Arbitraggio del Funding Rate tra Exchange: Come Trarre Profitto dalle Differenze di Tasso

Il funding rate su ETHUSDT è dello 0.01% su Binance e dello 0.035% su Bybit. La stessa moneta, lo stesso momento, ma i tassi differiscono di 3.5x. Qualcuno paga di più, qualcuno paga di meno. E qualcuno trae profitto da questa differenza.

L'arbitraggio del funding rate è una delle poche strategie in crypto che non dipende dalla direzione del mercato. Non si prevede il prezzo. Si estrae profitto dalla divergenza strutturale dei tassi tra le piattaforme.

Perché i Funding Rate Differiscono tra gli Exchange

Il funding rate è un meccanismo che ancora il prezzo di un contratto futures perpetuo al prezzo spot. Ogni exchange lo calcola in modo indipendente in base ai propri dati:

• Composizione dei trader. Su Binance prevalgono i trader retail che tendono ad andare long. Bybit e OKX hanno più partecipanti professionisti. Un diverso equilibrio long/short porta a funding diversi.
• Formula di calcolo. Ogni exchange usa la propria formula. Binance considera il premium index e il tasso d'interesse. Bybit e OKX fanno lo stesso ma con pesi e periodi di media diversi.
• Liquidità. Su exchange meno liquidi, il premium (differenza tra futures e spot) è più volatile, causando oscillazioni più ampie del funding.
• Frequenza di pagamento. La maggior parte degli exchange paga il funding ogni 8 ore (00:00, 08:00, 16:00 UTC). Ma alcuni (Bybit per certe coppie, dYdX) pagano ogni ora, creando opportunità aggiuntive.

Divergenze Tipiche

In un mercato calmo, i funding rate sui principali exchange sono simili — la differenza è dello 0.001-0.005%. Ma nei periodi di maggiore volatilità, le divergenze crescono:

Uno spread dello 0.025% ogni 8 ore corrisponde allo 0.075% al giorno. Con una posizione di $100K, sono$75/giorno o ~$2.250/mese — senza rischio direzionale.

Meccanica Base dell'Arbitraggio

L'idea è semplice: aprire posizioni opposte su due exchange in modo da ricevere funding su uno e pagarne meno sull'altro.

Esempio

Binance: funding rate = +0.01% (i long pagano gli short) Bybit: funding rate = +0.04% (i long pagano gli short)

Azioni:

1. Aprire uno short su Bybit — si riceve lo 0.04% ogni 8 ore
2. Aprire un long su Binance — si paga lo 0.01% ogni 8 ore
3. Le posizioni sono speculari — il rischio di prezzo è neutro
4. Profitto netto: 0.04% - 0.01% = 0.03% ogni 8 ore

Al giorno (3 pagamenti): 0.09%. Al mese: ~2.7%. Senza rischio direzionale.

def funding_arbitrage_pnl(
    rate_short_exchange: float,  # tasso sull'exchange dove andiamo short
    rate_long_exchange: float,   # tasso sull'exchange dove andiamo long
    position_size: float,        # dimensione della posizione in USD
    payments_per_day: int = 3,
    days: int = 30,
) -> float:
    """
    PnL dall'arbitraggio del funding rate su un periodo.

    Con funding positivo: gli short ricevono, i long pagano.
    Con funding negativo: gli short pagano, i long ricevono.
    """
    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)

Rischi e Insidie

La strategia sembra "denaro gratuito." Non lo è. Esistono diversi rischi seri.

1. Divergenza di Prezzo tra Exchange

Le posizioni su exchange diversi non sono allo stesso prezzo. Lo spread tra Binance e Bybit è solitamente dello 0.01-0.05%, ma nei momenti di alta volatilità può raggiungere lo 0.5-1%. Se non si aprono le posizioni simultaneamente, la divergenza può superare il profitto da funding.

Soluzione: apertura simultanea tramite API con latenza minima. Idealmente — server collocati vicino a entrambi gli exchange.

2. Variazioni del Funding Rate

Hai aperto le posizioni con uno spread dello 0.03%. Un'ora dopo lo spread si è ristretto allo 0.005% o si è invertito. Ora stai pagando su entrambi gli exchange.

Soluzione: monitoraggio dello spread in tempo reale e chiusura automatica quando lo spread scende sotto una soglia.

def should_close(
    current_spread: float,
    entry_spread: float,
    min_spread: float = 0.0001,     # 0.01%
    trading_costs: float = 0.0005,  # 0.05% per apertura + chiusura
) -> bool:
    """
    Chiude la posizione se lo spread è sceso sotto la soglia
    o se lo spread corrente non copre i costi di trading.
    """
    return current_spread < min_spread or current_spread < trading_costs

3. Commissioni di Trading

Aprire e chiudere posizioni su due exchange significa 4 ordini. Con commissioni maker dello 0.02% e taker dello 0.05%:

• Scenario ottimistico (tutto maker): $4 \times 0.02\% = 0.08\%$
• Scenario pessimistico (tutto taker): $4 \times 0.05\% = 0.20\%$

Perché le commissioni vengano coperte, la posizione deve essere mantenuta abbastanza a lungo:

$\text{Tempo di pareggio} = \frac{\text{Commissioni totali}}{\text{Spread} \times \text{Pagamenti al giorno}}$

def breakeven_days(
    total_commissions_pct: float,  # commissioni totali in %
    spread: float,                  # spread del funding rate
    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. Requisiti di Margine

Le posizioni su entrambi gli exchange richiedono collaterale. Con leva 5x su ciascun exchange per una posizione di $100K:

• Binance: $20K di collaterale
• Bybit: $20K di collaterale
• Totale bloccato: **$40K** per una posizione di$100K

Rendimento sul capitale: $\text{ROC} = \frac{\$2700}{\$40000} \times 100\% = 6.75\% \text{ al mese}$

A leva 10x, il collaterale scende a $20K, il ROC sale al 13.5%. Ma aumenta anche il rischio di liquidazione per divergenza di prezzo.

5. Rischio di Liquidazione

Se il prezzo dell'asset si muove bruscamente, una delle posizioni genera una perdita non realizzata. Sull'exchange con la posizione perdente, il margine deve essere mantenuto. Se il margine è insufficiente — liquidazione. Nel frattempo, il profitto sull'altro exchange non aiuta — si trova su un conto diverso.

Soluzione:

• Mantenere una riserva di margine (almeno 2x il minimo)
• Impostare avvisi sul livello del margine
• Ribilanciamento automatico: quando si verifica uno squilibrio — trasferire fondi tra gli exchange

Sistema di Monitoraggio del Funding Rate

Il primo passo verso l'arbitraggio è la raccolta dati. È necessario monitorare i funding rate su tutti gli exchange di interesse in tempo reale.

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:
    """
    Monitora i funding rate su più exchange.
    """
    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):
        """Recupera il funding rate corrente da un 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"Errore nel recupero {exchange_name} {symbol}: {e}")
            return None

    async def scan(self) -> list[dict]:
        """
        Scansiona tutti gli exchange e trova opportunità di arbitraggio.
        """
        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 qui (si paga meno)
            highest = rates[-1] # short qui (si riceve di più)
            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 % annualizzato
            })

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

Esempio di Output

Simbolo    | Long @      | Tasso   | Short @     | Tasso   | 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%

Esecuzione: Apertura Simultanea delle Posizioni

È fondamentale aprire il long e lo short nel modo più simultaneo possibile per evitare l'esposizione al rischio direzionale.

import asyncio

async def execute_arbitrage(
    long_exchange,
    short_exchange,
    symbol: str,
    size: float,
    max_slippage_pct: float = 0.05,
):
    """
    Apre simultaneamente un long e uno short su due exchange.
    """
    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"Spread di prezzo {price_spread:.3f}% supera lo slippage massimo"
        )

    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

Gestione delle Posizioni

Dopo l'apertura, è necessario un monitoraggio continuo:

1. Spread del funding rate. Se lo spread scende sotto la soglia — chiudi.
2. Saldo del margine. Se il margine su un exchange scende sotto il livello sicuro — ribilancia o chiudi.
3. Divergenza di prezzo. Se l'P&L non realizzato su un lato supera il limite — chiudi.

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,
):
    """
    Monitora una posizione di arbitraggio aperta.
    """
    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 crollato: {current_spread:.4%}")
            await close_both(long_exchange, short_exchange, symbol, size)
            break

        if abs(total_upnl_pct) > max_unrealized_loss_pct:
            print(f"Perdita non realizzata superata: {total_upnl_pct:.2f}%")
            await close_both(long_exchange, short_exchange, symbol, size)
            break

        await asyncio.sleep(check_interval)

Varianti Avanzate

Arbitraggio Spot-Perp

Invece di futures su due exchange, puoi usare spot + futures su un singolo exchange:

• Acquista spot (senza funding)
• Vai short sul futures perpetuo (ricevi funding quando il tasso è positivo)

Vantaggio: tutto su un unico exchange, gestione del margine più semplice. Svantaggio: funziona solo con funding positivo (i long pagano gli short), osservato circa il 70% del tempo in un mercato rialzista.

def spot_perp_carry(
    funding_rate: float,      # funding rate corrente
    spot_fee: float = 0.001,  # commissione spot (0.1%)
    perp_fee: float = 0.0005, # commissione futures (0.05%)
    leverage: int = 1,
) -> dict:
    """
    Calcola il rendimento di un carry trade spot-perp.
    """
    total_fees = (spot_fee + perp_fee) * 2  # apertura + chiusura

    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)

Arbitraggio Multi-Exchange

Monitorando 5+ exchange simultaneamente, si possono trovare opportunità più favorevoli. Algoritmo:

1. Raccogliere i funding rate da tutti gli exchange
2. Trovare la coppia con lo spread massimo
3. Verificare la liquidità e la profondità del book su entrambi gli exchange
4. Se spread > soglia — apri le posizioni
5. Riscansiona continuamente: se la coppia migliore cambia — ruota

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:
    """
    Trova la coppia di exchange con il massimo spread del funding rate.
    Restituisce: (long_exchange, short_exchange, spread) o 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

Previsione del Funding Rate

Il funding rate viene calcolato con una formula che include il premium index — la differenza tra il prezzo futures e il prezzo spot. Il premium si aggiorna più frequentemente del funding (ogni minuto vs ogni 8 ore). Ciò significa che puoi prevedere il prossimo funding rate minuti o ore prima del pagamento.

def predict_next_funding(
    premium_index: float,
    interest_rate: float = 0.0001,  # 0.01% ogni 8h (standard)
    clamp_range: float = 0.0005,    # ±0.05%
) -> float:
    """
    Prevede il prossimo funding rate basandosi sull'attuale premium index.
    Formula Binance: 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

Conoscendo il funding rate previsto, puoi aprire le posizioni prima del pagamento, quando lo spread non ha ancora attirato l'attenzione degli altri arbitraggisti.

Requisiti Infrastrutturali

Per un arbitraggio del funding rate serio, è necessaria un'infrastruttura:

Economia a Diverse Scale

Il ROC non dipende dalla scala (data liquidità sufficiente). Ma il profitto assoluto con un capitale di $10K potrebbe non giustificare i costi infrastrutturali e il tempo.

Conclusione

L'arbitraggio del funding rate è una strategia strutturale delta-neutrale. Non richiede la previsione dei prezzi, ma richiede:

1. Infrastruttura — monitoraggio in tempo reale dei tassi su più exchange
2. Velocità di esecuzione — apertura simultanea delle posizioni su diverse piattaforme
3. Gestione del rischio — controllo del margine, della divergenza di prezzo e delle variazioni dello spread
4. Capitale — il profitto è proporzionale alla dimensione della posizione

Gli spread del funding rate non sono costanti. Si ampliano nei periodi di volatilità e si restringono nei periodi calmi. Il compito è trovare e sfruttare automaticamente le divergenze finché esistono.

Per approfondire come i funding rate influenzano le strategie con leva — vedi l'articolo I Funding Rate Distruggono la Tua Leva: Perché PnL×50x È una Finzione.

Link Utili

1. Binance — Storico dei Funding Rate
2. Binance — Introduzione ai Funding Rate
3. Bybit — Comprendere i Funding Rate
4. dYdX — Meccanismo del Funding Rate Perpetuo
5. Coinglass — Monitor dei Funding Rate

Citazione

@article{soloviov2026fundingarbitrage,
  author = {Soloviov, Eugen},
  title = {Arbitraggio del Funding Rate tra Exchange: Come Trarre Profitto dalle Differenze di Tasso},
  year = {2026},
  url = {https://marketmaker.cc/it/blog/post/funding-rate-arbitrage-cross-exchange},
  description = {Come funziona l'arbitraggio del funding rate tra exchange crypto, perché i tassi differiscono su Binance, Bybit, OKX e dYdX, e come costruire un sistema di monitoraggio ed esecuzione.}
}