Funding Rates Kill Your Leverage: Why PnL×50x Is a Fiction

Suppose you optimized a strategy. The backtest shows PnL +55%, MaxDD -0.9%. You calculate MaxLev: $\lfloor 50 / 0.9 \rfloor = 55\times$. You multiply: $55\% \times 55 = +3025\%$. Three thousand percent over two years. You are already mentally picking out your Lamborghini.

Three months into production, your capital is below the starting point. The strategy works exactly as backtested — same entries, same exits, same drawdown. But you are losing money. Every day. Consistently.

The reason: funding rates. An invisible fee that your backtest did not account for — or accounted for incorrectly.

How Funding Rates Work

On cryptocurrency exchanges, perpetual swaps have no expiration date. To keep the futures price anchored to the spot price, exchanges use a funding mechanism — periodic payments between longs and shorts.

Mechanics on Binance/Bybit:

• Funding is paid every 8 hours (00:00, 08:00, 16:00 UTC)
• The funding rate is determined by the difference between the futures price and the spot price
• If the funding rate is positive — longs pay shorts
• If negative — shorts pay longs
• Typical rate: $\pm 0.01\%$ per 8 hours (can reach $\pm 0.5\%$ in extreme conditions)

Formula for a single payment:

$\text{Funding cost} = \text{Position size} \times \text{Funding rate}$

With leverage $L$ and capital $C$:

$\text{Funding cost} = C \times L \times \text{Rate}$

Why Backtests Lie About Leverage

The standard MaxLev (Maximum Leverage) metric is the theoretical ceiling of leverage at which drawdown does not exceed the target level:

$\text{MaxLev} = \left\lfloor \frac{\text{Target DD}}{\text{MaxDD}} \right\rfloor$

This formula does not account for costs that depend on leverage. At 1x leverage, the funding rate is an insignificant fee. At 58x — it is a catastrophe.

Linear vs Quadratic Costs

Trading commissions (maker/taker fees) are linear — they are proportional to trade volume and do not depend on leverage. Funding rates are also linear with respect to position size, but when recalculated per unit of capital, they grow proportionally to leverage:

$\text{Funding cost per capital} = L \times \text{Rate} \times \text{Frequency}$

With holding period $H$ days and 3 payments per day:

$\text{Total funding} = L \times \text{Rate} \times 3 \times H$

Recalculation: Strategy Examples Accounting for Funding

As an example, consider three hypothetical strategies with different risk profiles. Parameters: perpetual futures, 25-month test period, typical funding rate of 0.01% per 8 hours.

Original Results (Without Funding)

Calculating Funding Cost

def funding_cost(
    leverage: float,
    trading_time_pct: float,
    test_days: int = 750,  # 25 months
    funding_rate: float = 0.0001,  # 0.01% per 8h
    payments_per_day: int = 3,
) -> float:
    """
    Calculate cumulative funding costs as % of capital.

    Returns:
        Funding cost as percentage of initial capital
    """
    active_days = test_days * trading_time_pct
    daily_cost = funding_rate * payments_per_day * leverage
    total_cost = daily_cost * active_days
    return total_cost * 100  # in percent

Calculations:

a_funding = funding_cost(55, 0.15, 750)

b_funding = funding_cost(66, 0.05, 750)

c_funding = funding_cost(3, 0.45, 750)

Results Accounting for Funding

At first glance this seems tolerable: funding eats 3-6% of the final PnL@ML. But this is the average funding rate. Let us see what happens at elevated rates.

Funding Rate Is Not a Constant

The typical 0.01% funding rate is a median value. In reality, rates fluctuate:

At 55x leverage during a bullish market (0.03%): one day in a long position costs 4.95% of capital on funding alone.

PnL per Active Day vs Funding per Day

Here is the key calculation — daily strategy return versus daily costs:

a_pnl_per_day = 55 * 55 / 112.5  # PnL@ML / active days = 26.9%/day



b_pnl_per_day = 25 * 66 / 37.5  # = 44.0%/day

With numbers like these, funding seems non-critical. But these are averages. The problem lies elsewhere.

The Real Problem: Funding During Drawdown

Funding costs accumulate continuously while the position is open — including during drawdown periods. For example: a maximum drawdown of 0.9% (Strategy A) at 55x leverage becomes:

$\text{Effective DD} = 0.9\% \times 55 = 49.5\%$

This is already on the edge of liquidation. Now add funding:

$\text{DD with funding} = 49.3\% + \text{accumulated funding during DD period}$

If the drawdown lasts 3 days at a funding rate of 0.01%:

$\text{Funding over 3 days} = 0.0001 \times 3 \times 55 \times 3 = 4.95\%$

Total: $49.5\% + 4.95\% = 54.45\%$ — liquidation at the standard 50% maintenance margin.

Safe Leverage Formula Accounting for Funding

$L_{safe} = \frac{\text{Target DD} - \text{Funding buffer}}{|\text{MaxDD}|}$

where Funding buffer is the expected funding over the typical drawdown duration:

$\text{Funding buffer} = \text{Rate} \times 3 \times L \times \text{DD duration (days)}$

This is a recursive equation (the funding buffer depends on $L$). The solution:

$L_{safe} = \frac{\text{Target DD}}{|\text{MaxDD}| + \text{Rate} \times 3 \times \text{DD duration}}$

def safe_leverage(
    max_dd_pct: float,
    target_dd_pct: float = 50.0,
    funding_rate: float = 0.0001,
    dd_duration_days: float = 3.0,
) -> float:
    """
    Safe leverage accounting for funding costs during drawdown.
    """
    denominator = max_dd_pct / 100 + funding_rate * 3 * dd_duration_days
    return target_dd_pct / 100 / denominator

a_safe = safe_leverage(0.9, 50.0, 0.0001, 3.0)

a_safe_high = safe_leverage(0.9, 50.0, 0.0003, 3.0)

Conclusion: at the typical funding rate, safe leverage for Strategy A is 50x, not 55x. At elevated funding — 42x. The difference in PnL@ML:

• Naive: $55\% \times 55 = +3025\%$
• With funding (0.01%): $55\% \times 50 - 165\% = +2585\%$
• With funding (0.03%): $55\% \times 42 - 400\% = +1910\%$

Practical Integration of Funding Into Backtests

Accounting for funding rates in backtests is not optional — it is a necessity. Here is a minimal implementation:

import pandas as pd
import numpy as np

def load_funding_rates(symbol: str) -> pd.DataFrame:
    """Load historical funding rates from warehouse."""
    path = f"warehouse/data/{symbol}/funding/"
    return df  # columns: [timestamp, rate]

def apply_funding_to_trades(trades, funding_rates, leverage: int = 1):
    """
    Subtract real funding costs from each trade's PnL.
    """
    for trade in trades:
        mask = (
            (funding_rates.index >= trade.entry_time) &
            (funding_rates.index <= trade.exit_time)
        )
        payments = funding_rates.loc[mask, 'rate']

        direction = 1 if trade.side == 'long' else -1
        total_funding = payments.sum() * direction * leverage

        trade.pnl_pct -= total_funding * 100

    return trades

In a well-built backtesting engine, funding rates are loaded and applied to each trade automatically. This provides a realistic picture — and it is often less rosy than one would like.

Realistic Leverage Range

As an example — how the funding rate affects safe leverage at different MaxDD levels:

Key observation: for strategies with low drawdown (Strategy A, B), funding significantly reduces effective leverage. For strategies with high drawdown (Strategy C), funding impact is minimal — because leverage is already limited to 3x.

Strategies for Minimizing Funding Impact

1. Hedge-Neutral Positions

The funding rate is determined by the difference between the futures price and the spot price. If your strategy allows hedging through spot — funding is neutralized:

• Long futures + short spot = 0 net exposure to funding
• But: shorting spot in crypto is limited (requires a margin account or lending)

2. Moving to Exchanges with Lower Funding

Different exchanges have different funding rates for the same asset. Monitoring funding arbitrage is a separate strategy, described in detail in the article Funding Rate Arbitrage Across Exchanges.

3. Timing Entries

Funding is paid at fixed times (00:00, 08:00, 16:00 UTC). If a trade closes one minute before a payment — the funding is not charged. This is a micro-optimization, but at 58x leverage, saving 0.58% from one skipped payment is significant.

4. Dynamic Leverage

Instead of fixed leverage, use adaptive leverage:

$L_{dynamic} = L_{base} \times \frac{\text{Rate}_{median}}{\max(\text{Rate}_{current}, \text{Rate}_{median})}$

When funding is elevated, leverage automatically decreases, limiting costs.

Recommendations for Integrating Funding Into the Pipeline

Funding rates must be a mandatory part of the backtesting pipeline:

• Load historical funding rates for each symbol
• Adjust each trade for actual funding over the holding period
• Calculate MaxLev using the formula with funding buffer
• In the report, display both numbers: PnL@ML without funding and with funding

Practical rule: if a strategy stops being profitable at a funding rate of 0.03% (which occurs 20-30% of the time during a bull market) — it is not ready for production at high leverage. Reduce leverage to a level at which the strategy is profitable even in the worst-case funding scenario.

Conclusion

Funding rates are a tax on leverage. Like a real tax, they are unnoticeable at small amounts and devastating at large ones.

Three rules:

1. Always calculate PnL@ML accounting for funding. The formula without funding is marketing, not trading. Load historical funding rates and subtract real costs from each trade.

2. Use the safe leverage formula:

$L_{safe} = \frac{\text{Target DD}}{|\text{MaxDD}| + \text{Rate} \times 3 \times \text{DD duration}}$

3. Test at 3x funding. If the strategy is profitable at 0.03% funding (not just 0.01%) — it is robust. If not — reduce leverage.

Beautiful PnL numbers at 50-60x leverage are a pleasant illusion. Funding rates are cold reality. Between them lies the difference between a backtest and a trading account.

For more on the mathematics of drawdowns and volatility drag at high leverage — see our article Loss-Profit Asymmetry. On how to obtain confidence intervals for funding-adjusted results — Monte Carlo Bootstrap for Backtests.

Useful Links

1. Binance — Funding Rate History
2. Binance — Introduction to Funding Rates
3. Bybit — Understanding Funding Rates
4. Deribit Insights — The Hidden Cost of Perpetual Swaps
5. Lopez de Prado — Advances in Financial Machine Learning, Chapter 14: Backtest Statistics
6. Kevin Davey — Building Winning Algorithmic Trading Systems: Transaction Costs

Citation

@article{soloviov2026fundingratesleverage,
  author = {Soloviov, Eugen},
  title = {Funding Rates Kill Your Leverage: Why PnL×50x Is a Fiction},
  year = {2026},
  url = {https://marketmaker.cc/ru/blog/post/funding-rates-kill-leverage},
  version = {0.1.0},
  description = {How funding rates on Binance/Bybit turn beautiful high-leverage backtest results into guaranteed losses. Formulas, recalculation of real strategies, and the maximum leverage at which funding does not eat into profits.}
}