Genesis Arbitrage

Genesis Arbitrage · · 14 मिनट में पढ़ें

Crypto order book API: exchanges के बीच depth, execution price और slippage

संक्षेप में

  • Order book API bid और ask levels लौटाती है — हर level पर कीमत और साइज़ — REST snapshot या बदलावों की WebSocket stream के रूप में। Best bid और ask सिर्फ़ ट्रेड के पहले कुछ डॉलर बताते हैं।
  • Depth बड़े ऑर्डर की कीमत तय करती है। एक काल्पनिक उदाहरण में $10,000 की खरीद पाँच levels से गुज़रती है, उसकी औसत कीमत book mid से 25 basis points ऊपर बैठती है, और exchanges के बीच spread 1.20% से घटकर 0.70% रह जाता है।
  • Pro और Max प्लान पर Genesis API $500–$10,000 के तैयार execution price, arbitrage पंक्तियों के लिए Order-book Δ, book की उम्र और depth, slippage का इतिहास और DEX slippage ladder देती है। सिर्फ़ REST; books exchange से 5–20 सेकंड पीछे रहती हैं।

Crypto order book API किसी trading pair के मौजूदा खरीद और बिक्री ऑर्डर लौटाती है, कीमत के level के हिसाब से समूहित: हर level पर एक कीमत होती है और उस कीमत पर पड़ा साइज़। इन levels से आप किसी दिए गए साइज़ के ऑर्डर का execution price, उसका slippage और market depth निकालते हैं, और दो exchanges की books से यह कि असली ट्रेड के बाद spread का कितना हिस्सा बचता है।

Exchange अपनी book REST snapshot या WebSocket stream के रूप में देता है, जबकि Pro और Max प्लान पर Genesis API कई exchanges के तैयार execution price, depth और Order-book Δ एक साथ देती है।

Order book API क्या लौटाती है

Order book एक pair के पड़े हुए limit ऑर्डरों की सूची है। खरीद ऑर्डर (bids) ऊँची कीमत से नीचे की ओर, बिक्री ऑर्डर (asks) नीची कीमत से ऊपर की ओर क्रमबद्ध होते हैं। Level यानी एक कीमत और उस पर कुल साइज़; best ask और best bid के बीच का अंतर book का spread है।

REST snapshot एक रिक्वेस्ट का जवाब है: उसी क्षण के levels। Binance का order book endpoint सार्वजनिक है और API key नहीं माँगता; यह BTC/USDT के शीर्ष पाँच levels की रिक्वेस्ट और उसका जवाब है (संख्याएँ काल्पनिक हैं):

curl "https://api.binance.com/api/v3/depth?symbol=BTCUSDT&limit=5"
{
  "lastUpdateId": 81273645120,
  "bids": [["96015.90000000", "1.25000000"], …],
  "asks": [["96016.00000000", "0.84100000"], …]
}

हर level strings की जोड़ी [कीमत, मात्रा] के रूप में आता है, मात्रा coins में: best bid में 1.25 × 96,015.9 = $120,019.88 है। limit पैरामीटर का डिफ़ॉल्ट 100 है और यह हर पक्ष पर 5,000 levels तक जाता है (Binance docs)।

WebSocket stream exchange स्थायी कनेक्शन पर खुद भेजता है। Binance में book की दो तरह की streams हैं: btcusdt@depth5, btcusdt@depth10 और btcusdt@depth20 शीर्ष 5, 10 या 20 levels भेजती हैं, जबकि btcusdt@depth सिर्फ़ बदलाव भेजती है। दोनों हर 1000 ms पर अपडेट होती हैं, या @100ms प्रत्यय के साथ हर 100 ms पर (Binance WebSocket streams)।

पूरी लोकल book snapshot और diff stream से बनती है, snapshot के lastUpdateId को event के update ID से मिलाकर; कोई event छूट जाए तो book शुरू से दोबारा बनाई जाती है।

तरीकाक्या मिलता हैकिसके लिए
REST snapshotरिक्वेस्ट के समय के levels, Binance पर हर पक्ष 5,000 तकएक बार की जाँच, कम बार polling
WebSocket streamशीर्ष levels या बदलाव, हर 100–1000 msमेमोरी में लोकल book, trading bot
REST पर Genesis API[कीमत, USD राशि] के रूप में levels, execution price, depth और book की उम्रexchanges की तुलना, setup की जाँच

बड़े साइज़ पर best bid और ask भ्रम क्यों देते हैं

Best ask सिर्फ़ पहले level की कीमत है। उस level से बड़ी market खरीद अगले, महँगे levels भी लेती है, और औसत fill price चढ़ता जाता है — यही slippage है।

एक काल्पनिक उदाहरण: exchange A पर token ABC, best bid 0.9996, best ask 1.0004, book mid 1.0000। $10,000 की market खरीद पाँच ask levels से गुज़रती है:

Ask कीमतBook में, $लिया गया, $Coins
1.00041,1001,1001,099.56
1.00101,4001,4001,398.60
1.00182,6002,6002,595.33
1.00303,0003,0002,991.03
1.00506,0001,9001,890.55

ऑर्डर कुल 9,975.07 coins खरीदता है। औसत fill price VWAP है, यानी volume-weighted औसत कीमत: 10,000 / 9,975.07 ≈ 1.0025।

Best ask से slippage: (1.0025 − 1.0004) / 1.0004 × 100 ≈ 0.21%। Book mid से: (1.0025 − 1.0000) / 1.0000 × 10,000 = 25 basis points। इनमें से चार book spread का आधा हैं, जो हर market खरीद चुकाती है; बाकी 21 depth से आते हैं।

±X% के भीतर market depth और walls

Market depth best कीमत से एक तय दूरी के भीतर ऑर्डरों का कुल साइज़ है। उदाहरण में best से +0.2% के भीतर, 1.0024 तक, asks का जोड़ 1,100 + 1,400 + 2,600 = $5,100 है, और +0.5% के भीतर, 1.0054 तक, $14,100।

Depth को क्षमता की तरह पढ़ें: +0.2% के भीतर की depth से बड़ा ऑर्डर उस सीमा के पार के levels पर भरेगा। Exchange A पर $5,000 की खरीद उसके भीतर आ जाती है, $10,000 की नहीं।

Wall एक ही level पर पड़ा बड़ा ऑर्डर है, जो पड़ोसी levels से साफ़ बड़ा हो: उदाहरण में 1.0050 पर $6,000। जब तक wall खड़ी है वह कीमत थामे रखती है, पर आपका ऑर्डर पहुँचने से एक सेकंड पहले उसे हटाया जा सकता है, और तब खरीद उसके पीछे के levels पर भरती है।

Genesis API में depth /orderbooks/book से आती है, जो एक market की book है, और /orderbooks/coin/{coin} से, जो एक coin की books हर exchange और market पर एक साथ देता है (बाज़ार ऑर्डर बुक, कॉइन ऑर्डर बुक)। जवाब में शीर्ष 10 bids और asks [कीमत, USD राशि] के रूप में, सबसे बड़ी walls walls_bid और walls_ask में, और best कीमत के ±50% के भीतर पूरे पक्ष की depth depth_bid_usd और depth_ask_usd में होती है। ±50% का गलियारा चौड़ा है, इसलिए किसी ख़ास साइज़ के लिए levels या तैयार execution price देखें।

Book की उम्र: पुरानी books और सीमित depth

हर book snapshot की एक उम्र होती है। अगर एक exchange की book दूसरी से 15 सेकंड पुरानी है, तो उनके बीच के spread का कुछ हिस्सा समय का अंतर हो सकता है: पुरानी book की कीमत पहले ही खिसक चुकी है।

Genesis API में books exchange से 5–20 सेकंड पीछे रहती हैं, और हर book अपनी उम्र साथ लाती है। Docs से /orderbooks/book के जवाब की शुरुआत:

{
  "exchange": "Binance",
  "market": "spot",
  "coin": "BTC",
  "book_ts": 1794675858,
  "age_sec": 6,
  "stale": false,
  "source": "ws",
  "depth_limited": false,
  "levels_bid": 500,
  "levels_ask": 500,
  …
}

book_ts book का समय है unix सेकंड में, age_sec उसकी उम्र सेकंड में, और stale: true 30 सेकंड से पुरानी book को चिह्नित करता है। source बताता है कि book exchange से कैसे ली गई: WebSocket (ws) से या REST रिक्वेस्ट (rest) से।

depth_limited: true का मतलब है कि exchange सीमित depth प्रकाशित करता है: कुल अधूरे हैं, और बड़ा ऑर्डर पूरा न भरे। जब ऑर्डर खत्म हो जाते हैं, /orderbooks/exec कीमत की जगह null लौटाता है, और Order-book Δ exhausted स्टेटस।

Exchanges के बीच executable spread: Order-book Δ

काल्पनिक उदाहरण पर लौटें। Exchange B पर आख़िरी ट्रेड 1.0120 पर छपा, best bid 1.0116 और ask 1.0124 है। B के bids में 1.0116 पर $1,100, 1.0110 पर $1,300, 1.0102 पर $2,800, 1.0090 पर $2,900 और 1.0070 पर $5,000 हैं।

इन bids में $10,000 बेचने पर उसी सूत्र से VWAP 1.0095 आता है। यह B के book mid से (1.0120 − 1.0095) / 1.0120 × 10,000 ≈ 24.7 basis points नीचे है।

Spread कैसे निकाला गयाA पर खरीद → B पर बिक्रीSpread
आख़िरी ट्रेड, जैसे table की पंक्ति में1.0000 → 1.01201.20%
Book की best कीमतें1.0004 → 1.01161.12%
$10,000 execute होने के बाद1.0025 → 1.00950.70%

पंक्ति का spread: (1.0120 − 1.0000) / 1.0000 × 100 = 1.20%। Execution के बाद: (1.0095 − 1.0025) / 1.0025 × 100 ≈ 0.70%। पंक्ति $10,000 पर $120 का वादा करती है, और books के बाद लगभग $70 बचते हैं: 10,000 × 0.006983 ≈ 69.83।

खोए 50 basis points में से 8 आख़िरी ट्रेड और best ऑर्डरों के बीच के अंतर में गए, और बाकी 42 दोनों books की depth में।

Order-book Δ वह नाम है जो Genesis Arbitrage किसी पंक्ति के उस spread को देता है जो दिए गए साइज़ के लिए order books से दोबारा निकाला गया हो; साइट पर यह arbitrage tables का «Δ ऑर्डर से» कॉलम है, जैसे Spot – Futures। API में यह /orderbooks/spreads/{dataset} से आता है: spot-spot, spot-futures, futures-futures, dex-spot या dex-futures dataset में एक coin की हर पंक्ति को order_delta ऑब्जेक्ट मिलता है (ऑर्डर-बुक Δ)।

order_delta में चुने गए साइज़ के लिए buy_price और sell_price, execution के बाद का spread_pct और एक status होता है: ok, no_book (book नहीं) या exhausted (book नहीं भरी)। volume या तो 0 (book की best कीमतें) है या 500, 1000, 2500, 5000, 10000, और नतीजा पंक्ति के spread से कभी ज़्यादा नहीं होता। DEX पंक्तियों में कीमतों की जोड़ी की जगह side और cex_price होते हैं: CEX पक्ष और उसका execution price।

Execution price खुद, सभी markets के लिए एक साथ, /orderbooks/exec से आते हैं: Binance|spot|BTC जैसी key के नीचे [खरीद कीमत, बिक्री कीमत] की जोड़ी, और जहाँ book बहुत पतली है वहाँ null (निष्पादन कीमतें)।

Coin ट्रांसफ़र और network जाँच के साथ पूरा setup Cross-exchange crypto arbitrage में है।

Python उदाहरण: पंक्ति का spread बनाम execution के बाद का spread

स्क्रिप्ट कम से कम 0.5% spread वाले Spot – Spot setup लेती है, सबसे चौड़े spread वाले दस coins के लिए $5,000 पर Order-book Δ माँगती है और छापती है कि books ने कितने basis points खा लिए। Key GENESIS_API_KEY environment variable से आती है। 429 और 503 पर स्क्रिप्ट Retry-After सेकंड रुकती है, और अगर प्रतीक्षा एक मिनट से लंबी हो — मासिक कोटा खत्म हो गया — तो रुक जाती है।

import os
import time
import requests

BASE = "https://api.genesisarbitrage.com/v1"
HEADERS = {"X-API-Key": os.environ["GENESIS_API_KEY"]}
VOLUME = 5000      # हर leg के डॉलर
MIN_SPREAD = 0.5   # पंक्ति का spread, %


def get(path, params):
    for _ in range(3):
        r = requests.get(BASE + path, headers=HEADERS,
                         params=params, timeout=15)
        if r.status_code in (429, 503):
            wait = int(r.headers.get("Retry-After", "5"))
            if wait > 60:  # मासिक कोटा खत्म हो गया
                break
            time.sleep(wait)
            continue
        r.raise_for_status()
        return r.json()["data"]
    raise RuntimeError("API ने जवाब नहीं दिया, बाद में कोशिश करें")


rows = get("/arbitrage/spot-spot", {"min_spread": MIN_SPREAD})
rows.sort(key=lambda x: x["spread_pct"], reverse=True)
coins = list(dict.fromkeys(x["coin"] for x in rows))[:10]

for coin in coins:
    data = get("/orderbooks/spreads/spot-spot",
               {"coin": coin, "volume": VOLUME})
    for row in data:
        od = row["order_delta"]
        if row["spread_pct"] < MIN_SPREAD or od["status"] != "ok":
            continue  # no_book या exhausted: यह साइज़ नहीं भरेगा
        lost = (row["spread_pct"] - od["spread_pct"]) * 100
        print(f'{coin} {row["exchange_buy"]}→{row["exchange_sell"]}'
              f' {row["spread_pct"]:.2f}% → {od["spread_pct"]:.2f}%,'
              f' books ने {lost:.0f} bps खाए')
    time.sleep(0.25)  # प्रति सेकंड 4 रिक्वेस्ट तक: Pro में 5 की अनुमति

स्क्रिप्ट coins के बीच 0.25 s के ठहराव के साथ 11 कॉल तक करती है। इसे लूप में meta.freshness_sec से ज़्यादा बार न चलाएँ: Pro पर 10 s और Max पर 5 s (Genesis API limits)। इसमें नोटिफ़िकेशन जोड़ने के लिए Python में Crypto Arbitrage Bot देखें।

Execution cost का इतिहास

अकेला snapshot नहीं बता सकता कि मौजूदा slippage इस market के लिए सामान्य है या book सामान्य से पतली है। /orderbooks/exec-history Genesis Charts से इतिहास लौटाता है: $500, $1,000, $2,500, $5,000 और $10,000 का execution book mid से कितने basis points महँगा पड़ा, खरीद और बिक्री अलग-अलग (निष्पादन इतिहास)।

हर interval में 360 बिंदु होते हैं: 1m 6 घंटे, 15m 3.75 दिन, 1h 15 दिन और 1d लगभग एक साल कवर करता है, डेटा 6 सितंबर 2026 से। एक रिक्वेस्ट keys पैरामीटर में 8 markets तक लेती है। खरीद के मान धनात्मक और बिक्री के ऋणात्मक होते हैं; null का मतलब डेटा नहीं है या book नहीं भरी। Genesis API खुद book के पुराने snapshots नहीं देती।

import os
import statistics
import requests

KEY = "Binance|spot|BTC"
r = requests.get(
    "https://api.genesisarbitrage.com/v1/orderbooks/exec-history",
    headers={"X-API-Key": os.environ["GENESIS_API_KEY"]},
    params={"keys": KEY, "interval": "1h"},  # 360 घंटे, 15 दिन
    timeout=15,
)
r.raise_for_status()
data = r.json()["data"]
series = data["series"][KEY]
if series is None:
    raise SystemExit("market नहीं मिला: " + KEY)
i = data["volumes_usd"].index(10000)  # $10,000 की खरीद की series
buy = series["buy"][i]
known = [x for x in buy if x is not None]
if not known:
    raise SystemExit("इस अवधि का डेटा नहीं है")
print("15 दिन की median, bps:", statistics.median(known))
print("आख़िरी बिंदु, bps:", buy[-1])

काल्पनिक रूप से, अगर 15 दिन की median 12 basis points है और आख़िरी बिंदु 25, तो अभी execution सामान्य से दोगुना महँगा है, और इस coin के लिए spread की सीमा बढ़ाना समझदारी है।

DEX: slippage ladder, token tax और honeypot

DEX pool में order book नहीं होती: swap की कीमत pool के सूत्र से आती है, और ट्रेड liquidity के मुक़ाबले जितना बड़ा होता है कीमत उतनी ज़्यादा खिसकती है। इसीलिए DEX leg को ladder से आँका जाता है — साइज़ की एक श्रृंखला पर slippage।

/orderbooks/dex-slippage हर contract के लिए $100, $500, $1,000, $2,500, $5,000, $10,000, $20,000, $50,000 और $100,000 पर खरीद और बिक्री का slippage, token tax और honeypot फ़्लैग लौटाता है, साइट की DEX table के वही कॉलम (DEX स्लिपेज)। Docs के नमूना जवाब में खरीद का slippage $10,000 पर 0.86%, $50,000 पर 3.12% और $100,000 पर 6.05% है।

यही setup की सीमा तय करता है: 2% का DEX – CEX spread $10,000 पर pool के slippage से बच जाता है पर $50,000 पर नहीं, fees से पहले ही। Ladder में null का मतलब है कि pool में उस साइज़ के लिए liquidity नहीं है, और network gas जवाब में नहीं है, इसलिए उसका अलग हिसाब रखें।

tax_buy_pct और tax_sell_pct token का खरीद और बिक्री tax हैं, % में; null का मतलब स्रोत नहीं है और इसे शून्य नहीं पढ़ना चाहिए। honeypot: no — कोई संकेत नहीं, suspect — स्रोत असहमत हैं, yes — token बेचना असंभव हो सकता है।

Token की मैन्युअल जाँच के लिए खरीदने से पहले token कैसे जाँचें देखें; CEX के साथ DEX की कीमत और liquidity के लिए DEX API।

Genesis API में order books: endpoints और प्लान

कामEndpoint
हर market पर $500–$10,000 का execution price/orderbooks/exec
Execution के बाद पंक्ति का spread/orderbooks/spreads/{dataset}
10 levels, walls, depth और book की उम्र/orderbooks/book
एक coin की books हर exchange पर/orderbooks/coin/{coin}
Execution cost का इतिहास/orderbooks/exec-history
DEX slippage, tax और honeypot फ़्लैग/orderbooks/dex-slippage

छहों Pro और Max API प्लान का हिस्सा हैं। Pro $100 प्रति माह है: 5M कॉल, 5 रिक्वेस्ट प्रति सेकंड, 10 s freshness। Max $200 है: 10M कॉल, 15 रिक्वेस्ट प्रति सेकंड, 5 s; Trial और Start पर order book endpoints 403 plan_restricted लौटाते हैं।

पैरामीटर और जवाबों के उदाहरण order book endpoints गाइड में हैं; API के डेटा के अवलोकन के लिए Crypto API और पाठ Arbitrage के लिए API डेटा देखें।

सवाल और जवाब

Table का spread ट्रेड में मिलने वाले spread से बड़ा क्यों है?

पंक्ति का spread आख़िरी ट्रेड से आता है, जबकि market ऑर्डर book के सामने भरता है, और साइज़ जितना बड़ा होगा उसकी औसत कीमत best कीमत से उतनी दूर जाएगी। ऊपर से fees और ट्रांसफ़र के दौरान कीमत की चाल जुड़ती है। Order-book Δ दिखाता है कि आपके साइज़ पर spread का कितना बचता है।

Order books कितनी बार अपडेट होती हैं?

Book हर नए ऑर्डर और cancel के साथ बदलती है; Binance की stream बदलाव हर 100 या 1000 ms पर भेजती है। Genesis API में books exchange से 5–20 सेकंड पीछे रहती हैं (उम्र age_sec में है), और जवाब Pro पर हर 10 सेकंड और Max पर हर 5 सेकंड में ताज़ा होते हैं।

क्या Genesis API में order books के लिए WebSocket है?

नहीं। Genesis API सिर्फ़ REST है: HTTP GET रिक्वेस्ट और JSON जवाब। Books की real-time streams exchanges के अपने WebSocket से आती हैं, और exchange की trading API से ऑर्डर लगाने वाले bot को वही चाहिए।

क्या मुफ़्त order book API है?

Exchanges के सार्वजनिक endpoints होते हैं: /api/v3/depth पर Binance की book बिना key के जवाब देती है, पर वह एक ही exchange कवर करती है, और execution price आप खुद निकालते हैं। Genesis API में मुफ़्त प्लान नहीं है; order books Pro में $100 प्रति माह और Max में $200 पर शामिल हैं।