Arbitrase Funding Rate Antar Bursa: Cara Mengambil Keuntungan dari Perbedaan Rate

Funding rate pada ETHUSDT adalah 0,01% di Binance dan 0,035% di Bybit. Koin yang sama, waktu yang sama, namun rate berbeda 3,5x. Ada yang membayar lebih, ada yang membayar lebih sedikit. Dan ada yang mengambil keuntungan dari perbedaan ini.

Arbitrase funding rate adalah salah satu dari sedikit strategi di kripto yang tidak bergantung pada arah pasar. Anda tidak perlu memprediksi harga. Anda mengambil keuntungan dari divergensi struktural rate antar bursa.

Mengapa Funding Rate Berbeda Antar Bursa

Funding rate adalah mekanisme yang mengikat harga kontrak perpetual futures ke harga spot. Setiap bursa menghitungnya secara independen berdasarkan data mereka sendiri:

• Komposisi trader. Binance didominasi oleh trader ritel yang cenderung long. Bybit dan OKX memiliki lebih banyak peserta profesional. Keseimbangan long/short yang berbeda menghasilkan funding yang berbeda.
• Formula perhitungan. Setiap bursa menggunakan formulanya sendiri. Binance memperhitungkan premium index dan interest rate. Bybit dan OKX melakukan hal yang sama tetapi dengan bobot dan periode rata-rata yang berbeda.
• Likuiditas. Pada bursa yang kurang likuid, premium (selisih antara futures dan spot) lebih volatil, menyebabkan funding berfluktuasi lebih lebar.
• Frekuensi pembayaran. Sebagian besar bursa membayar funding setiap 8 jam (00:00, 08:00, 16:00 UTC). Namun beberapa (Bybit untuk pair tertentu, dYdX) membayar setiap jam, menciptakan peluang tambahan.

Divergensi Tipikal

Di pasar yang tenang, funding rate pada bursa-bursa utama hampir sama — perbedaannya 0,001-0,005%. Namun selama periode volatilitas tinggi, divergensi membesar:

Spread 0,025% per 8 jam setara dengan 0,075% per hari. Dengan ukuran posisi $100K, itu adalah$75/hari atau ~$2.250/bulan — tanpa risiko arah.

Mekanika Dasar Arbitrase

Idenya sederhana: buka posisi berlawanan di dua bursa sehingga Anda menerima funding di satu sisi dan membayar lebih sedikit di sisi lain.

Contoh

Binance: funding rate = +0,01% (long membayar short) Bybit: funding rate = +0,04% (long membayar short)

Tindakan:

1. Buka short di Bybit — terima 0,04% setiap 8 jam
2. Buka long di Binance — bayar 0,01% setiap 8 jam
3. Posisi saling mencerminkan — risiko harga netral
4. Keuntungan bersih: 0,04% - 0,01% = 0,03% per 8 jam

Per hari (3 pembayaran): 0,09%. Per bulan: ~2,7%. Tanpa risiko arah.

def funding_arbitrage_pnl(
    rate_short_exchange: float,  # rate di bursa tempat kita short
    rate_long_exchange: float,   # rate di bursa tempat kita long
    position_size: float,        # ukuran posisi dalam USD
    payments_per_day: int = 3,
    days: int = 30,
) -> float:
    """
    PnL dari arbitrase funding rate selama suatu periode.

    Dengan funding positif: short menerima, long membayar.
    Dengan funding negatif: short membayar, long menerima.
    """
    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)

Risiko dan Jebakan

Strategi ini terlihat seperti "uang gratis." Sebenarnya tidak. Ada beberapa risiko serius.

1. Divergensi Harga Antar Bursa

Posisi di bursa yang berbeda tidak berada pada harga yang sama. Selisih antara Binance dan Bybit biasanya 0,01-0,05%, namun saat volatilitas tinggi bisa mencapai 0,5-1%. Jika Anda tidak membuka posisi secara bersamaan, divergensi bisa melebihi keuntungan funding.

Solusi: pembukaan simultan melalui API dengan latensi minimal. Idealnya — server collocated dekat kedua bursa.

2. Perubahan Funding Rate

Anda membuka posisi pada spread 0,03%. Satu jam kemudian spread menyempit menjadi 0,005% atau berbalik arah. Sekarang Anda membayar di kedua bursa.

Solusi: pemantauan spread secara real-time dan penutupan otomatis ketika spread turun di bawah ambang batas.

def should_close(
    current_spread: float,
    entry_spread: float,
    min_spread: float = 0.0001,     # 0,01%
    trading_costs: float = 0.0005,  # 0,05% untuk pembukaan + penutupan
) -> bool:
    """
    Tutup posisi jika spread telah turun di bawah ambang batas
    atau jika spread saat ini tidak menutup biaya trading.
    """
    return current_spread < min_spread or current_spread < trading_costs

3. Komisi Trading

Membuka dan menutup posisi di dua bursa berarti 4 order. Dengan maker fee 0,02% dan taker fee 0,05%:

• Skenario optimis (semua maker): $4 \times 0.02\% = 0.08\%$
• Skenario pesimis (semua taker): $4 \times 0.05\% = 0.20\%$

Agar komisi impas, posisi harus ditahan cukup lama:

$\text{Waktu impas} = \frac{\text{Total komisi}}{\text{Spread} \times \text{Pembayaran per hari}}$

def breakeven_days(
    total_commissions_pct: float,  # total komisi dalam %
    spread: float,                  # selisih 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. Persyaratan Margin

Posisi di kedua bursa membutuhkan jaminan. Pada leverage 5x di setiap bursa dengan posisi $100K:

• Binance: jaminan $20K
• Bybit: jaminan $20K
• Total terkunci: **$40K** untuk posisi$100K

Imbal hasil atas modal: $\text{ROC} = \frac{\$2700}{\$40000} \times 100\% = 6.75\% \text{ per bulan}$

Pada leverage 10x, jaminan turun menjadi $20K, ROC naik menjadi 13,5%. Namun risiko likuidasi akibat divergensi harga juga meningkat.

5. Risiko Likuidasi

Jika harga aset bergerak tajam, salah satu posisi menghasilkan kerugian yang belum terealisasi. Di bursa dengan posisi yang merugi, margin harus dipertahankan. Jika margin tidak cukup — likuidasi. Sementara itu, keuntungan di bursa lain tidak membantu — itu ada di akun yang berbeda.

Solusi:

• Pertahankan cadangan margin (setidaknya 2x minimum)
• Siapkan peringatan level margin
• Rebalancing otomatis: ketika terjadi ketidakseimbangan — transfer dana antar bursa

Sistem Pemantauan Funding Rate

Langkah pertama menuju arbitrase adalah pengumpulan data. Anda perlu memantau funding rate di semua bursa yang diminati secara real-time.

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:
    """
    Pantau funding rate di berbagai bursa.
    """
    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):
        """Ambil funding rate saat ini dari suatu bursa."""
        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]:
        """
        Pindai semua bursa dan temukan peluang arbitrase.
        """
        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 di sini (bayar lebih sedikit)
            highest = rates[-1] # short di sini (terima lebih banyak)
            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,  # dalam % tahunan
            })

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

Contoh Output

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%

Eksekusi: Pembukaan Posisi Simultan

Sangat penting untuk membuka long dan short sesimultan mungkin guna menghindari eksposur risiko arah.

import asyncio

async def execute_arbitrage(
    long_exchange,
    short_exchange,
    symbol: str,
    size: float,
    max_slippage_pct: float = 0.05,
):
    """
    Buka long dan short secara simultan di dua bursa.
    """
    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

Manajemen Posisi

Setelah dibuka, pemantauan berkelanjutan diperlukan:

1. Spread funding rate. Jika spread menyempit di bawah ambang batas — tutup.
2. Saldo margin. Jika margin di satu bursa turun di bawah level aman — rebalancing atau tutup.
3. Divergensi harga. Jika P&L yang belum terealisasi di satu sisi melampaui batas — tutup.

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,
):
    """
    Pantau posisi arbitrase yang terbuka.
    """
    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)

Varian Lanjutan

Arbitrase Spot-Perp

Alih-alih futures di dua bursa, Anda dapat menggunakan spot + futures di satu bursa:

• Beli spot (tanpa funding)
• Short perpetual futures (terima funding ketika rate positif)

Keuntungan: semuanya di satu bursa, manajemen margin lebih sederhana. Kerugian: hanya berfungsi dengan funding positif (long membayar short), yang terjadi ~70% waktu selama pasar bull.

def spot_perp_carry(
    funding_rate: float,      # funding rate saat ini
    spot_fee: float = 0.001,  # komisi spot (0,1%)
    perp_fee: float = 0.0005, # komisi futures (0,05%)
    leverage: int = 1,
) -> dict:
    """
    Hitung imbal hasil carry trade spot-perp.
    """
    total_fees = (spot_fee + perp_fee) * 2  # pembukaan + penutupan

    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)

Arbitrase Multi-Bursa

Saat memantau 5+ bursa secara bersamaan, Anda dapat menemukan peluang yang lebih menguntungkan. Algoritma:

1. Kumpulkan funding rate dari semua bursa
2. Temukan pasangan dengan spread maksimum
3. Periksa likuiditas dan kedalaman order book di kedua bursa
4. Jika spread > ambang batas — buka posisi
5. Pindai ulang secara berkelanjutan: jika pasangan terbaik berubah — rotasi

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:
    """
    Temukan pasangan bursa dengan spread funding rate maksimum.
    Mengembalikan: (long_exchange, short_exchange, spread) atau 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

Memprediksi Funding Rate

Funding rate dihitung menggunakan formula yang mencakup premium index — selisih antara harga futures dan harga spot. Premium diperbarui lebih sering daripada funding (setiap menit vs setiap 8 jam). Ini berarti Anda dapat memprediksi funding rate berikutnya beberapa menit atau jam sebelum pembayaran.

def predict_next_funding(
    premium_index: float,
    interest_rate: float = 0.0001,  # 0,01% per 8j (standar)
    clamp_range: float = 0.0005,    # ±0,05%
) -> float:
    """
    Prediksi funding rate berikutnya berdasarkan premium index saat ini.
    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

Dengan mengetahui prediksi funding rate, Anda dapat membuka posisi sebelum pembayaran, saat spread belum menarik perhatian arbitrageur lain.

Persyaratan Infrastruktur

Untuk arbitrase funding rate yang serius, Anda membutuhkan infrastruktur:

Ekonomi pada Berbagai Skala

ROC tidak bergantung pada skala (dengan likuiditas yang cukup). Namun keuntungan absolut pada modal $10K mungkin tidak membenarkan biaya infrastruktur dan waktu.

Kesimpulan

Arbitrase funding rate adalah strategi struktural yang delta-netral. Tidak memerlukan prediksi harga, tetapi memerlukan:

1. Infrastruktur — pemantauan rate secara real-time di berbagai bursa
2. Kecepatan eksekusi — pembukaan posisi simultan di berbagai venue
3. Manajemen risiko — kontrol margin, divergensi harga, dan perubahan spread
4. Modal — keuntungan berbanding lurus dengan ukuran posisi

Spread funding rate tidak konstan. Melebar selama periode volatilitas dan menyempit selama periode tenang. Tugasnya adalah menemukan dan mengeksploitasi divergensi secara otomatis selagi masih ada.

Untuk lebih lanjut tentang bagaimana funding rate memengaruhi strategi berleverage — lihat artikel Funding Rate Menggerogoti Leverage Anda: Mengapa PnL×50x Adalah Fiksi.

Tautan Berguna

1. Binance — Riwayat Funding Rate
2. Binance — Pengantar Funding Rate
3. Bybit — Memahami Funding Rate
4. dYdX — Mekanisme Funding Rate Perpetual
5. Coinglass — Monitor Funding Rate

Kutipan

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