Arbitrage de Funding Rate entre Exchanges : Comment Profiter des Écarts de Taux

Le funding rate sur ETHUSDT est de 0,01 % sur Binance et de 0,035 % sur Bybit. La même crypto, le même instant, mais des taux qui diffèrent d'un facteur 3,5. Quelqu'un paie plus, quelqu'un paie moins. Et quelqu'un profite de cet écart.

L'arbitrage de funding rate est l'une des rares stratégies en crypto qui ne dépend pas de la direction du marché. On ne prédit pas le prix. On extrait un profit de la divergence structurelle des taux entre plateformes.

Pourquoi les Funding Rates Diffèrent entre Exchanges

Le funding rate est un mécanisme qui ancre le prix d'un contrat futures perpétuel au prix spot. Chaque exchange le calcule indépendamment à partir de ses propres données :

• Composition des traders. Binance est dominé par des traders particuliers qui ont tendance à aller long. Bybit et OKX comptent plus de participants professionnels. Un équilibre long/short différent entraîne un funding différent.
• Formule de calcul. Chaque exchange utilise sa propre formule. Binance intègre l'indice de prime et le taux d'intérêt. Bybit et OKX font de même mais avec des pondérations et des périodes de moyennage différentes.
• Liquidité. Sur les exchanges moins liquides, la prime (différence entre futures et spot) est plus volatile, ce qui fait fluctuer davantage le funding.
• Fréquence de paiement. La plupart des exchanges versent le funding toutes les 8 heures (00h00, 08h00, 16h00 UTC). Mais certains (Bybit pour certaines paires, dYdX) le versent chaque heure, créant des opportunités supplémentaires.

Divergences Typiques

Sur un marché calme, les funding rates sur les grands exchanges sont proches — l'écart est de 0,001-0,005 %. Mais lors de périodes de volatilité accrue, les divergences s'amplifient :

Un écart de 0,025 % par 8 heures représente 0,075 % par jour. Avec une position de 100 000 $, cela fait 75$/jour soit ~2 250 $/mois — sans risque directionnel.

Mécanique de Base de l'Arbitrage

L'idée est simple : ouvrir des positions opposées sur deux exchanges de manière à recevoir du funding sur l'un et à en payer moins sur l'autre.

Exemple

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

Actions :

1. Ouvrir un short sur Bybit — recevoir 0,04 % toutes les 8 heures
2. Ouvrir un long sur Binance — payer 0,01 % toutes les 8 heures
3. Les positions sont symétriques — le risque de prix est neutre
4. Profit net : 0,04 % - 0,01 % = 0,03 % par 8 heures

Par jour (3 paiements) : 0,09 %. Par mois : ~2,7 %. Sans risque directionnel.

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)

Risques et Pièges

La stratégie ressemble à de "l'argent gratuit". Ce n'est pas le cas. Il existe plusieurs risques sérieux.

1. Divergence de Prix entre Exchanges

Les positions sur différents exchanges ne sont pas au même prix. L'écart entre Binance et Bybit est généralement de 0,01-0,05 %, mais lors de moments de forte volatilité il peut atteindre 0,5-1 %. Si les positions ne sont pas ouvertes simultanément, la divergence peut dépasser le profit du funding.

Solution : ouverture simultanée via API avec une latence minimale. Idéalement — des serveurs colocalisés près des deux exchanges.

2. Changements du Funding Rate

Vous ouvrez des positions avec un écart de 0,03 %. Une heure plus tard, l'écart se resserre à 0,005 % ou s'inverse. Vous payez désormais sur les deux exchanges.

Solution : surveillance de l'écart en temps réel et fermeture automatique lorsque l'écart passe en dessous d'un seuil.

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. Commissions de Trading

Ouvrir et fermer des positions sur deux exchanges signifie 4 ordres. Avec des frais maker de 0,02 % et des frais taker de 0,05 % :

• Scénario optimiste (tout en maker) : $4 \times 0,02\% = 0,08\%$
• Scénario pessimiste (tout en taker) : $4 \times 0,05\% = 0,20\%$

Pour que les commissions soient amorties, la position doit être conservée suffisamment longtemps :

$\text{Temps de rentabilité} = \frac{\text{Commissions totales}}{\text{Écart} \times \text{Paiements par jour}}$

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. Exigences de Marge

Les positions sur les deux exchanges nécessitent une garantie. Avec un effet de levier 5x sur chaque exchange pour une position de 100 000 $ :

• Binance : 20 000 $ de garantie
• Bybit : 20 000 $ de garantie
• Total immobilisé : **40 000 $** pour une position de 100 000$

Rendement du capital : $\text{ROC} = \frac{\$2700}{\$40000} \times 100\% = 6,75\% \text{ par mois}$

Avec un effet de levier 10x, la garantie tombe à 20 000 $, le ROC monte à 13,5 %. Mais le risque de liquidation dû à la divergence de prix augmente également.

5. Risque de Liquidation

Si le prix de l'actif bouge fortement, l'une des positions génère une perte non réalisée. Sur l'exchange avec la position perdante, la marge doit être maintenue. Si la marge est insuffisante — liquidation. Pendant ce temps, le profit sur l'autre exchange n'aide pas — il est sur un compte différent.

Solution :

• Maintenir une réserve de marge (au moins 2x le minimum)
• Configurer des alertes de niveau de marge
• Rééquilibrage automatique : en cas de déséquilibre — transférer des fonds entre exchanges

Système de Surveillance des Funding Rates

La première étape vers l'arbitrage est la collecte de données. Il faut suivre les funding rates sur tous les exchanges d'intérêt en temps réel.

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

Exemple de Sortie

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%

Exécution : Ouverture Simultanée des Positions

Il est essentiel d'ouvrir le long et le short le plus simultanément possible pour éviter toute exposition au risque directionnel.

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

Gestion des Positions

Après l'ouverture, une surveillance continue est nécessaire :

1. Écart de funding rate. Si l'écart se contracte sous le seuil — fermer.
2. Solde de marge. Si la marge sur un exchange tombe sous le niveau de sécurité — rééquilibrer ou fermer.
3. Divergence de prix. Si le P&L latent d'un côté dépasse la limite — fermer.

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)

Variantes Avancées

Arbitrage Spot-Perp

Au lieu de futures sur deux exchanges, on peut utiliser du spot + des futures sur un seul exchange :

• Acheter du spot (pas de funding)
• Vendre à découvert le futures perpétuel (recevoir du funding lorsque le taux est positif)

Avantage : tout sur un seul exchange, gestion de marge plus simple. Inconvénient : ne fonctionne qu'avec un funding positif (les longs paient les shorts), ce qui est observé ~70 % du temps pendant un marché haussier.

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)

Arbitrage Multi-Exchange

En surveillant 5+ exchanges simultanément, on peut trouver des opportunités plus favorables. Algorithme :

1. Collecter les funding rates sur tous les exchanges
2. Trouver la paire avec l'écart maximum
3. Vérifier la liquidité et la profondeur du carnet d'ordres sur les deux exchanges
4. Si écart > seuil — ouvrir les positions
5. Rescanner en continu : si la meilleure paire change — pivoter

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

Prédiction du Funding Rate

Le funding rate est calculé via une formule qui inclut l'indice de prime — la différence entre le prix des futures et le prix spot. La prime est mise à jour plus fréquemment que le funding (chaque minute contre toutes les 8 heures). Cela signifie qu'on peut prédire le prochain funding rate des minutes ou des heures avant le paiement.

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

Connaissant le funding rate prévu, on peut ouvrir des positions avant le paiement, lorsque l'écart n'a pas encore attiré l'attention d'autres arbitragistes.

Exigences d'Infrastructure

Pour un arbitrage de funding rate sérieux, il faut une infrastructure :

Économie à Différentes Échelles

Le ROC ne dépend pas de l'échelle (à condition d'avoir suffisamment de liquidité). Mais le profit absolu avec un capital de 10K $ peut ne pas justifier les coûts d'infrastructure et le temps investi.

Conclusion

L'arbitrage de funding rate est une stratégie structurelle, delta-neutre. Elle ne nécessite pas de prédiction de prix, mais elle nécessite :

1. Infrastructure — surveillance en temps réel des taux sur plusieurs exchanges
2. Vitesse d'exécution — ouverture simultanée de positions sur différentes plateformes
3. Gestion des risques — contrôle de la marge, de la divergence de prix et des variations d'écart
4. Capital — le profit est proportionnel à la taille de la position

Les écarts de funding rate ne sont pas constants. Ils s'élargissent pendant les périodes de volatilité et se resserrent pendant les périodes calmes. La tâche consiste à trouver et exploiter automatiquement les divergences tant qu'elles existent.

Pour en savoir plus sur la façon dont les funding rates affectent les stratégies avec effet de levier — voir l'article Funding Rates Kill Your Leverage: Why PnL×50x Is a Fiction.

Liens Utiles

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

Citation

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