Funding rates verwoesten je hefboom: waarom PnL×50x fictie is

Stel dat je een strategie hebt geoptimaliseerd. De backtest laat PnL +55%, MaxDD -0,9% zien. Je berekent MaxLev: $\lfloor 50 / 0.9 \rfloor = 55\times$. Je vermenigvuldigt: $55\% \times 55 = +3025\%$. Drieduizend procent over twee jaar. Je bent in gedachten al je Lamborghini aan het uitzoeken.

Drie maanden na de livegang staat je kapitaal onder het startpunt. De strategie werkt exact zoals in de backtest — dezelfde entries, dezelfde exits, dezelfde drawdown. Maar je verliest geld. Elke dag. Consequent.

De reden: funding rates. Een onzichtbare kosten waar je backtest geen rekening mee hield — of verkeerd rekening mee hield.

Hoe funding rates werken

Op cryptobeurzen hebben perpetual swaps geen vervaldatum. Om de futuresprijs verankerd te houden aan de spotprijs, gebruiken beurzen een funding-mechanisme — periodieke betalingen tussen longs en shorts.

Werking op Binance/Bybit:

• Funding wordt elke 8 uur betaald (00:00, 08:00, 16:00 UTC)
• De funding rate wordt bepaald door het verschil tussen de futuresprijs en de spotprijs
• Als de funding rate positief is — betalen longs aan shorts
• Als negatief — betalen shorts aan longs
• Typisch tarief: $\pm 0.01\%$ per 8 uur (kan oplopen tot $\pm 0.5\%$ in extreme omstandigheden)

Formule voor een enkele betaling:

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

Met hefboom $L$ en kapitaal $C$:

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

Waarom backtests liegen over hefboom

De standaard MaxLev-metric (Maximum Leverage) is het theoretische plafond van de hefboom waarbij de drawdown het streefniveau niet overschrijdt:

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

Deze formule houdt geen rekening met kosten die afhangen van de hefboom. Bij 1x hefboom is de funding rate een verwaarloosbare kostenpost. Bij 58x is het een catastrofe.

Lineaire vs. kwadratische kosten

Handelscommissies (maker/taker fees) zijn lineair — ze zijn proportioneel aan het handelsvolume en hangen niet af van de hefboom. Funding rates zijn ook lineair ten opzichte van de positiegrootte, maar wanneer herberekend per eenheid kapitaal, groeien ze proportioneel met de hefboom:

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

Met een aanhoudperiode van $H$ dagen en 3 betalingen per dag:

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

Herberekening: voorbeeldstrategieën met funding meegerekend

Als voorbeeld beschouwen we drie hypothetische strategieën met verschillende risicoprofielen. Parameters: perpetual futures, testperiode van 25 maanden, typische funding rate van 0,01% per 8 uur.

Oorspronkelijke resultaten (zonder funding)

Berekening van de funding-kosten

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

Berekeningen:

a_funding = funding_cost(55, 0.15, 750)

b_funding = funding_cost(66, 0.05, 750)

c_funding = funding_cost(3, 0.45, 750)

Resultaten met funding meegerekend

Op het eerste gezicht lijkt dit acceptabel: funding eet 3-6% van de uiteindelijke PnL@ML op. Maar dit is de gemiddelde funding rate. Laten we zien wat er gebeurt bij verhoogde tarieven.

De funding rate is geen constante

De typische funding rate van 0,01% is een mediaan-waarde. In werkelijkheid schommelen de tarieven:

Bij 55x hefboom in een bullish markt (0,03%): kost één dag in een longpositie 4,95% van het kapitaal aan funding alleen.

PnL per actieve dag vs. funding per dag

Hier de essentiële berekening — dagelijks strategierendement versus dagelijkse kosten:

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

Met dit soort cijfers lijkt funding niet kritiek. Maar dit zijn gemiddelden. Het echte probleem zit elders.

Het echte probleem: funding tijdens een drawdown

Funding-kosten lopen continu op zolang de positie open is — ook tijdens drawdown-periodes. Bijvoorbeeld: een maximale drawdown van 0,9% (Strategie A) wordt bij 55x hefboom:

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

Dit staat al op de rand van liquidatie. Voeg nu funding toe:

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

Als de drawdown 3 dagen duurt bij een funding rate van 0,01%:

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

Totaal: $49.5\% + 4.95\% = 54.45\%$ — liquidatie bij de standaard maintenance margin van 50%.

Formule voor veilige hefboom met funding meegerekend

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

waarbij de funding buffer de verwachte funding is over de typische drawdown-duur:

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

Dit is een recursieve vergelijking (de funding buffer hangt af van $L$). De oplossing:

$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)

Conclusie: bij de typische funding rate is de veilige hefboom voor Strategie A 50x, niet 55x. Bij verhoogde funding — 42x. Het verschil in PnL@ML:

• Naïef: $55\% \times 55 = +3025\%$
• Met funding (0,01%): $55\% \times 50 - 165\% = +2585\%$
• Met funding (0,03%): $55\% \times 42 - 400\% = +1910\%$

Praktische integratie van funding in backtests

Rekening houden met funding rates in backtests is geen optie — het is een noodzaak. Hier een minimale implementatie:

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 een goed gebouwde backtesting-engine worden funding rates automatisch geladen en op elke trade toegepast. Dit geeft een realistisch beeld — en dat is vaak minder rooskleurig dan men zou willen.

Realistisch hefboombereik

Als voorbeeld — hoe de funding rate de veilige hefboom beïnvloedt bij verschillende MaxDD-niveaus:

Belangrijke observatie: voor strategieën met een lage drawdown (Strategie A, B) vermindert funding de effectieve hefboom aanzienlijk. Voor strategieën met een hoge drawdown (Strategie C) is de impact van funding minimaal — omdat de hefboom al beperkt is tot 3x.

Strategieën om de impact van funding te minimaliseren

1. Hedge-neutrale posities

De funding rate wordt bepaald door het verschil tussen de futuresprijs en de spotprijs. Als je strategie hedging via spot toestaat — wordt funding geneutraliseerd:

• Long futures + short spot = 0 netto blootstelling aan funding
• Maar: shorten van spot in crypto is beperkt (vereist een margin-account of lenen)

2. Overstappen naar beurzen met lagere funding

Verschillende beurzen hebben verschillende funding rates voor hetzelfde asset. Het monitoren van funding-arbitrage is een aparte strategie, uitgebreid beschreven in het artikel Funding Rate Arbitrage Across Exchanges.

3. Timing van entries

Funding wordt op vaste tijden betaald (00:00, 08:00, 16:00 UTC). Als een trade een minuut voor een betaling sluit — wordt er geen funding in rekening gebracht. Dit is een micro-optimalisatie, maar bij 58x hefboom is het besparen van 0,58% door één overgeslagen betaling significant.

4. Dynamische hefboom

Gebruik in plaats van een vaste hefboom een adaptieve hefboom:

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

Wanneer funding verhoogd is, neemt de hefboom automatisch af, waardoor kosten worden beperkt.

Aanbevelingen voor het integreren van funding in de pipeline

Funding rates moeten een verplicht onderdeel zijn van de backtesting-pipeline:

• Laad historische funding rates voor elk symbool
• Corrigeer elke trade voor de werkelijke funding over de aanhoudperiode
• Bereken MaxLev met de formule inclusief funding buffer
• Toon in het rapport beide cijfers: PnL@ML zonder funding en met funding

Praktische regel: als een strategie niet langer winstgevend is bij een funding rate van 0,03% (wat 20-30% van de tijd voorkomt tijdens een bullmarkt) — is deze niet klaar voor productie met hoge hefboom. Verlaag de hefboom tot een niveau waarbij de strategie zelfs in het worst-case funding-scenario winstgevend is.

Conclusie

Funding rates zijn een belasting op hefboom. Net als een echte belasting zijn ze onmerkbaar bij kleine bedragen en verwoestend bij grote bedragen.

Drie regels:

1. Bereken PnL@ML altijd met funding meegerekend. De formule zonder funding is marketing, geen trading. Laad historische funding rates en trek de werkelijke kosten van elke trade af.

2. Gebruik de formule voor veilige hefboom:

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

3. Test bij 3x funding. Als de strategie winstgevend is bij 0,03% funding (niet alleen 0,01%) — is deze robuust. Zo niet — verlaag de hefboom.

Mooie PnL-cijfers bij 50-60x hefboom zijn een aangename illusie. Funding rates zijn de koude realiteit. Daartussen ligt het verschil tussen een backtest en een handelsrekening.

Voor meer over de wiskunde van drawdowns en volatility drag bij hoge hefboom — zie ons artikel Loss-Profit Asymmetry. Over hoe je betrouwbaarheidsintervallen krijgt voor funding-gecorrigeerde resultaten — Monte Carlo Bootstrap for Backtests.

Nuttige 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

Citatie

@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.}
}