Funding Rate Arbitrage Tussen Exchanges: Hoe Winst te Maken uit Renteverschillen

De funding rate op ETHUSDT is 0,01% op Binance en 0,035% op Bybit. Dezelfde coin, hetzelfde moment, maar de rates verschillen 3,5 keer. De één betaalt meer, de ander minder. En iemand profiteert van dit verschil.

Funding rate arbitrage is een van de weinige strategieën in crypto die niet afhankelijk is van de marktrichting. Je voorspelt de prijs niet. Je haalt winst uit de structurele divergentie van rates tussen platforms.

Waarom Funding Rates Verschillen Tussen Exchanges

De funding rate is een mechanisme dat de prijs van een perpetual futures-contract verankert aan de spotprijs. Elke exchange berekent dit onafhankelijk op basis van eigen data:

• Samenstelling van traders. Binance wordt gedomineerd door retailtraders die de neiging hebben long te gaan. Bybit en OKX hebben meer professionele deelnemers. Een verschillende long/short-balans leidt tot verschillende funding.
• Berekeningsformule. Elke exchange gebruikt zijn eigen formule. Binance neemt de premium-index en de rentevoet mee. Bybit en OKX doen hetzelfde, maar met andere wegingen en middelingsperiodes.
• Liquiditeit. Op minder liquide exchanges is de premium (verschil tussen futures en spot) volatieler, waardoor funding sterker fluctueert.
• Betalingsfrequentie. De meeste exchanges betalen funding elke 8 uur (00:00, 08:00, 16:00 UTC). Maar sommige (Bybit voor bepaalde paren, dYdX) betalen elk uur, wat extra mogelijkheden creëert.

Typische Divergenties

In een rustige markt liggen de funding rates op grote exchanges dicht bij elkaar — het verschil is 0,001-0,005%. Maar tijdens periodes van verhoogde volatiliteit groeien de divergenties:

Een spread van 0,025% per 8 uur is 0,075% per dag. Bij een positiegrootte van $100K is dat$75/dag oftewel ~$2.250/maand — zonder directioneel risico.

Basisprincipes van Arbitrage

Het idee is simpel: open tegengestelde posities op twee exchanges zodat je op de ene funding ontvangt en op de andere minder betaalt.

Voorbeeld

Binance: funding rate = +0,01% (longs betalen shorts) Bybit: funding rate = +0,04% (longs betalen shorts)

Acties:

1. Open een short op Bybit — ontvang 0,04% elke 8 uur
2. Open een long op Binance — betaal 0,01% elke 8 uur
3. Posities zijn gespiegeld — prijsrisico is neutraal
4. Netto winst: 0,04% - 0,01% = 0,03% per 8 uur

Per dag (3 betalingen): 0,09%. Per maand: ~2,7%. Zonder directioneel risico.

def funding_arbitrage_pnl(
    rate_short_exchange: float,  # rate on the exchange where we short
    rate_long_exchange: float,   # rate on the exchange where we long
    position_size: float,        # position size in USD
    payments_per_day: int = 3,
    days: int = 30,
) -> float:
    """
    PnL from funding rate arbitrage over a period.

    With positive funding: short receives, long pays.
    With negative funding: short pays, long receives.
    """
    spread = rate_short_exchange - rate_long_exchange
    daily_pnl = spread * payments_per_day * position_size
    return daily_pnl * days

pnl = funding_arbitrage_pnl(0.0004, 0.0001, 100_000, days=30)

Risico's en Valkuilen

De strategie lijkt op "gratis geld". Dat is het niet. Er zijn verschillende serieuze risico's.

1. Prijsdivergentie Tussen Exchanges

Posities op verschillende exchanges staan niet op dezelfde prijs. De spread tussen Binance en Bybit is doorgaans 0,01-0,05%, maar tijdens momenten van hoge volatiliteit kan die 0,5-1% bereiken. Als je posities niet gelijktijdig opent, kan de divergentie de funding-winst overtreffen.

Oplossing: gelijktijdige opening via API met minimale latentie. Idealiter — gecolokeerde servers dicht bij beide exchanges.

2. Veranderingen in de Funding Rate

Je opent posities bij een spread van 0,03%. Een uur later versmalt de spread naar 0,005% of keert om. Nu betaal je op beide exchanges.

Oplossing: real-time spread-monitoring en automatisch sluiten wanneer de spread onder een drempel zakt.

def should_close(
    current_spread: float,
    entry_spread: float,
    min_spread: float = 0.0001,     # 0.01%
    trading_costs: float = 0.0005,  # 0.05% for opening + closing
) -> bool:
    """
    Close the position if the spread has fallen below the threshold
    or if the current spread does not cover trading costs.
    """
    return current_spread < min_spread or current_spread < trading_costs

3. Handelscommissies

Het openen en sluiten van posities op twee exchanges betekent 4 orders. Bij een maker fee van 0,02% en een taker fee van 0,05%:

• Optimistisch scenario (alles maker): $4 \times 0,02\% = 0,08\%$
• Pessimistisch scenario (alles taker): $4 \times 0,05\% = 0,20\%$

Om de commissies terug te verdienen, moet de positie lang genoeg worden aangehouden:

$\text{Break-even tijd} = \frac{\text{Totale commissies}}{\text{Spread} \times \text{Betalingen per dag}}$

def breakeven_days(
    total_commissions_pct: float,  # total commissions in %
    spread: float,                  # funding rate spread
    payments_per_day: int = 3,
) -> float:
    daily_income = spread * payments_per_day
    return total_commissions_pct / daily_income if daily_income > 0 else float('inf')

4. Margevereisten

Posities op beide exchanges vereisen onderpand. Bij 5x hefboom op elke exchange met een positie van $100K:

• Binance: $20K onderpand
• Bybit: $20K onderpand
• Totaal vastgezet: **$40K** voor een positie van$100K

Rendement op kapitaal: $\text{ROC} = \frac{\$2700}{\$40000} \times 100\% = 6,75\% \text{ per maand}$

Bij 10x hefboom daalt het onderpand naar $20K, stijgt de ROC naar 13,5%. Maar het liquidatierisico door prijsdivergentie neemt ook toe.

5. Liquidatierisico

Als de prijs van het asset sterk beweegt, ontstaat er op een van de posities een ongerealiseerd verlies. Op de exchange met de verliesgevende positie moet marge worden aangehouden. Als de marge onvoldoende is — liquidatie. Ondertussen helpt de winst op de andere exchange niet — die staat op een andere rekening.

Oplossing:

• Houd een margereserve aan (minstens 2x het minimum)
• Stel meldingen voor marge-niveau in
• Automatisch herbalanceren: bij een onevenwicht — geld overboeken tussen exchanges

Funding Rate Monitoringsysteem

De eerste stap richting arbitrage is dataverzameling. Je moet funding rates op alle relevante exchanges in real time volgen.

import asyncio
import ccxt.pro as ccxt
from dataclasses import dataclass
from datetime import datetime

@dataclass
class FundingSnapshot:
    exchange: str
    symbol: str
    rate: float
    next_funding_time: datetime
    timestamp: datetime

class FundingMonitor:
    """
    Monitor funding rates across multiple exchanges.
    """
    def __init__(self, symbols: list[str], exchanges: list[str]):
        self.symbols = symbols
        self.exchanges = {
            name: getattr(ccxt, name)() for name in exchanges
        }
        self.latest: dict[str, dict[str, FundingSnapshot]] = {}

    async def fetch_funding(self, exchange_name: str, exchange, symbol: str):
        """Fetch current funding rate from an exchange."""
        try:
            funding = await exchange.fetch_funding_rate(symbol)
            return FundingSnapshot(
                exchange=exchange_name,
                symbol=symbol,
                rate=funding['fundingRate'],
                next_funding_time=datetime.fromtimestamp(
                    funding['fundingTimestamp'] / 1000
                ),
                timestamp=datetime.utcnow(),
            )
        except Exception as e:
            print(f"Error fetching {exchange_name} {symbol}: {e}")
            return None

    async def scan(self) -> list[dict]:
        """
        Scan all exchanges and find arbitrage opportunities.
        """
        tasks = []
        for ex_name, ex in self.exchanges.items():
            for symbol in self.symbols:
                tasks.append(self.fetch_funding(ex_name, ex, symbol))

        snapshots = await asyncio.gather(*tasks)
        snapshots = [s for s in snapshots if s is not None]

        by_symbol: dict[str, list[FundingSnapshot]] = {}
        for s in snapshots:
            by_symbol.setdefault(s.symbol, []).append(s)

        opportunities = []
        for symbol, rates in by_symbol.items():
            rates.sort(key=lambda x: x.rate)
            lowest = rates[0]   # long here (pay less)
            highest = rates[-1] # short here (receive more)
            spread = highest.rate - lowest.rate

            opportunities.append({
                'symbol': symbol,
                'long_exchange': lowest.exchange,
                'long_rate': lowest.rate,
                'short_exchange': highest.exchange,
                'short_rate': highest.rate,
                'spread': spread,
                'annualized': spread * 3 * 365 * 100,  # in % annualized
            })

        return sorted(opportunities, key=lambda x: -x['spread'])

Voorbeeldoutput

Symbol     | Long @      | Rate    | Short @     | Rate    | Spread  | APR
-----------+-------------+---------+-------------+---------+---------+--------
ETHUSDT    | Binance     | 0.010%  | Bybit       | 0.040%  | 0.030%  | 32.9%
BTCUSDT    | OKX         | 0.008%  | Binance     | 0.020%  | 0.012%  | 13.1%
SOLUSDT    | Binance     | 0.015%  | dYdX        | 0.055%  | 0.040%  | 43.8%
ARBUSDT    | Bybit       | 0.005%  | OKX         | 0.030%  | 0.025%  | 27.4%

Uitvoering: Gelijktijdig Openen van Posities

Het is cruciaal om de long en short zo gelijktijdig mogelijk te openen om directionele risicoblootstelling te vermijden.

import asyncio

async def execute_arbitrage(
    long_exchange,
    short_exchange,
    symbol: str,
    size: float,
    max_slippage_pct: float = 0.05,
):
    """
    Simultaneously open a long and short on two exchanges.
    """
    long_ticker = await long_exchange.fetch_ticker(symbol)
    short_ticker = await short_exchange.fetch_ticker(symbol)

    price_spread = abs(
        long_ticker['ask'] - short_ticker['bid']
    ) / long_ticker['ask'] * 100

    if price_spread > max_slippage_pct:
        raise ValueError(
            f"Price spread {price_spread:.3f}% exceeds max slippage"
        )

    long_order, short_order = await asyncio.gather(
        long_exchange.create_market_buy_order(symbol, size),
        short_exchange.create_market_sell_order(symbol, size),
    )

    return long_order, short_order

Positiebeheer

Na het openen is continue monitoring vereist:

1. Funding rate spread. Als de spread onder de drempel krimpt — sluiten.
2. Marge-balans. Als de marge op een exchange onder het veilige niveau zakt — herbalanceren of sluiten.
3. Prijsdivergentie. Als de ongerealiseerde P&L aan één kant de limiet overschrijdt — sluiten.

async def monitor_and_manage(
    long_exchange,
    short_exchange,
    symbol: str,
    size: float,
    min_spread: float = 0.0001,
    max_unrealized_loss_pct: float = 2.0,
    check_interval: int = 60,
):
    """
    Monitor an open arbitrage position.
    """
    while True:
        long_funding = await long_exchange.fetch_funding_rate(symbol)
        short_funding = await short_exchange.fetch_funding_rate(symbol)
        current_spread = (
            short_funding['fundingRate'] - long_funding['fundingRate']
        )

        long_balance = await long_exchange.fetch_balance()
        short_balance = await short_exchange.fetch_balance()

        long_positions = await long_exchange.fetch_positions([symbol])
        short_positions = await short_exchange.fetch_positions([symbol])

        long_upnl = long_positions[0]['unrealizedPnl'] if long_positions else 0
        short_upnl = short_positions[0]['unrealizedPnl'] if short_positions else 0

        total_upnl_pct = (long_upnl + short_upnl) / size * 100

        if current_spread < min_spread:
            print(f"Spread collapsed: {current_spread:.4%}")
            await close_both(long_exchange, short_exchange, symbol, size)
            break

        if abs(total_upnl_pct) > max_unrealized_loss_pct:
            print(f"Unrealized loss exceeded: {total_upnl_pct:.2f}%")
            await close_both(long_exchange, short_exchange, symbol, size)
            break

        await asyncio.sleep(check_interval)

Geavanceerde Varianten

Spot-Perp Arbitrage

In plaats van futures op twee exchanges, kun je spot + futures op één exchange gebruiken:

• Spot kopen (geen funding)
• De perpetual futures shorten (funding ontvangen wanneer de rate positief is)

Voordeel: alles op één exchange, eenvoudiger margebeheer. Nadeel: werkt alleen bij positieve funding (longs betalen shorts), wat ~70% van de tijd voorkomt tijdens een bullmarkt.

def spot_perp_carry(
    funding_rate: float,      # current funding rate
    spot_fee: float = 0.001,  # spot commission (0.1%)
    perp_fee: float = 0.0005, # futures commission (0.05%)
    leverage: int = 1,
) -> dict:
    """
    Calculate the yield of a spot-perp carry trade.
    """
    total_fees = (spot_fee + perp_fee) * 2  # opening + closing

    daily_income = funding_rate * 3

    breakeven_days = total_fees / daily_income if daily_income > 0 else float('inf')

    return {
        'daily_income_pct': daily_income * 100,
        'monthly_income_pct': daily_income * 30 * 100,
        'annualized_pct': daily_income * 365 * 100,
        'total_fees_pct': total_fees * 100,
        'breakeven_days': breakeven_days,
    }

result = spot_perp_carry(0.0003)

Multi-Exchange Arbitrage

Bij het gelijktijdig monitoren van 5+ exchanges kun je gunstigere kansen vinden. Algoritme:

1. Verzamel funding rates van alle exchanges
2. Vind het paar met de maximale spread
3. Controleer liquiditeit en orderboekdiepte op beide exchanges
4. Als spread > drempel — open posities
5. Continu opnieuw scannen: als het beste paar verandert — roteren

def find_best_pair(
    rates: dict[str, float],  # {"binance": 0.01, "bybit": 0.04, "okx": 0.02}
    min_spread: float = 0.0002,
) -> tuple[str, str, float] | None:
    """
    Find the exchange pair with the maximum funding rate spread.
    Returns: (long_exchange, short_exchange, spread) or None.
    """
    exchanges = list(rates.keys())
    best = None

    for i, ex_long in enumerate(exchanges):
        for ex_short in exchanges[i+1:]:
            if rates[ex_long] < rates[ex_short]:
                spread = rates[ex_short] - rates[ex_long]
                long_ex, short_ex = ex_long, ex_short
            else:
                spread = rates[ex_long] - rates[ex_short]
                long_ex, short_ex = ex_short, ex_long

            if spread >= min_spread:
                if best is None or spread > best[2]:
                    best = (long_ex, short_ex, spread)

    return best

Voorspelling van de Funding Rate

De funding rate wordt berekend met een formule die de premium-index bevat — het verschil tussen de futures-prijs en de spotprijs. De premium wordt vaker bijgewerkt dan funding (elke minuut versus elke 8 uur). Dat betekent dat je de volgende funding rate minuten of uren vóór de betaling kunt voorspellen.

def predict_next_funding(
    premium_index: float,
    interest_rate: float = 0.0001,  # 0.01% per 8h (standard)
    clamp_range: float = 0.0005,    # ±0.05%
) -> float:
    """
    Predict the next funding rate based on the current premium index.
    Binance formula: FR = clamp(Premium - Interest, -0.05%, 0.05%) + Interest
    """
    diff = premium_index - interest_rate
    clamped = max(-clamp_range, min(clamp_range, diff))
    return clamped + interest_rate

Als je de voorspelde funding rate kent, kun je posities openen vóór de betaling, wanneer de spread nog niet de aandacht van andere arbitrageurs heeft getrokken.

Infrastructuurvereisten

Voor serieuze funding rate arbitrage heb je infrastructuur nodig:

Economie op Verschillende Schalen

De ROC hangt niet af van de schaal (gegeven voldoende liquiditeit). Maar de absolute winst bij $10K kapitaal rechtvaardigt mogelijk niet de infrastructuurkosten en tijd.

Conclusie

Funding rate arbitrage is een structurele, delta-neutrale strategie. Het vereist geen prijsvoorspelling, maar het vereist wel:

1. Infrastructuur — real-time monitoring van rates op meerdere exchanges
2. Uitvoeringssnelheid — gelijktijdig openen van posities op verschillende platforms
3. Risicobeheer — controle van marge, prijsdivergentie en spread-veranderingen
4. Kapitaal — winst is evenredig met de positiegrootte

Funding rate spreads zijn niet constant. Ze verbreden tijdens periodes van volatiliteit en versmallen tijdens rustige periodes. De taak is om divergenties automatisch te vinden en te benutten zolang ze bestaan.

Voor meer over hoe funding rates gehefboomde strategieën beïnvloeden — zie het artikel Funding Rates Kill Your Leverage: Why PnL×50x Is a Fiction.

Nuttige Links

1. Binance — Funding Rate History
2. Binance — Introduction to Funding Rates
3. Bybit — Understanding Funding Rates
4. dYdX — Perpetual Funding Rate Mechanism
5. Coinglass — Funding Rate Monitor

Citatie

@article{soloviov2026fundingarbitrage,
  author = {Soloviov, Eugen},
  title = {Funding Rate Arbitrage Across Exchanges: How to Profit from Rate Differences},
  year = {2026},
  url = {https://marketmaker.cc/ru/blog/post/funding-rate-arbitrage-cross-exchange},
  description = {How funding rate arbitrage works across crypto exchanges, why rates differ on Binance, Bybit, OKX and dYdX, and how to build a monitoring and execution system.}
}