Funding-Rate-Arbitrage über Exchanges hinweg: Wie man von Ratenunterschieden profitiert

Die Funding Rate für ETHUSDT liegt auf Binance bei 0,01 % und auf Bybit bei 0,035 %. Dieselbe Münze, derselbe Zeitpunkt, aber die Raten unterscheiden sich um das 3,5-fache. Jemand zahlt mehr, jemand zahlt weniger. Und jemand profitiert von dieser Differenz.

Funding-Rate-Arbitrage ist eine der wenigen Strategien im Krypto-Markt, die nicht von der Marktrichtung abhängt. Man sagt den Preis nicht voraus. Man extrahiert Profit aus der strukturellen Divergenz der Raten zwischen den Handelsplätzen.

Warum sich Funding Rates zwischen Exchanges unterscheiden

Die Funding Rate ist ein Mechanismus, der den Preis eines perpetuellen Futures-Kontrakts an den Spotpreis bindet. Jede Exchange berechnet sie unabhängig anhand ihrer eigenen Daten:

• Trader-Zusammensetzung. Binance wird von Retail-Tradern dominiert, die tendenziell long gehen. Bybit und OKX haben mehr professionelle Teilnehmer. Ein unterschiedliches Long/Short-Verhältnis führt zu unterschiedlichem Funding.
• Berechnungsformel. Jede Exchange verwendet ihre eigene Formel. Binance bezieht den Premium-Index und den Zinssatz ein. Bybit und OKX tun dasselbe, aber mit unterschiedlichen Gewichtungen und Mittelungszeiträumen.
• Liquidität. Auf weniger liquiden Exchanges ist die Prämie (Differenz zwischen Futures und Spot) volatiler, was zu stärkeren Schwankungen des Fundings führt.
• Zahlungsfrequenz. Die meisten Exchanges zahlen Funding alle 8 Stunden (00:00, 08:00, 16:00 UTC). Einige (Bybit für bestimmte Paare, dYdX) zahlen jedoch stündlich, was zusätzliche Möglichkeiten schafft.

Typische Divergenzen

In einem ruhigen Markt liegen die Funding Rates auf großen Exchanges nah beieinander — die Differenz beträgt 0,001-0,005 %. Aber in Phasen erhöhter Volatilität wachsen die Divergenzen:

Ein Spread von 0,025 % pro 8 Stunden entspricht 0,075 % pro Tag. Bei einer Positionsgröße von 100.000 $sind das 75$/Tag bzw. ~2.250 $/Monat — ohne Richtungsrisiko.

Grundlegende Arbitrage-Mechanik

Die Idee ist einfach: entgegengesetzte Positionen auf zwei Exchanges eröffnen, sodass man auf der einen Funding erhält und auf der anderen weniger zahlt.

Beispiel

Binance: Funding Rate = +0,01 % (Longs zahlen Shorts) Bybit: Funding Rate = +0,04 % (Longs zahlen Shorts)

Vorgehen:

1. Short auf Bybit eröffnen — alle 8 Stunden 0,04 % erhalten
2. Long auf Binance eröffnen — alle 8 Stunden 0,01 % zahlen
3. Positionen sind gespiegelt — das Preisrisiko ist neutral
4. Nettogewinn: 0,04 % - 0,01 % = 0,03 % pro 8 Stunden

Pro Tag (3 Zahlungen): 0,09 %. Pro Monat: ~2,7 %. Ohne Richtungsrisiko.

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)

Risiken und Fallstricke

Die Strategie sieht nach "kostenlosem Geld" aus. Das ist sie nicht. Es gibt mehrere ernsthafte Risiken.

1. Preisdivergenz zwischen Exchanges

Positionen auf verschiedenen Exchanges liegen nicht beim gleichen Preis. Der Spread zwischen Binance und Bybit beträgt normalerweise 0,01-0,05 %, kann aber in Momenten hoher Volatilität 0,5-1 % erreichen. Wenn Positionen nicht gleichzeitig eröffnet werden, kann die Divergenz den Funding-Gewinn übersteigen.

Lösung: gleichzeitige Eröffnung über die API mit minimaler Latenz. Idealerweise — kollokierte Server nahe beiden Exchanges.

2. Änderungen der Funding Rate

Man eröffnet Positionen bei einem Spread von 0,03 %. Eine Stunde später verengt sich der Spread auf 0,005 % oder kehrt sich um. Jetzt zahlt man auf beiden Exchanges.

Lösung: Echtzeit-Spread-Monitoring und automatisches Schließen, wenn der Spread unter eine Schwelle fällt.

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. Handelsgebühren

Das Eröffnen und Schließen von Positionen auf zwei Exchanges bedeutet 4 Orders. Bei einer Maker-Gebühr von 0,02 % und einer Taker-Gebühr von 0,05 %:

• Optimistisches Szenario (alles Maker): $4 \times 0,02\% = 0,08\%$
• Pessimistisches Szenario (alles Taker): $4 \times 0,05\% = 0,20\%$

Damit sich die Gebühren amortisieren, muss die Position lange genug gehalten werden:

$\text{Breakeven-Zeit} = \frac{\text{Gesamtgebühren}}{\text{Spread} \times \text{Zahlungen pro Tag}}$

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. Margin-Anforderungen

Positionen auf beiden Exchanges erfordern Sicherheiten. Bei 5-fachem Hebel auf jeder Exchange mit einer Position von 100.000 $:

• Binance: 20.000 $ Sicherheit
• Bybit: 20.000 $ Sicherheit
• Insgesamt gebunden: **40.000 $** für eine Position von 100.000$

Kapitalrendite: $\text{ROC} = \frac{\$2700}{\$40000} \times 100\% = 6,75\% \text{ pro Monat}$

Bei 10-fachem Hebel sinkt die Sicherheit auf 20.000 $, die ROC steigt auf 13,5 %. Aber auch das Liquidationsrisiko durch Preisdivergenz steigt.

5. Liquidationsrisiko

Bewegt sich der Preis des Assets stark, entsteht bei einer der Positionen ein unrealisierter Verlust. Auf der Exchange mit der verlustbringenden Position muss die Margin gehalten werden. Reicht die Margin nicht aus — Liquidation. Der Gewinn auf der anderen Exchange hilft dabei nicht — er befindet sich auf einem anderen Konto.

Lösung:

• Margin-Reserve halten (mindestens das 2-fache des Minimums)
• Margin-Level-Warnungen einrichten
• Automatisches Rebalancing: bei einem Ungleichgewicht — Mittel zwischen Exchanges verschieben

Funding-Rate-Monitoring-System

Der erste Schritt zur Arbitrage ist die Datenerfassung. Man muss die Funding Rates auf allen relevanten Exchanges in Echtzeit verfolgen.

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'])

Beispielausgabe

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%

Ausführung: Gleichzeitige Positionseröffnung

Es ist von entscheidender Bedeutung, Long und Short so gleichzeitig wie möglich zu eröffnen, um eine Richtungsrisiko-Exposition zu vermeiden.

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

Positionsmanagement

Nach der Eröffnung ist eine kontinuierliche Überwachung erforderlich:

1. Funding-Rate-Spread. Wenn der Spread unter die Schwelle fällt — schließen.
2. Margin-Bilanz. Wenn die Margin auf einer Exchange unter das sichere Niveau fällt — rebalancieren oder schließen.
3. Preisdivergenz. Wenn der unrealisierte P&L auf einer Seite das Limit übersteigt — schließen.

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)

Erweiterte Varianten

Spot-Perp-Arbitrage

Anstelle von Futures auf zwei Exchanges kann man Spot + Futures auf einer einzigen Exchange verwenden:

• Spot kaufen (kein Funding)
• Den perpetuellen Futures shorten (Funding erhalten, wenn die Rate positiv ist)

Vorteil: alles auf einer Exchange, einfacheres Margin-Management. Nachteil: funktioniert nur bei positivem Funding (Longs zahlen Shorts), was ~70 % der Zeit während eines Bullenmarktes zu beobachten ist.

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

Bei gleichzeitiger Überwachung von 5+ Exchanges lassen sich günstigere Gelegenheiten finden. Algorithmus:

1. Funding Rates von allen Exchanges sammeln
2. Das Paar mit dem maximalen Spread finden
3. Liquidität und Orderbuchtiefe auf beiden Exchanges prüfen
4. Wenn Spread > Schwelle — Positionen eröffnen
5. Kontinuierlich neu scannen: wenn sich das beste Paar ändert — rotieren

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

Vorhersage der Funding Rate

Die Funding Rate wird mittels einer Formel berechnet, die den Premium-Index einbezieht — die Differenz zwischen dem Futures-Preis und dem Spotpreis. Die Prämie wird häufiger aktualisiert als das Funding (jede Minute gegenüber alle 8 Stunden). Das bedeutet, man kann die nächste Funding Rate Minuten oder Stunden vor der Zahlung vorhersagen.

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

Wenn man die prognostizierte Funding Rate kennt, kann man Positionen vor der Zahlung eröffnen, wenn der Spread noch nicht die Aufmerksamkeit anderer Arbitrageure auf sich gezogen hat.

Infrastruktur-Anforderungen

Für ernsthafte Funding-Rate-Arbitrage benötigt man Infrastruktur:

Ökonomie bei verschiedenen Größenordnungen

Die ROC hängt nicht von der Größenordnung ab (bei ausreichender Liquidität). Aber der absolute Gewinn bei 10.000 $ Kapital rechtfertigt möglicherweise nicht die Infrastrukturkosten und den Zeitaufwand.

Fazit

Funding-Rate-Arbitrage ist eine strukturelle, deltaneutrale Strategie. Sie erfordert keine Preisvorhersage, aber sie erfordert:

1. Infrastruktur — Echtzeit-Monitoring der Raten über mehrere Exchanges hinweg
2. Ausführungsgeschwindigkeit — gleichzeitige Eröffnung von Positionen auf verschiedenen Handelsplätzen
3. Risikomanagement — Kontrolle von Margin, Preisdivergenz und Spread-Änderungen
4. Kapital — der Gewinn ist proportional zur Positionsgröße

Funding-Rate-Spreads sind nicht konstant. Sie weiten sich in Phasen der Volatilität aus und verengen sich in ruhigen Phasen. Die Aufgabe besteht darin, Divergenzen automatisch zu finden und auszunutzen, solange sie existieren.

Mehr dazu, wie Funding Rates gehebelte Strategien beeinflussen — siehe den Artikel Funding Rates Kill Your Leverage: Why PnL×50x Is a Fiction.

Nützliche 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

Zitation

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