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

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) हर घंटे भुगतान करते हैं, जिससे अतिरिक्त अवसर बनते हैं।

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

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

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

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

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

उदाहरण

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

क्रियाएं:

1. Bybit पर शॉर्ट खोलें — हर 8 घंटे में 0.04% प्राप्त करें
2. Binance पर लॉन्ग खोलें — हर 8 घंटे में 0.01% भुगतान करें
3. पोजीशंस मिरर की गई हैं — कीमत का जोखिम न्यूट्रल है
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. एक्सचेंजों के बीच कीमत में अंतर

अलग-अलग एक्सचेंजों पर पोजीशंस एक ही कीमत पर नहीं होतीं। 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')

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)
• मार्जिन लेवल अलर्ट सेट करें
• ऑटोमेटिक रीबैलेंसिंग: असंतुलन होने पर — एक्सचेंजों के बीच फंड ट्रांसफर करें

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

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

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%

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

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

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

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

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

1. फंडिंग रेट स्प्रेड। यदि स्प्रेड सीमा से नीचे सिकुड़ता है — बंद करें।
2. मार्जिन बैलेंस। यदि किसी एक्सचेंज पर मार्जिन सुरक्षित स्तर से नीचे गिरता है — रीबैलेंस करें या बंद करें।
3. कीमत का अंतर। यदि किसी एक तरफ का अनरियलाइज्ड 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)

एडवांस्ड वेरिएंट्स

स्पॉट-पर्प आर्बिट्राज

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

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

फायदा: सब कुछ एक ही एक्सचेंज पर, आसान मार्जिन मैनेजमेंट। नुकसान: केवल पॉजिटिव फंडिंग के साथ काम करता है (लॉन्ग शॉर्ट को भुगतान करते हैं), जो बुल मार्केट के दौरान ~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. सभी एक्सचेंजों से फंडिंग रेट्स एकत्र करें
2. अधिकतम स्प्रेड वाला पेयर खोजें
3. दोनों एक्सचेंजों पर लिक्विडिटी और ऑर्डर बुक डेप्थ की जांच करें
4. यदि स्प्रेड > सीमा है — पोजीशंस खोलें
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:]:
            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

फंडिंग रेट की भविष्यवाणी

फंडिंग रेट की गणना एक फॉर्मूला का उपयोग करके की जाती है जिसमें प्रीमियम इंडेक्स शामिल होता है — फ्यूचर्स कीमत और स्पॉट कीमत के बीच का अंतर। प्रीमियम फंडिंग की तुलना में अधिक बार अपडेट होता है (हर मिनट बनाम हर 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

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

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

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

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

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

निष्कर्ष

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

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

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

लीवरेज्ड रणनीतियों को फंडिंग रेट्स कैसे प्रभावित करते हैं, इसके बारे में अधिक जानकारी के लिए — देखें लेख 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/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.}
}