एक्सचेंजों के बीच फंडिंग रेट आर्बिट्राज: दरों के अंतर से मुनाफा कैसे कमाएं

ETHUSDT का फंडिंग रेट Binance पर 0.01% है और Bybit पर 0.035%। वही कॉइन, वही समय, लेकिन दरें 3.5 गुना अलग हैं। कोई ज्यादा भुगतान करता है, कोई कम। और कोई इस अंतर से मुनाफा कमाता है।

फंडिंग रेट आर्बिट्राज क्रिप्टो की उन कुछ रणनीतियों में से एक है जो बाजार की दिशा पर निर्भर नहीं करती। आप कीमत का पूर्वानुमान नहीं लगाते। आप विभिन्न प्लेटफॉर्मों के बीच दरों के संरचनात्मक अंतर से मुनाफा निकालते हैं।

एक्सचेंजों में फंडिंग रेट अलग-अलग क्यों होते हैं

फंडिंग रेट एक ऐसा तंत्र है जो परपेचुअल फ्यूचर्स कॉन्ट्रैक्ट की कीमत को स्पॉट कीमत से जोड़े रखता है। हर एक्सचेंज इसे अपने डेटा के आधार पर स्वतंत्र रूप से कैलकुलेट करता है:

ट्रेडर संरचना। Binance पर रिटेल ट्रेडर्स का दबदबा है जो आमतौर पर लॉन्ग लेते हैं। Bybit और OKX पर अधिक प्रोफेशनल भागीदार हैं। अलग-अलग लॉन्ग/शॉर्ट संतुलन से अलग फंडिंग बनती है।
कैलकुलेशन फॉर्मूला। हर एक्सचेंज अपना खुद का फॉर्मूला इस्तेमाल करता है। Binance प्रीमियम इंडेक्स और इंटरेस्ट रेट को शामिल करता है। Bybit और OKX भी ऐसा ही करते हैं लेकिन अलग वेटेज और एवरेजिंग पीरियड के साथ।
लिक्विडिटी। कम लिक्विड एक्सचेंजों पर, प्रीमियम (फ्यूचर्स और स्पॉट के बीच का अंतर) ज्यादा वोलेटाइल होता है, जिससे फंडिंग में व्यापक उतार-चढ़ाव होता है।
भुगतान की आवृत्ति। ज्यादातर एक्सचेंज हर 8 घंटे में फंडिंग का भुगतान करते हैं (00:00, 08:00, 16:00 UTC)। लेकिन कुछ (कुछ पेयर्स के लिए Bybit, dYdX) हर घंटे भुगतान करते हैं, जिससे अतिरिक्त अवसर बनते हैं।

सामान्य विसंगतियाँ

Funding rate spreads across exchanges

शांत बाजार में, प्रमुख एक्सचेंजों पर फंडिंग रेट करीब होते हैं — अंतर 0.001-0.005% होता है। लेकिन उच्च अस्थिरता की अवधि में, विसंगतियाँ बढ़ जाती हैं:

बाजार चरण	Binance	Bybit	OKX	dYdX	स्प्रेड
शांत	0.01%	0.012%	0.009%	0.01%	~0.003%
तेजी का ट्रेंड	0.03%	0.05%	0.025%	0.04%	~0.025%
अत्यधिक तेजी	0.1%	0.2%	0.08%	0.15%	~0.12%
मंदी का ट्रेंड	-0.02%	-0.01%	-0.025%	-0.015%	~0.015%

8 घंटे में 0.025% का स्प्रेड यानी प्रति दिन 0.075%। $100K की पोजीशन साइज पर, यह$ 75/दिन या ~$2,250/महीना है — बिना किसी दिशात्मक जोखिम के।

आर्बिट्राज की बुनियादी मैकेनिक्स

Cross-exchange funding rate arbitrage: opposite positions on two exchanges

विचार सरल है: दो एक्सचेंजों पर विपरीत पोजीशन खोलें ताकि आपको एक पर फंडिंग मिले और दूसरे पर कम भुगतान करना पड़े।

उदाहरण

Binance: फंडिंग रेट = +0.01% (लॉन्ग शॉर्ट को भुगतान करते हैं) Bybit: फंडिंग रेट = +0.04% (लॉन्ग शॉर्ट को भुगतान करते हैं)

क्रियाएं:

Bybit पर शॉर्ट खोलें — हर 8 घंटे में 0.04% प्राप्त करें
Binance पर लॉन्ग खोलें — हर 8 घंटे में 0.01% भुगतान करें
पोजीशंस मिरर की गई हैं — कीमत का जोखिम न्यूट्रल है
नेट प्रॉफिट: 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.
    """
    # Short receives rate_short, long pays rate_long
    spread = rate_short_exchange - rate_long_exchange
    daily_pnl = spread * payments_per_day * position_size
    return daily_pnl * days

# Example: short on Bybit (0.04%), long on Binance (0.01%)
pnl = funding_arbitrage_pnl(0.0004, 0.0001, 100_000, days=30)
# = (0.0004 - 0.0001) * 3 * 100_000 * 30 = $2,700

जोखिम और मुश्किलें

Risks of cross-exchange arbitrage: liquidation, price divergence, fee erosion

यह रणनीति "मुफ्त पैसे" जैसी दिखती है। यह ऐसी नहीं है। इसमें कई गंभीर जोखिम हैं।

1. एक्सचेंजों के बीच कीमत में अंतर

अलग-अलग एक्सचेंजों पर पोजीशंस एक ही कीमत पर नहीं होतीं। Binance और Bybit के बीच स्प्रेड आमतौर पर 0.01-0.05% होता है, लेकिन उच्च अस्थिरता के दौरान यह 0.5-1% तक पहुंच सकता है। यदि आप पोजीशंस एक साथ नहीं खोलते, तो यह अंतर फंडिंग मुनाफे से अधिक हो सकता है।

समाधान: न्यूनतम लेटेंसी के साथ API के जरिए एक साथ ओपनिंग। आदर्श रूप से — दोनों एक्सचेंजों के पास को-लोकेटेड सर्वर।

2. फंडिंग रेट में बदलाव

आपने 0.03% स्प्रेड पर पोजीशंस खोलीं। एक घंटे बाद स्प्रेड घटकर 0.005% हो गया या उलट गया। अब आप दोनों एक्सचेंजों पर भुगतान कर रहे हैं।

समाधान: रियल-टाइम स्प्रेड मॉनिटरिंग और स्प्रेड सीमा से नीचे गिरने पर ऑटोमेटिक क्लोजिंग।

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. ट्रेडिंग कमीशन

दो एक्सचेंजों पर पोजीशंस खोलने और बंद करने का मतलब है 4 ऑर्डर। 0.02% मेकर फी और 0.05% टेकर फी पर:

आशावादी परिदृश्य (सभी मेकर): $4 \times 0.02\% = 0.08\%$
निराशावादी परिदृश्य (सभी टेकर): $4 \times 0.05\% = 0.20\%$

कमीशन का ब्रेकईवन करने के लिए, पोजीशन को पर्याप्त समय तक होल्ड करना होगा:

$\text{ब्रेकईवन समय} = \frac{\text{कुल कमीशन}}{\text{स्प्रेड} \times \text{प्रति दिन भुगतान}}$

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

# With maker fees: 0.08% / (0.03% * 3) = 0.89 days
# With taker fees: 0.20% / (0.03% * 3) = 2.22 days

4. मार्जिन आवश्यकताएं

दोनों एक्सचेंजों पर पोजीशंस के लिए कोलेटरल चाहिए। $100K पोजीशन के साथ हर एक्सचेंज पर 5x लीवरेज पर:

Binance: $20K कोलेटरल
Bybit: $20K कोलेटरल
कुल लॉक्ड: $100K पोजीशन के लिए **$ 40K**

पूंजी पर रिटर्न: $\text{ROC} = \frac{\$2700}{\$40000} \times 100\% = 6.75\% \text{ प्रति माह}$

10x लीवरेज पर, कोलेटरल घटकर $20K हो जाता है, ROC बढ़कर 13.5% हो जाता है। लेकिन कीमत के अंतर से लिक्विडेशन का जोखिम भी बढ़ता है।

5. लिक्विडेशन जोखिम

यदि एसेट की कीमत तेजी से बदलती है, तो एक पोजीशन में अनरियलाइज्ड लॉस बनता है। जिस एक्सचेंज पर लॉस वाली पोजीशन है, वहां मार्जिन बनाए रखना होगा। यदि मार्जिन अपर्याप्त है — लिक्विडेशन। इस बीच, दूसरे एक्सचेंज पर मुनाफा मदद नहीं करता — वह एक अलग अकाउंट में है।

समाधान:

मार्जिन रिजर्व बनाए रखें (न्यूनतम का कम से कम 2x)
मार्जिन लेवल अलर्ट सेट करें
ऑटोमेटिक रीबैलेंसिंग: असंतुलन होने पर — एक्सचेंजों के बीच फंड ट्रांसफर करें

फंडिंग रेट मॉनिटरिंग सिस्टम

Real-time funding rate monitoring dashboard across multiple exchanges

आर्बिट्राज की ओर पहला कदम डेटा कलेक्शन है। आपको सभी संबंधित एक्सचेंजों पर रियल टाइम में फंडिंग रेट्स ट्रैक करना होगा।

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.
        """
        # Collect funding rates in parallel
        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]

        # Group by symbol
        by_symbol: dict[str, list[FundingSnapshot]] = {}
        for s in snapshots:
            by_symbol.setdefault(s.symbol, []).append(s)

        # Find spreads
        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%

एक्जीक्यूशन: एक साथ पोजीशन खोलना

Simultaneous arbitrage execution across exchanges

दिशात्मक जोखिम एक्सपोजर से बचने के लिए लॉन्ग और शॉर्ट को यथासंभव एक साथ खोलना अति महत्वपूर्ण है।

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.
    """
    # Get current prices
    long_ticker = await long_exchange.fetch_ticker(symbol)
    short_ticker = await short_exchange.fetch_ticker(symbol)

    # Check the spread between exchanges
    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"
        )

    # Open simultaneously
    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

पोजीशन मैनेजमेंट

खोलने के बाद, निरंतर मॉनिटरिंग की आवश्यकता है:

फंडिंग रेट स्प्रेड। यदि स्प्रेड सीमा से नीचे सिकुड़ता है — बंद करें।
मार्जिन बैलेंस। यदि किसी एक्सचेंज पर मार्जिन सुरक्षित स्तर से नीचे गिरता है — रीबैलेंस करें या बंद करें।
कीमत का अंतर। यदि किसी एक तरफ का अनरियलाइज्ड 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:
        # Check the current spread
        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']
        )

        # Check margin balance
        long_balance = await long_exchange.fetch_balance()
        short_balance = await short_exchange.fetch_balance()

        # Check unrealized P&L
        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

        # Closing conditions
        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-perpetual futures carry trade: spot holdings and short perp position on one exchange

दो एक्सचेंजों पर फ्यूचर्स की जगह, आप एक ही एक्सचेंज पर स्पॉट + फ्यूचर्स का उपयोग कर सकते हैं:

स्पॉट खरीदें (कोई फंडिंग नहीं)
परपेचुअल फ्यूचर्स शॉर्ट करें (जब दर पॉजिटिव हो तो फंडिंग प्राप्त करें)

फायदा: सब कुछ एक ही एक्सचेंज पर, आसान मार्जिन मैनेजमेंट। नुकसान: केवल पॉजिटिव फंडिंग के साथ काम करता है (लॉन्ग शॉर्ट को भुगतान करते हैं), जो बुल मार्केट के दौरान ~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.
    """
    # Entry/exit costs
    total_fees = (spot_fee + perp_fee) * 2  # opening + closing

    # Daily income from funding (at 3 payments)
    daily_income = funding_rate * 3

    # Breakeven
    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,
    }

# Example: funding rate 0.03%
result = spot_perp_carry(0.0003)
# daily: 0.09%, monthly: 2.7%, annualized: 32.9%, breakeven: 3.3 days

मल्टी-एक्सचेंज आर्बिट्राज

Multi-exchange network graph showing funding rate differentials between five exchanges

एक साथ 5+ एक्सचेंजों की मॉनिटरिंग करने पर, आप अधिक अनुकूल अवसर पा सकते हैं। एल्गोरिदम:

सभी एक्सचेंजों से फंडिंग रेट्स एकत्र करें
अधिकतम स्प्रेड वाला पेयर खोजें
दोनों एक्सचेंजों पर लिक्विडिटी और ऑर्डर बुक डेप्थ की जांच करें
यदि स्प्रेड > सीमा है — पोजीशंस खोलें
लगातार पुनः स्कैन करें: यदि सबसे अच्छा पेयर बदल जाए — रोटेट करें

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:]:
            # Long on the exchange with the lower rate, short on the one with the higher rate
            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 prediction using premium index data with confidence cone

फंडिंग रेट की गणना एक फॉर्मूला का उपयोग करके की जाती है जिसमें प्रीमियम इंडेक्स शामिल होता है — फ्यूचर्स कीमत और स्पॉट कीमत के बीच का अंतर। प्रीमियम फंडिंग की तुलना में अधिक बार अपडेट होता है (हर मिनट बनाम हर 8 घंटे)। इसका मतलब है कि आप भुगतान से मिनटों या घंटों पहले अगली फंडिंग रेट का पूर्वानुमान लगा सकते हैं।

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

अनुमानित फंडिंग रेट को जानकर, आप भुगतान से पहले पोजीशंस खोल सकते हैं, जब स्प्रेड ने अभी तक अन्य आर्बिट्राजर्स का ध्यान आकर्षित नहीं किया हो।

इंफ्रास्ट्रक्चर आवश्यकताएं

Low-latency trading infrastructure for cross-exchange arbitrage

गंभीर फंडिंग रेट आर्बिट्राज के लिए, आपको इंफ्रास्ट्रक्चर की आवश्यकता है:

कंपोनेंट	न्यूनतम	इष्टतम
सर्वर	क्लाउड VPS	एक्सचेंजों के पास को-लोकेटेड
लेटेंसी	< 500ms	< 50ms
API कीज़	2 एक्सचेंज	5+ एक्सचेंज
प्रति एक्सचेंज पूंजी	$10K प्रत्येक	$50K+ प्रत्येक
मॉनिटरिंग	लॉग्स + अलर्ट्स	डैशबोर्ड + ऑटो-रीबैलेंसिंग
डेटा	REST API पोलिंग	WebSocket स्ट्रीमिंग

अलग-अलग स्केल पर अर्थशास्त्र

पूंजी	पोजीशन (5x)	स्प्रेड 0.03%	मासिक PnL	ROC
$10K	$25K	0.03%	~$675	~6.75%
$50K	$125K	0.03%	~$3,375	~6.75%
$200K	$500K	0.03%	~$13,500	~6.75%

ROC स्केल पर निर्भर नहीं करता (पर्याप्त लिक्विडिटी दिए जाने पर)। लेकिन $10K पूंजी पर एब्सोल्यूट मुनाफा इंफ्रास्ट्रक्चर लागत और समय को सही नहीं ठहरा सकता।

निष्कर्ष

फंडिंग रेट आर्बिट्राज एक संरचनात्मक, डेल्टा-न्यूट्रल रणनीति है। इसके लिए कीमत का पूर्वानुमान करने की जरूरत नहीं है, लेकिन इसके लिए आवश्यक है:

इंफ्रास्ट्रक्चर — कई एक्सचेंजों में रियल-टाइम रेट मॉनिटरिंग
एक्जीक्यूशन स्पीड — विभिन्न प्लेटफॉर्मों पर एक साथ पोजीशंस खोलना
रिस्क मैनेजमेंट — मार्जिन, कीमत के अंतर और स्प्रेड में बदलाव को नियंत्रित करना
पूंजी — मुनाफा पोजीशन साइज के अनुपात में होता है

फंडिंग रेट स्प्रेड स्थिर नहीं होते। ये अस्थिरता की अवधि में बढ़ते हैं और शांत अवधि में सिकुड़ते हैं। काम यह है कि जब तक विसंगतियां मौजूद हैं, उन्हें स्वचालित रूप से खोजें और उनका फायदा उठाएं।

लीवरेज्ड रणनीतियों को फंडिंग रेट्स कैसे प्रभावित करते हैं, इसके बारे में अधिक जानकारी के लिए — देखें लेख Funding Rates Kill Your Leverage: Why PnL×50x Is a Fiction।

उपयोगी लिंक

उद्धरण

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