อาร์บิทราจ Funding Rate ข้ามกระดาน: วิธีทำกำไรจากความแตกต่างของอัตรา

Funding rate ของ ETHUSDT อยู่ที่ 0.01% บน Binance และ 0.035% บน Bybit เหรียญเดียวกัน ช่วงเวลาเดียวกัน แต่อัตราต่างกันถึง 3.5 เท่า บางคนจ่ายมากกว่า บางคนจ่ายน้อยกว่า และมีคนที่ทำกำไรจากความแตกต่างนี้

อาร์บิทราจ Funding Rate เป็นหนึ่งในไม่กี่กลยุทธ์ใน crypto ที่ไม่ขึ้นอยู่กับทิศทางของตลาด คุณไม่ต้องทำนายราคา คุณดึงกำไรจากความแตกต่างเชิงโครงสร้างของอัตราระหว่างกระดาน

ทำไม Funding Rate จึงแตกต่างกันระหว่างกระดาน

Funding rate คือกลไกที่ยึดราคาสัญญา perpetual futures ให้ใกล้เคียงกับราคา spot แต่ละกระดานคำนวณแยกจากกันโดยใช้ข้อมูลของตัวเอง:

• องค์ประกอบของนักเทรด Binance มีนักเทรดรายย่อยครองตลาด ซึ่งมักจะ long Bybit และ OKX มีผู้เข้าร่วมมืออาชีพมากกว่า ความสมดุล long/short ที่ต่างกันนำไปสู่ funding ที่ต่างกัน
• สูตรการคำนวณ แต่ละกระดานใช้สูตรของตัวเอง Binance คำนวณจาก premium index และ interest rate Bybit และ OKX ใช้แนวทางเดียวกันแต่ต่างน้ำหนักและช่วงเวลาเฉลี่ย
• สภาพคล่อง บนกระดานที่มีสภาพคล่องน้อยกว่า premium (ส่วนต่างระหว่าง futures และ spot) ผันผวนมากกว่า ทำให้ funding แกว่งในช่วงกว้างกว่า
• ความถี่การจ่าย กระดานส่วนใหญ่จ่าย funding ทุก 8 ชั่วโมง (00:00, 08:00, 16:00 UTC) แต่บางกระดาน (Bybit สำหรับบางคู่, dYdX) จ่ายทุกชั่วโมง ซึ่งสร้างโอกาสเพิ่มเติม

ความแตกต่างที่เกิดขึ้นทั่วไป

ในตลาดที่สงบ funding rate บนกระดานหลักจะใกล้เคียงกัน โดยต่างกันเพียง 0.001-0.005% แต่ช่วงที่มีความผันผวนสูง ความแตกต่างจะขยายใหญ่ขึ้น:

Spread 0.025% ต่อ 8 ชั่วโมง คือ 0.075% ต่อวัน ด้วยขนาด position $100K นั่นคือ$75/วัน หรือ ~$2,250/เดือน โดยไม่มีความเสี่ยงด้านทิศทาง

กลไกพื้นฐานของอาร์บิทราจ

ไอเดียเรียบง่าย: เปิด position ตรงข้ามบนสองกระดาน เพื่อรับ funding จากกระดานหนึ่งและจ่ายน้อยกว่าบนอีกกระดาน

ตัวอย่าง

Binance: funding rate = +0.01% (long จ่ายให้ short) Bybit: funding rate = +0.04% (long จ่ายให้ short)

การดำเนินการ:

1. เปิด short บน Bybit — รับ 0.04% ทุก 8 ชั่วโมง
2. เปิด long บน Binance — จ่าย 0.01% ทุก 8 ชั่วโมง
3. Position สะท้อนกัน — ความเสี่ยงด้านราคาเป็นกลาง
4. กำไรสุทธิ: 0.04% - 0.01% = 0.03% ต่อ 8 ชั่วโมง

ต่อวัน (3 ครั้ง): 0.09% ต่อเดือน: ~2.7% โดยไม่มีความเสี่ยงด้านทิศทาง

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)

ความเสี่ยงและกับดัก

กลยุทธ์นี้ดูเหมือน "เงินฟรี" แต่ไม่ใช่ มีความเสี่ยงที่ร้ายแรงหลายประการ

1. ราคาแตกต่างกันระหว่างกระดาน

Position บนกระดานต่างกันไม่ได้อยู่ที่ราคาเดียวกัน Spread ระหว่าง Binance และ Bybit ปกติอยู่ที่ 0.01-0.05% แต่ช่วงที่ความผันผวนสูงอาจถึง 0.5-1% ถ้าคุณไม่เปิด position พร้อมกัน ความแตกต่างอาจกินกำไรจาก funding หมด

วิธีแก้: เปิดพร้อมกันผ่าน API ด้วย latency น้อยที่สุด อุดมคติคือ server collocated ใกล้กับทั้งสองกระดาน

2. Funding Rate เปลี่ยนแปลง

คุณเปิด position ที่ spread 0.03% หนึ่งชั่วโมงต่อมา spread แคบลงเหลือ 0.005% หรือพลิกกลับ ตอนนี้คุณจ่ายบนทั้งสองกระดาน

วิธีแก้: ติดตาม spread แบบ real-time และปิดอัตโนมัติเมื่อ spread ลดลงต่ำกว่าเกณฑ์

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. ค่าธรรมเนียมการซื้อขาย

การเปิดและปิด position บนสองกระดานหมายถึง 4 คำสั่ง ที่ค่าธรรมเนียม maker 0.02% และ taker 0.05%:

• สถานการณ์ดีที่สุด (ทั้งหมด maker): $4 \times 0.02\% = 0.08\%$
• สถานการณ์แย่ที่สุด (ทั้งหมด taker): $4 \times 0.05\% = 0.20\%$

เพื่อให้ค่าธรรมเนียมคุ้มทุน ต้องถือ position นานพอ:

$\text{Breakeven time} = \frac{\text{Total commissions}}{\text{Spread} \times \text{Payments per day}}$

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. ข้อกำหนด Margin

Position บนทั้งสองกระดานต้องการหลักประกัน ที่ leverage 5x บนแต่ละกระดานด้วย position $100K:

• Binance: หลักประกัน $20K
• Bybit: หลักประกัน $20K
• รวมที่ถูกล็อค: **$40K** สำหรับ position$100K

ผลตอบแทนต่อทุน: $\text{ROC} = \frac{\$2700}{\$40000} \times 100\% = 6.75\% \text{ per month}$

ที่ leverage 10x หลักประกันลดเหลือ $20K ROC เพิ่มขึ้นเป็น 13.5% แต่ความเสี่ยง liquidation จากความแตกต่างของราคาก็เพิ่มขึ้นด้วย

5. ความเสี่ยง Liquidation

ถ้าราคาของสินทรัพย์เคลื่อนที่อย่างรวดเร็ว หนึ่งใน position จะมีขาดทุนที่ยังไม่รับรู้ บนกระดานที่ position ขาดทุน ต้องรักษา margin ไว้ ถ้า margin ไม่เพียงพอจะถูก liquidation ในขณะที่กำไรบนกระดานอื่นไม่ช่วยได้ — มันอยู่ในบัญชีอื่น

วิธีแก้:

• รักษาสำรอง margin ไว้ (อย่างน้อย 2x ขั้นต่ำ)
• ตั้งการแจ้งเตือนระดับ margin
• Rebalancing อัตโนมัติ: เมื่อเกิดความไม่สมดุล — โอนเงินระหว่างกระดาน

ระบบติดตาม Funding Rate

ก้าวแรกสู่อาร์บิทราจคือการรวบรวมข้อมูล คุณต้องติดตาม funding rate บนทุกกระดานที่สนใจแบบ 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:
    """
    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'])

ตัวอย่างผลลัพธ์

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%

การดำเนินการ: เปิด Position พร้อมกัน

สิ่งสำคัญอย่างยิ่งคือต้องเปิด long และ short พร้อมกันให้ได้มากที่สุด เพื่อหลีกเลี่ยงการรับความเสี่ยงด้านทิศทาง

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

การจัดการ Position

หลังจากเปิดแล้ว ต้องติดตามอย่างต่อเนื่อง:

1. Funding rate spread ถ้า spread แคบลงต่ำกว่าเกณฑ์ — ปิด
2. ยอด Margin ถ้า margin บนกระดานใดกระดานหนึ่งลดลงต่ำกว่าระดับปลอดภัย — rebalance หรือปิด
3. ความแตกต่างของราคา ถ้า unrealized P&L ด้านใดด้านหนึ่งเกินขีดจำกัด — ปิด

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)

รูปแบบขั้นสูง

อาร์บิทราจ Spot-Perp

แทนที่จะใช้ futures บนสองกระดาน คุณสามารถใช้ spot + futures บนกระดานเดียวกัน:

• ซื้อ spot (ไม่มี funding)
• Short perpetual futures (รับ funding เมื่ออัตราเป็นบวก)

ข้อดี: ทุกอย่างอยู่บนกระดานเดียว จัดการ margin ง่ายกว่า ข้อเสีย: ใช้ได้เฉพาะเมื่อ funding เป็นบวก (long จ่ายให้ short) ซึ่งเกิดขึ้น ~70% ของเวลาในตลาดขาขึ้น

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)

อาร์บิทราจหลายกระดาน

เมื่อติดตาม 5+ กระดานพร้อมกัน คุณสามารถหาโอกาสที่ดีกว่าได้ อัลกอริทึม:

1. รวบรวม funding rate จากทุกกระดาน
2. หาคู่ที่มี spread สูงสุด
3. ตรวจสอบสภาพคล่องและความลึกของ order book บนทั้งสองกระดาน
4. ถ้า spread > เกณฑ์ — เปิด position
5. Rescan อย่างต่อเนื่อง: ถ้าคู่ที่ดีที่สุดเปลี่ยน — หมุนเวียน

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

การทำนาย Funding Rate

Funding rate คำนวณด้วยสูตรที่รวม premium index — ส่วนต่างระหว่างราคา futures และ spot Premium อัปเดตบ่อยกว่า funding (ทุกนาที vs ทุก 8 ชั่วโมง) นั่นหมายความว่าคุณสามารถ ทำนาย funding rate ครั้งถัดไปได้ก่อนการจ่ายเงินเป็นนาทีหรือหลายชั่วโมง

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

เมื่อรู้ funding rate ที่คาดการณ์ได้ คุณสามารถเปิด position ก่อน การจ่าย เมื่อ spread ยังไม่ดึงดูดความสนใจของ arbitrageurs รายอื่น

ข้อกำหนดด้านโครงสร้างพื้นฐาน

สำหรับอาร์บิทราจ Funding Rate อย่างจริงจัง คุณต้องการโครงสร้างพื้นฐาน:

เศรษฐศาสตร์ที่มาตราส่วนต่างกัน

ROC ไม่ขึ้นอยู่กับมาตราส่วน (เมื่อสภาพคล่องเพียงพอ) แต่กำไรสัมบูรณ์ที่ทุน $10K อาจไม่คุ้มกับต้นทุนโครงสร้างพื้นฐานและเวลาที่ใช้

บทสรุป

อาร์บิทราจ Funding Rate เป็นกลยุทธ์เชิงโครงสร้างที่ delta-neutral ไม่ต้องการการทำนายราคา แต่ต้องการ:

1. โครงสร้างพื้นฐาน — ติดตาม rate แบบ real-time บนหลายกระดาน
2. ความเร็วในการดำเนินการ — เปิด position พร้อมกันบนกระดานต่างๆ
3. การจัดการความเสี่ยง — ควบคุม margin ความแตกต่างของราคา และการเปลี่ยนแปลง spread
4. ทุน — กำไรเป็นสัดส่วนกับขนาด position

Funding rate spread ไม่คงที่ จะขยายตัวในช่วงที่มีความผันผวนและแคบลงในช่วงที่สงบ งานคือการหาและใช้ประโยชน์จากความแตกต่างโดยอัตโนมัติในขณะที่มันยังคงอยู่

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับวิธีที่ funding rate ส่งผลต่อกลยุทธ์ leverage — ดูบทความ Funding Rates Kill Your Leverage: Why PnL×50x Is a Fiction.

ลิงก์ที่เป็นประโยชน์

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

อ้างอิง

@article{soloviov2026fundingarbitrage,
  author = {Soloviov, Eugen},
  title = {Funding Rate Arbitrage Across Exchanges: How to Profit from Rate Differences},
  year = {2026},
  url = {https://marketmaker.cc/th/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.}
}