Arbitragem de Funding Rate entre Exchanges: Como Lucrar com as Diferenças de Taxas

O funding rate do ETHUSDT é 0,01% na Binance e 0,035% na Bybit. A mesma moeda, o mesmo momento, mas as taxas diferem em 3,5 vezes. Alguém paga mais, alguém paga menos. E alguém lucra com essa diferença.

A arbitragem de funding rate é uma das poucas estratégias em cripto que não depende da direção do mercado. Você não prevê o preço. Você extrai lucro da divergência estrutural das taxas entre plataformas.

Por que os Funding Rates Diferem entre Exchanges

O funding rate é um mecanismo que ancora o preço de um contrato futuro perpétuo ao preço à vista. Cada exchange o calcula de forma independente com base em seus próprios dados:

• Composição de traders. A Binance é dominada por traders de varejo que tendem a ficar comprados (long). Bybit e OKX têm mais participantes profissionais. Um equilíbrio long/short diferente leva a um funding diferente.
• Fórmula de cálculo. Cada exchange usa sua própria fórmula. A Binance incorpora o índice de prêmio e a taxa de juros. Bybit e OKX fazem o mesmo, mas com pesos e períodos de média diferentes.
• Liquidez. Em exchanges menos líquidas, o prêmio (diferença entre futuros e à vista) é mais volátil, fazendo com que o funding flutue mais amplamente.
• Frequência de pagamento. A maioria das exchanges paga funding a cada 8 horas (00:00, 08:00, 16:00 UTC). Mas algumas (Bybit para certos pares, dYdX) pagam a cada hora, criando oportunidades adicionais.

Divergências Típicas

Em um mercado calmo, os funding rates nas principais exchanges estão próximos — a diferença é de 0,001-0,005%. Mas durante períodos de volatilidade elevada, as divergências crescem:

Um spread de 0,025% por 8 horas equivale a 0,075% ao dia. Com um tamanho de posição de $100 mil, isso é$75/dia ou ~$2.250/mês — sem risco direcional.

Mecânica Básica da Arbitragem

A ideia é simples: abrir posições opostas em duas exchanges de forma que você receba funding em uma e pague menos na outra.

Exemplo

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

Ações:

1. Abrir um short na Bybit — receber 0,04% a cada 8 horas
2. Abrir um long na Binance — pagar 0,01% a cada 8 horas
3. As posições estão espelhadas — o risco de preço é neutro
4. Lucro líquido: 0,04% - 0,01% = 0,03% a cada 8 horas

Por dia (3 pagamentos): 0,09%. Por mês: ~2,7%. Sem risco direcional.

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)

Riscos e Armadilhas

A estratégia parece "dinheiro grátis". Não é. Existem vários riscos sérios.

1. Divergência de Preço entre Exchanges

As posições em diferentes exchanges não estão no mesmo preço. O spread entre Binance e Bybit costuma ser de 0,01-0,05%, mas durante momentos de alta volatilidade pode chegar a 0,5-1%. Se você não abrir as posições simultaneamente, a divergência pode superar o lucro do funding.

Solução: abertura simultânea via API com latência mínima. Idealmente — servidores colocados próximos a ambas as exchanges.

2. Mudanças no Funding Rate

Você abriu posições com um spread de 0,03%. Uma hora depois, o spread se estreita para 0,005% ou se inverte. Agora você está pagando em ambas as exchanges.

Solução: monitoramento do spread em tempo real e fechamento automático quando o spread cai abaixo de um limite.

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. Comissões de Negociação

Abrir e fechar posições em duas exchanges significa 4 ordens. Com uma taxa maker de 0,02% e uma taxa taker de 0,05%:

• Cenário otimista (tudo maker): $4 \times 0,02\% = 0,08\%$
• Cenário pessimista (tudo taker): $4 \times 0,05\% = 0,20\%$

Para que as comissões se paguem, a posição deve ser mantida por tempo suficiente:

$\text{Tempo de equilíbrio} = \frac{\text{Comissões totais}}{\text{Spread} \times \text{Pagamentos por dia}}$

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 Margem

As posições em ambas as exchanges exigem colateral. Com alavancagem de 5x em cada exchange com uma posição de $100 mil:

• Binance: $20 mil de colateral
• Bybit: $20 mil de colateral
• Total bloqueado: **$40 mil** para uma posição de$100 mil

Retorno sobre o capital: $\text{ROC} = \frac{\$2700}{\$40000} \times 100\% = 6,75\% \text{ ao mês}$

Com alavancagem de 10x, o colateral cai para $20 mil, o ROC sobe para 13,5%. Mas o risco de liquidação por divergência de preço também aumenta.

5. Risco de Liquidação

Se o preço do ativo se mover bruscamente, uma das posições gera uma perda não realizada. Na exchange com a posição perdedora, a margem deve ser mantida. Se a margem for insuficiente — liquidação. Enquanto isso, o lucro na outra exchange não ajuda — está em uma conta diferente.

Solução:

• Manter uma reserva de margem (pelo menos 2x o mínimo)
• Configurar alertas de nível de margem
• Rebalanceamento automático: quando ocorre um desequilíbrio — transferir fundos entre exchanges

Sistema de Monitoramento de Funding Rate

O primeiro passo em direção à arbitragem é a coleta de dados. Você precisa acompanhar os funding rates em todas as exchanges de interesse em tempo 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'])

Exemplo de Saída

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%

Execução: Abertura Simultânea de Posições

É extremamente importante abrir o long e o short da forma mais simultânea possível para evitar exposição ao risco direcional.

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

Gestão de Posições

Após a abertura, é necessário monitoramento contínuo:

1. Spread do funding rate. Se o spread se contrair abaixo do limite — fechar.
2. Saldo de margem. Se a margem em uma exchange cair abaixo do nível seguro — rebalancear ou fechar.
3. Divergência de preço. Se o P&L não realizado de um lado exceder o limite — fechar.

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 Avançadas

Arbitragem Spot-Perp

Em vez de futuros em duas exchanges, você pode usar spot + futuros em uma única exchange:

• Comprar spot (sem funding)
• Vender a descoberto o futuro perpétuo (receber funding quando a taxa for positiva)

Vantagem: tudo em uma exchange, gestão de margem mais simples. Desvantagem: só funciona com funding positivo (os longs pagam os shorts), o que é observado ~70% do tempo durante um mercado em alta.

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)

Arbitragem Multi-Exchange

Ao monitorar 5+ exchanges simultaneamente, você pode encontrar oportunidades mais favoráveis. Algoritmo:

1. Coletar funding rates de todas as exchanges
2. Encontrar o par com o spread máximo
3. Verificar liquidez e profundidade do livro de ofertas em ambas as exchanges
4. Se spread > limite — abrir posições
5. Reescanear continuamente: se o melhor par mudar — rotacionar

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

Previsão do Funding Rate

O funding rate é calculado usando uma fórmula que inclui o índice de prêmio — a diferença entre o preço dos futuros e o preço à vista. O prêmio é atualizado com mais frequência do que o funding (a cada minuto versus a cada 8 horas). Isso significa que você pode prever o próximo funding rate minutos ou horas antes do pagamento.

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

Conhecendo o funding rate previsto, você pode abrir posições antes do pagamento, quando o spread ainda não atraiu a atenção de outros arbitradores.

Requisitos de Infraestrutura

Para uma arbitragem de funding rate séria, você precisa de infraestrutura:

Economia em Diferentes Escalas

O ROC não depende da escala (dada liquidez suficiente). Mas o lucro absoluto com $10 mil de capital pode não justificar os custos de infraestrutura e o tempo.

Conclusão

A arbitragem de funding rate é uma estratégia estrutural, delta-neutra. Ela não requer previsão de preço, mas requer:

1. Infraestrutura — monitoramento em tempo real de taxas em múltiplas exchanges
2. Velocidade de execução — abertura simultânea de posições em diferentes plataformas
3. Gestão de risco — controle de margem, divergência de preço e mudanças de spread
4. Capital — o lucro é proporcional ao tamanho da posição

Os spreads de funding rate não são constantes. Eles se ampliam durante períodos de volatilidade e se estreitam durante períodos calmos. A tarefa é encontrar e explorar automaticamente as divergências enquanto elas existem.

Para mais sobre como os funding rates afetam estratégias alavancadas — veja o artigo Funding Rates Kill Your Leverage: Why PnL×50x Is a Fiction.

Links Úteis

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ção

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