MarketMaker.cc Team
Quantitative Research & Strategy
Suppose you optimized a strategy. The backtest shows PnL +55%, MaxDD -0.9%. You calculate MaxLev: . You multiply: . 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.
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:
Formula for a single payment:
With leverage and capital :
The standard MaxLev (Maximum Leverage) metric is the theoretical ceiling of leverage at which drawdown does not exceed the target level:
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.
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:
With holding period days and 3 payments per day:
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.
| Strategy | PnL | MaxDD | MaxLev | PnL@ML | Trades | Trading time |
|---|---|---|---|---|---|---|
| Strategy A | +55% | -0.9% | 55x | +3025% | ~500 | ~15% |
| Strategy B | +25% | -0.75% | 66x | +1650% | ~40 | ~5% |
| Strategy C | +300% | -17% | 3x | +900% | ~400 | ~45% |
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)
| Strategy | PnL@ML (no funding) | Funding cost | PnL@ML (with funding) | Status |
|---|---|---|---|---|
| Strategy A | +3025% | -185.6% | +2839% | Eats ~6% |
| Strategy B | +1650% | -74.3% | +1576% | Eats ~4.5% |
| Strategy C | +900% | -30.4% | +870% | Eats ~3% |
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.
The typical 0.01% funding rate is a median value. In reality, rates fluctuate:
| Market Phase | Typical funding rate | Per 8h at 55x | Per day at 55x |
|---|---|---|---|
| Calm market | 0.005% | 0.275% | 0.825% |
| Normal | 0.01% | 0.55% | 1.65% |
| Bullish trend | 0.03% | 1.65% | 4.95% |
| Extreme bullish | 0.1% | 5.50% | 16.5% |
| Flash pump | 0.5% | 27.5% | — |
At 55x leverage during a bullish market (0.03%): one day in a long position costs 4.95% of capital on funding alone.
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.
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:
This is already on the edge of liquidation. Now add funding:
If the drawdown lasts 3 days at a funding rate of 0.01%:
Total: — liquidation at the standard 50% maintenance margin.
where Funding buffer is the expected funding over the typical drawdown duration:
This is a recursive equation (the funding buffer depends on ). The solution:
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:
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.
As an example — how the funding rate affects safe leverage at different MaxDD levels:
| Funding regime | Average rate | MaxLev at DD=0.9% | MaxLev at DD=17% |
|---|---|---|---|
| Low (0.005%) | 0.005% | 53x | 3x |
| Typical (0.01%) | 0.01% | 50x | 3x |
| Elevated (0.03%) | 0.03% | 42x | 3x |
| High (0.05%) | 0.05% | 36x | 2x |
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.
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:
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.
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.
Instead of fixed leverage, use adaptive leverage:
When funding is elevated, leverage automatically decreases, limiting costs.
Funding rates must be a mandatory part of the backtesting pipeline:
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.
Funding rates are a tax on leverage. Like a real tax, they are unnoticeable at small amounts and devastating at large ones.
Three rules:
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.
Use the safe leverage formula:
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.
@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.} }