Arbitraje de Funding Rate entre Exchanges: Cómo Sacar Provecho de las Diferencias de Tasas

El funding rate de ETHUSDT es 0,01% en Binance y 0,035% en Bybit. La misma moneda, el mismo momento, pero las tasas difieren en 3,5 veces. Alguien paga más, alguien paga menos. Y alguien se beneficia de esta diferencia.

El arbitraje de funding rate es una de las pocas estrategias en cripto que no depende de la dirección del mercado. No se predice el precio. Se extrae beneficio de la divergencia estructural de las tasas entre plataformas.

Por qué los Funding Rates Difieren entre Exchanges

El funding rate es un mecanismo que ancla el precio de un contrato de futuros perpetuo al precio spot. Cada exchange lo calcula de forma independiente basándose en sus propios datos:

• Composición de traders. Binance está dominado por traders minoristas que tienden a ir long. Bybit y OKX tienen más participantes profesionales. Un balance long/short diferente lleva a un funding diferente.
• Fórmula de cálculo. Cada exchange usa su propia fórmula. Binance incorpora el índice de prima y la tasa de interés. Bybit y OKX hacen lo mismo pero con diferentes ponderaciones y periodos de promediado.
• Liquidez. En exchanges menos líquidos, la prima (diferencia entre futuros y spot) es más volátil, lo que hace que el funding fluctúe más ampliamente.
• Frecuencia de pago. La mayoría de los exchanges pagan funding cada 8 horas (00:00, 08:00, 16:00 UTC). Pero algunos (Bybit para ciertos pares, dYdX) pagan cada hora, creando oportunidades adicionales.

Divergencias Típicas

En un mercado tranquilo, los funding rates en los principales exchanges están cerca — la diferencia es de 0,001-0,005%. Pero durante periodos de volatilidad elevada, las divergencias crecen:

Un spread de 0,025% por 8 horas equivale a 0,075% al día. Con un tamaño de posición de $100K, eso es$75/día o ~$2.250/mes — sin riesgo direccional.

Mecánica Básica del Arbitraje

La idea es simple: abrir posiciones opuestas en dos exchanges de forma que se reciba funding en uno y se pague menos en el otro.

Ejemplo

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

Acciones:

1. Abrir un short en Bybit — recibir 0,04% cada 8 horas
2. Abrir un long en Binance — pagar 0,01% cada 8 horas
3. Las posiciones están reflejadas — el riesgo de precio es neutral
4. Beneficio neto: 0,04% - 0,01% = 0,03% por 8 horas

Al día (3 pagos): 0,09%. Al mes: ~2,7%. Sin riesgo direccional.

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)

Riesgos y Trampas

La estrategia parece "dinero gratis". No lo es. Existen varios riesgos serios.

1. Divergencia de Precio entre Exchanges

Las posiciones en diferentes exchanges no están al mismo precio. El spread entre Binance y Bybit suele ser de 0,01-0,05%, pero durante momentos de alta volatilidad puede alcanzar el 0,5-1%. Si no se abren las posiciones simultáneamente, la divergencia puede superar el beneficio del funding.

Solución: apertura simultánea vía API con latencia mínima. Idealmente — servidores colocados cerca de ambos exchanges.

2. Cambios en el Funding Rate

Se abren posiciones con un spread de 0,03%. Una hora después el spread se estrecha a 0,005% o se invierte. Ahora se está pagando en ambos exchanges.

Solución: monitoreo del spread en tiempo real y cierre automático cuando el spread cae por debajo de un umbral.

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

Abrir y cerrar posiciones en dos exchanges significa 4 órdenes. Con una comisión maker de 0,02% y una comisión taker de 0,05%:

• Escenario optimista (todo maker): $4 \times 0,02\% = 0,08\%$
• Escenario pesimista (todo taker): $4 \times 0,05\% = 0,20\%$

Para que las comisiones se amorticen, la posición debe mantenerse el tiempo suficiente:

$\text{Tiempo de equilibrio} = \frac{\text{Comisiones totales}}{\text{Spread} \times \text{Pagos por día}}$

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. Requisitos de Margen

Las posiciones en ambos exchanges requieren colateral. Con apalancamiento 5x en cada exchange con una posición de $100K:

• Binance: $20K de colateral
• Bybit: $20K de colateral
• Total bloqueado: **$40K** para una posición de$100K

Retorno sobre capital: $\text{ROC} = \frac{\$2700}{\$40000} \times 100\% = 6,75\% \text{ al mes}$

Con apalancamiento 10x, el colateral baja a $20K, el ROC sube a 13,5%. Pero el riesgo de liquidación por divergencia de precio también aumenta.

5. Riesgo de Liquidación

Si el precio del activo se mueve bruscamente, una de las posiciones genera una pérdida no realizada. En el exchange con la posición perdedora, hay que mantener el margen. Si el margen es insuficiente — liquidación. Mientras tanto, el beneficio en el otro exchange no ayuda — está en una cuenta diferente.

Solución:

• Mantener una reserva de margen (al menos 2x el mínimo)
• Configurar alertas de nivel de margen
• Rebalanceo automático: cuando ocurre un desequilibrio — transferir fondos entre exchanges

Sistema de Monitoreo de Funding Rate

El primer paso hacia el arbitraje es la recopilación de datos. Es necesario rastrear los funding rates en todos los exchanges de interés en tiempo real.

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

Salida de Ejemplo

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%

Ejecución: Apertura Simultánea de Posiciones

Es fundamental abrir el long y el short lo más simultáneamente posible para evitar exposición al riesgo direccional.

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

Gestión de Posiciones

Después de abrir, se requiere un monitoreo continuo:

1. Spread del funding rate. Si el spread se contrae por debajo del umbral — cerrar.
2. Balance de margen. Si el margen en un exchange cae por debajo del nivel seguro — rebalancear o cerrar.
3. Divergencia de precio. Si el P&L no realizado en un lado excede el límite — cerrar.

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 Avanzadas

Arbitraje Spot-Perp

En lugar de futuros en dos exchanges, se puede usar spot + futuros en un único exchange:

• Comprar spot (sin funding)
• Abrir short en el futuro perpetuo (recibir funding cuando la tasa es positiva)

Ventaja: todo en un exchange, gestión de margen más simple. Desventaja: solo funciona con funding positivo (los longs pagan a los shorts), lo cual se observa ~70% del tiempo durante un mercado alcista.

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)

Arbitraje Multi-Exchange

Al monitorear 5+ exchanges simultáneamente, se pueden encontrar oportunidades más favorables. Algoritmo:

1. Recopilar funding rates de todos los exchanges
2. Encontrar el par con el spread máximo
3. Verificar liquidez y profundidad del libro de órdenes en ambos exchanges
4. Si el spread > umbral — abrir posiciones
5. Reescanear continuamente: si el mejor par cambia — rotar

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

Predicción del Funding Rate

El funding rate se calcula mediante una fórmula que incluye el índice de prima — la diferencia entre el precio de futuros y el precio spot. La prima se actualiza con más frecuencia que el funding (cada minuto frente a cada 8 horas). Esto significa que se puede predecir el próximo funding rate minutos u horas antes del pago.

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

Conociendo el funding rate previsto, se pueden abrir posiciones antes del pago, cuando el spread aún no ha atraído la atención de otros arbitrajistas.

Requisitos de Infraestructura

Para un arbitraje de funding rate serio, se necesita infraestructura:

Economía a Diferentes Escalas

El ROC no depende de la escala (dada suficiente liquidez). Pero el beneficio absoluto con $10K de capital puede no justificar los costos de infraestructura y el tiempo.

Conclusión

El arbitraje de funding rate es una estrategia estructural, delta-neutral. No requiere predicción de precios, pero sí requiere:

1. Infraestructura — monitoreo en tiempo real de tasas en múltiples exchanges
2. Velocidad de ejecución — apertura simultánea de posiciones en diferentes plataformas
3. Gestión de riesgo — control de margen, divergencia de precio y cambios de spread
4. Capital — el beneficio es proporcional al tamaño de la posición

Los spreads de funding rate no son constantes. Se amplían durante periodos de volatilidad y se estrechan durante periodos de calma. La tarea consiste en encontrar y explotar automáticamente las divergencias mientras existen.

Para más información sobre cómo los funding rates afectan a las estrategias apalancadas — ver el artículo Funding Rates Kill Your Leverage: Why PnL×50x Is a Fiction.

Enlaces Útiles

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

Cita

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