Genesis Arbitrage

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

Python में Crypto Arbitrage Bot: spread API से Telegram alerts तक

संक्षेप में

  • Crypto arbitrage bot की चार कड़ियाँ हैं: spread का डेटा, अमल में लाए जा सकने वाले pairs का फ़िल्टर, alert और इंसान का फ़ैसला। कोड पहली तीन करता है; ट्रेड आप एक्सचेंजों पर ख़ुद लगाते हैं।
  • Arbitrage में सबसे मुश्किल हिस्सा execution है: कॉइन ट्रांसफर, फ़ीस, slippage और समय। इसलिए bot सिर्फ़ वे pairs रखता है जिनमें withdrawal और deposit खुले हैं, और Pro व Max पर $1,000 के order book से spread दोबारा निकालता है।
  • Bot Genesis API को meta.freshness_sec से ज़्यादा बार नहीं पूछता, 429 और 503 पर Retry-After तक रुकता है, और एक pair पर 15 मिनट में अधिकतम एक बार alert भेजता है। बुनियादी संस्करण $20 प्रति माह के Trial प्लान पर चलता है।

Crypto arbitrage bot एक प्रोग्राम है जो तय समय पर एक्सचेंजों के बीच spread लेता है — यानी एक कॉइन की क़ीमतों का अंतर, प्रतिशत में — उन pairs को रखता है जिन पर सच में अमल हो सकता है और उनके बारे में alert देता है। फ़ैसला और ट्रेड इंसान करता है। स्पॉट cross-exchange arbitrage के लिए ऐसा bot लगभग 140 लाइन के Python कोड में बन जाता है: spread Genesis API से आते हैं और संदेश Telegram Bot API से जाते हैं।

Arbitrage bot किससे बनता है

हर arbitrage bot चार कड़ियों से बनता है:

कड़ीक्या करती हैइस bot में
डेटाएक्सचेंजों की क़ीमतें और spread लाती हैGenesis API GET /arbitrage/spot-spot
फ़िल्टरअमल में लाए जा सकने वाले pairs रखता हैDeposit और withdrawal की स्थिति, $1,000 का Order-book Δ
Alertpair की सूचना देता हैTelegram Bot API की sendMessage विधि
फ़ैसला और ट्रेडpair जाँचता है और ट्रेड करता हैएक्सचेंजों पर इंसान

अपना डेटा कलेक्टर बनाना सबसे धीमी कड़ी है: हर एक्सचेंज का अपना API, टिकर और नेटवर्क के अपने नाम और deposit व withdrawal की अपनी स्थितियाँ हैं, और सबको एक फ़ॉर्मैट में जोड़ना पड़ता है। Genesis API 20 से ज़्यादा CEX एक्सचेंजों के तैयार pairs देता है, जिनमें Binance, OKX, Bybit, Bitget, MEXC और Gate शामिल हैं, साथ में क़ीमतें, spread, नेटवर्क, contract, deposit और withdrawal की स्थिति और वॉल्यूम। हर arbitrage endpoint के फ़ील्ड Genesis API के arbitrage endpoints गाइड में हैं, और डेटा स्रोत चुनने की बात Crypto API: प्रकार और कैसे चुनें में है।

ट्रेड इंसान के पास क्यों रहते हैं

Spread ढूँढना arbitrage का आसान हिस्सा है। Execution मुश्किल हिस्सा है: API के जवाब की एक पंक्ति और आपके खाते के पैसे के बीच चार रुकावटें हैं।

काल्पनिक उदाहरण: bot 1.2% spread वाला pair भेजता है, जो $1,000 पर $12 है। $1,000 के order book से गुज़रने के बाद 0.8% बचता है, यानी $8। ख़रीद और बिक्री पर 0.1% taker फ़ीस की लागत लगभग $2 है, और कॉइन निकालने की $3।

जो कोड ख़ुद कॉइन ख़रीदे और निकाले, वह इनमें से हर चूक को ऐसे ट्रेड में बदल देता है जिसे किसी ने जाँचा नहीं। इसीलिए यह bot सिग्नल भेजता है: withdrawal, deposit और order book के बाद का spread वह ख़ुद जाँचता है, और ट्रेड से पहले contract, फ़ीस और ट्रांसफर का रास्ता इंसान जाँचता है। Genesis API वैसे भी ट्रेड नहीं कर सकता: वह सिर्फ़ डेटा पढ़ता है और कोई ऑर्डर नहीं लगाता। किसी pair की क़दम-दर-क़दम मैन्युअल जाँच Cross-exchange crypto arbitrage में है।

आपको क्या चाहिए

python3 --version   # Python 3.10 or newer is required
python3 -m pip install requests

export GENESIS_API_KEY="gns_live_XXXXXXXXXXXXXXXX"
export TG_BOT_TOKEN="123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11"

# after /start in the bot chat, find "chat":{"id":...} in the reply
curl "https://api.telegram.org/bot$TG_BOT_TOKEN/getUpdates"

export TG_CHAT_ID="123456789"

export से सेट किए गए वेरिएबल टर्मिनल बंद होने तक रहते हैं। Telegram docs के अनुसार token से bot पर पूरा नियंत्रण मिलता है, और key से आपके प्लान तक पहुँच; इसलिए दोनों सिर्फ़ environment variables में रहते हैं: वे कोड या repository में नहीं जाते।

Bot का कोड क़दम-दर-क़दम

नीचे के सात ब्लॉक पूरा bot.py हैं: उन्हें इसी क्रम में एक फ़ाइल में सहेजें। सेटिंग्स की सीमाएँ अस्थायी मान हैं; उन्हें अपनी फ़ीस और ट्रेड के आकार के हिसाब से ठीक करें।

1. सेटिंग्स

import os
import time

import requests

API = "https://api.genesisarbitrage.com/v1"
TG = "https://api.telegram.org/bot" + os.environ["TG_BOT_TOKEN"]
CHAT_ID = os.environ["TG_CHAT_ID"]

MIN_SPREAD = 1.0      # पंक्ति का spread 1% से
MIN_VOLUME = 50_000   # दोनों एक्सचेंजों पर 24 घंटे का वॉल्यूम $50,000 से
MIN_EXEC = 0.5        # $1,000 के order book के बाद spread 0.5% से
TOP = 5               # हर चक्कर में अधिकतम pairs
REPEAT_SEC = 15 * 60  # एक pair 15 मिनट में अधिकतम एक बार
RECHECK_SEC = 5 * 60  # जिस pair को book ने खा लिया वह 5 मिनट रुकता है

api = requests.Session()
api.headers["X-API-Key"] = os.environ["GENESIS_API_KEY"]
cache = {}       # अनुरोध -> (ETag, जवाब)
wait_until = {}  # pair -> वह समय जब तक वह शांत रहता है

Key api सेशन से जाने वाले हर अनुरोध के X-API-Key हेडर में जाती है और URL में कभी नहीं जाती। MIN_VOLUME उन pairs को हटाता है जिनमें किसी भी एक्सचेंज पर 24 घंटे का वॉल्यूम $50,000 से कम है। cache जवाबों के ETag रखता है, और wait_until वह समय जब तक bot किसी pair पर शांत रहता है।

2. Genesis API को कॉल करना: Retry-After और ETag

def get(path, params=None):
    """Retry-After पर दोबारा कोशिश और ETag के साथ Genesis API को GET।"""
    key = (path, tuple(sorted((params or {}).items())))
    for _ in range(4):  # एक अनुरोध और तीन तक दोबारा कोशिशें
        hdr = {"If-None-Match": cache[key][0]} if key in cache else {}
        r = api.get(API + path, params=params, headers=hdr,
                    timeout=15)
        if r.status_code == 304:  # snapshot नहीं बदला
            return cache[key][1]
        if r.status_code in (429, 503):
            wait = int(r.headers.get("Retry-After", "5"))
            if wait > 60:  # ख़त्म हुआ कोटा ऐसा दिखता है
                raise SystemExit(f"Quota exhausted: wait {wait} s")
            time.sleep(wait)
            continue
        r.raise_for_status()  # 400, 401, 403: दोबारा कोशिश से कुछ नहीं होगा
        body = r.json()
        if "ETag" in r.headers:  # ETag सिर्फ़ पूरे dataset के साथ आता है
            cache[key] = (r.headers["ETag"], body)
        return body
    raise RuntimeError("Genesis API is busy, retrying next pass")

429 तब आता है जब आप प्रति सेकंड rate limit या डाउनलोड की मात्रा पार करते हैं, और 503 तब जब डेटा दोबारा बन रहा हो। दोनों में Retry-After होता है, और get उतने सेकंड रुकता है जितने सर्वर माँगता है। ख़त्म हुआ कोटा भी 429 लौटाता है, पर Retry-After में रीसेट का समय होता है, जो कभी-कभी दिनों दूर होता है, इसलिए bot रुक जाता है। 400, 401 और 403 दोबारा कोशिश से नहीं जाएँगे, इसलिए raise_for_status उन्हें उठा देता है। सारी सीमाएँ Genesis API limits गाइड में हैं।

3. Spread और pairs का फ़िल्टर

def candidates():
    """Spot – Spot pairs जिनका कॉइन सच में ट्रांसफर हो सकता है।"""
    body = get("/arbitrage/spot-spot",
               {"min_spread": MIN_SPREAD, "min_volume": MIN_VOLUME})
    # ख़रीद की तरफ़ withdrawal खुला, बिक्री की तरफ़ deposit
    rows = [x for x in body["data"]
            if x["withdraw_enabled_buy"] and x["deposit_enabled_sell"]]
    rows.sort(key=lambda x: x["spread_pct"], reverse=True)
    return rows, body["meta"]["freshness_sec"]

min_spread और min_volume पंक्तियों को सर्वर पर फ़िल्टर करते हैं। Deposit और withdrawal के फ़्लैग के लिए कोई पैरामीटर नहीं है, इसलिए कोड उन्हें जाँचता है: कॉइन तब ट्रांसफर हो सकता है जब ख़रीद वाले एक्सचेंज पर withdrawal (withdraw_enabled_buy) और बिक्री वाले पर deposit (deposit_enabled_sell) खुला हो। Bot जो फ़ील्ड इस्तेमाल करता है, Spot — Spot docs की एक पंक्ति में:

{
  "coin": "FUEL",
  "exchange_buy": "ByBit",
  "exchange_sell": "Gate",
  "spread_pct": 0.11,
  "network": "ETH",
  "contract": "0x675B68AA4d9c2d3BB3F0397048e62E6B7192079c",
  "withdraw_enabled_buy": true,
  "deposit_enabled_sell": true,
  "volume_24h_buy": 17652.64,
  "volume_24h_sell": 12512.51,
  "trade_url_buy": "https://www.bybit.com/trade/spot/FUEL/USDT",
  "trade_url_sell": "https://www.gate.io/trade/FUEL_USDT",
  …
}

यह पंक्ति bot के फ़िल्टर पार नहीं करेगी: 0.11% spread और $50,000 से कम वॉल्यूम। Bot संदेश में नेटवर्क और contract रखता है, ताकि आप उन्हें दोनों एक्सचेंजों के withdrawal और deposit पन्नों से मिला सकें।

4. $1,000 का order book check

def exec_spread(row):
    """$1,000 के order book के बाद spread। सिर्फ़ Pro और Max।"""
    body = get("/orderbooks/spreads/spot-spot",
               {"coin": row["coin"], "volume": 1000})
    for x in body["data"]:
        od = x["order_delta"]
        if (x["exchange_buy"] == row["exchange_buy"]
                and x["exchange_sell"] == row["exchange_sell"]
                and od["status"] == "ok"):
            return od["spread_pct"]
    return None  # no_book, exhausted, या pair ग़ायब

यह endpoint कॉइन की पंक्तियाँ Spot – Spot dataset से order_delta ऑब्जेक्ट के साथ लौटाता है — Order-book Δ, यानी order book से गुज़रने के बाद का spread: ख़रीद वाले एक्सचेंज के asks से ख़रीदना और बिक्री वाले के bids में बेचना। फ़ंक्शन वही एक्सचेंजों वाली पंक्ति लेता है और status के ok होने पर उसका order_delta.spread_pct लौटाता है; no_book का मतलब book नहीं है, और exhausted का मतलब $1,000 से पहले book ख़त्म हो गई। Books एक्सचेंज से 5–20 सेकंड पीछे रहती हैं; फ़ील्ड Order-book Δ docs और order book endpoints गाइड में बताए गए हैं।

यह चरण सिर्फ़ Pro और Max पर है; Trial और Start पर endpoint 403 plan_restricted लौटाता है। Bot शुरू में आपका प्लान पढ़ता है और वहाँ check छोड़ देता है: संदेश में लिखा होता है कि order book जाँची नहीं गई, और गहराई आप एक्सचेंज टर्मिनल में ख़ुद देखते हैं।

5. Telegram संदेश

def message(row, ex):
    buy, sell = row["exchange_buy"], row["exchange_sell"]
    if ex is None:
        book = "order book जाँची नहीं गई (Trial या Start)"
    else:
        book = f"$1,000 के order book के बाद: {ex:.2f}%"
    return "\n".join([
        f'{row["coin"]}: {buy} → {sell}',
        f'Spread {row["spread_pct"]}%, {book}',
        f'नेटवर्क {row["network"]}, contract {row["contract"] or "—"}',
        f'ख़रीद: {row["trade_url_buy"]}',
        f'बिक्री: {row["trade_url_sell"]}',
    ])


def send(text):
    """Telegram Bot API sendMessage; 429 पर retry_after तक रुकें।"""
    for _ in range(3):
        r = requests.post(TG + "/sendMessage", timeout=15, json={
            "chat_id": CHAT_ID, "text": text,
            "link_preview_options": {"is_disabled": True}})
        if r.status_code != 429:
            r.raise_for_status()  # 400 या 401: ग़लत चैट या token
            return
        wait = r.json().get("parameters", {}).get("retry_after", 5)
        time.sleep(wait)  # Telegram flood control
    raise RuntimeError("Telegram did not accept the message")

sendMessage में chat_id और 1 से 4096 अक्षरों का text जाता है, और अनुरोध https://api.telegram.org/bot<token>/sendMessage पर जाता है (Telegram Bot API docs)। link_preview_options में is_disabled लिंक preview बंद करता है। Flood control में Telegram 429 लौटाता है और प्रतीक्षा के सेकंड parameters.retry_after में रखता है। एक चैट में Telegram bots से कहता है कि प्रति सेकंड एक संदेश से ज़्यादा न भेजें (bot developer FAQ)।

संदेश ऐसा दिखता है, काल्पनिक उदाहरण के रूप में:

XYZ: MEXC → Gate
Spread 1.4%, $1,000 के order book के बाद: 0.62%
नेटवर्क ETH, contract 0x…
ख़रीद: https://…
बिक्री: https://…

6. दोहराव रोकना: एक pair 15 मिनट में एक बार

def scan(books):
    """एक चक्कर: spread, order books, संदेश।"""
    rows, pause = candidates()
    done = 0
    for row in rows:
        key = (row["coin"], row["exchange_buy"], row["exchange_sell"])
        if time.time() < wait_until.get(key, 0):
            continue  # alert जा चुका, या book ने spread खा लिया
        if done == TOP:
            break
        done += 1
        ex = exec_spread(row) if books else None
        ok = not books or (ex is not None and ex >= MIN_EXEC)
        if ok:
            send(message(row, ex))
        # alert के बाद 15 मिनट शांति, book पतली हो तो 5
        hold = REPEAT_SEC if ok else RECHECK_SEC
        wait_until[key] = time.time() + hold
        time.sleep(1)  # प्रति सेकंड अधिकतम एक अनुरोध और संदेश
    return pause

Pair का मतलब है कॉइन, ख़रीद एक्सचेंज और बिक्री एक्सचेंज की तिकड़ी। Alert के बाद bot उस पर 15 मिनट शांत रहता है, चाहे spread बना रहे। अगर book ने spread खा लिया, तो bot 5 मिनट में pair पर लौटता है, ताकि order book की जाँच हर चक्कर में एक कॉल न ख़र्च करे। एक चक्कर सबसे चौड़े spread वाले अधिकतम पाँच pairs लेता है और हर एक के बाद एक सेकंड रुकता है: इससे bot Telegram की सलाह और किसी भी प्लान की प्रति-सेकंड सीमा में रहता है। Dictionary मेमोरी में रहती है, इसलिए restart के बाद ताज़ा pairs दोहर सकते हैं।

7. लूप: कम से कम freshness_sec का ठहराव

def main():
    usage = get("/account/usage")["data"]  # कोटा नहीं लेता
    books = usage["plan"] in ("pro", "max")
    pause = usage["freshness_sec"]
    print("Plan", usage["plan"], "| polling every", pause, "s",
          "| order books:", "yes" if books else "no")
    while True:
        try:
            pause = scan(books)
        except requests.HTTPError as e:
            if e.response.status_code < 500:
                raise  # key, प्लान या token: दोबारा कोशिश से कुछ नहीं होगा
            print("Server error, retrying:", e)
        except (requests.RequestException, RuntimeError) as e:
            print("No response, retrying:", e)
        time.sleep(pause)  # meta.freshness_sec से ज़्यादा बार नहीं


if __name__ == "__main__":
    main()

शुरू में bot /account/usage कॉल करता है: यह अनुरोध कोटा नहीं लेता और आपका प्लान तथा freshness_sec लौटाता है। यह data freshness है, यानी वह अंतराल जिस पर आपके प्लान को नया snapshot मिलता है: Trial पर 60 सेकंड, Start पर 30, Pro पर 10 और Max पर 5। इसके बाद ठहराव meta.freshness_sec से आता है, क्योंकि ज़्यादा तेज़ पूछने पर वही snapshot मिलता है। नेटवर्क की विफलताएँ और 5xx त्रुटियाँ अगले चक्कर तक इंतज़ार करती हैं, जबकि बाक़ी 4xx त्रुटियाँ — ग़लत key, ख़त्म हुई सदस्यता, बिना उस endpoint वाला प्लान, ग़लत token या chat_id — bot को रोक देती हैं। त्रुटि कोड Genesis API responses and errors में हैं, और Telegram के बिना spread मॉनिटर पाठ Python में spread और funding मॉनिटर में बनता है।

इसे कैसे चलाएँ और जाँचें

python3 bot.py
# Plan trial | polling every 60 s | order books: no
  1. पहले चक्कर का इंतज़ार करें

    संदेश तब आते हैं जब बाज़ार में आपकी सीमाओं से ऊपर के pairs हों। अगर कुछ मिनट में कोई न आए, तो थोड़ी देर के लिए MIN_SPREAD और MIN_VOLUME घटाएँ: इससे दिखेगा कि API से Telegram तक की कड़ी चल रही है।

  2. किसी pair को तालिका से मिलाएँ

    साइट पर Spot – Spot खोलें: वही कॉइन और एक्सचेंज pair तालिका में है। संख्याएँ थोड़ी अलग हो सकती हैं, क्योंकि API snapshot आपके प्लान की देरी से देता है।

  3. दोहराव रोकने की जाँच करें

    वही pair 15 मिनट के भीतर दोबारा नहीं आना चाहिए।

  4. कॉल का उपयोग देखें

    /account/usage में calls_used फ़ील्ड या प्रोफ़ाइल में «Calls used» पंक्ति देखें: Trial पर बिना order book check के bot लगभग 1,440 कॉल प्रतिदिन लेता है।

  5. Bot को चलता छोड़ दें

    nohup python3 bot.py >> bot.log 2>&1 & bot को बैकग्राउंड में चलाता है; environment variables उसी टर्मिनल सेशन में सेट करें।

Bot को Genesis API का कौन-सा प्लान चाहिए

एक चक्कर एक /arbitrage/spot-spot कॉल है, साथ में Pro और Max पर /orderbooks/spreads/spot-spot की पाँच तक कॉलें; कोटा सिर्फ़ 200 जवाब लेते हैं। 30 दिनों की ऊपरी सीमा: (1 + प्रति चक्कर checks) × 86,400 / ठहराव × 30।

प्लानPolling$1,000 का order book check30 दिनों में कॉल
Trial, $20/माहहर 60 sनहीं500,000 में से 43,200
Start, $50/माहहर 30 sनहीं2M में से 86,400
Pro, $100/माहहर 10 sहाँ5M में से 1,555,200 तक
Max, $200/माहहर 5 sहाँ10M में से 3,110,400 तक

Trial पर यह 86,400 / 60 × 30 = 43,200 कॉल है, यानी कोटे का 8.64%। Pro पर, सबसे बुरे हाल में जब हर चक्कर पाँच books जाँचे, यह 6 × 86,400 / 10 × 30 = 1,555,200 कॉल होता है, यानी कोटे का 31.1%। कोटे के नियम docs के Plans & limits खंड में हैं।

Arbitrage bot के जोखिम

बिना कोड: Genesis Arbitrage के Telegram alerts

अगर आप अपना bot लिखना और चलाना नहीं चाहते, तो Genesis Arbitrage के Telegram Alerts pairs आपको भेज देते हैं। आप @BotFather में bot बनाते हैं, उसका token साइट पर चिपकाते हैं और Spot - Spot, DEX - Futures, Crosschain और Funding arbitrage जैसी श्रेणियाँ चुनते हैं। फ़िल्टर न्यूनतम spread, एक्सचेंज और नेटवर्क, Deposit/Withdrawal स्थिति और Order spread तय करते हैं, और «दोहराव का समय (मिनट)» सीमित करता है कि एक pair कितनी बार लौटे। निजी bot साइट के Pro प्लान पर चलता है, Genesis API के प्लानों से अलग; सेटअप Telegram notifications गाइड में है।

सवाल और जवाब

क्या bot अपने आप ट्रेड कर सकता है?

Genesis API से नहीं: API सिर्फ़ डेटा देता है और कोई ऑर्डर नहीं लगाता। ट्रेडिंग एक्सचेंजों के अपने API से trading keys के साथ जोड़ी जाती है, जो अलग कोड है और आपकी अपनी ज़िम्मेदारी: पुराना spread या बंद withdrawal ऐसे ट्रेड में बदल जाता है जिसे किसी ने जाँचा नहीं।

ऐसे bot की लागत कितनी है?

कोड मुफ़्त है, और Telegram उपयोगकर्ताओं को bot के संदेश भी। आप डेटा के लिए भुगतान करते हैं: Genesis API Trial पर $20 प्रति माह से शुरू होता है, और order book check $100 के Pro से शुरू होता है। आपको चौबीसों घंटे चलने वाला कंप्यूटर या सर्वर भी चाहिए।

मुझे Genesis API का कौन-सा प्लान चाहिए?

बुनियादी bot के लिए Trial काफ़ी है: /arbitrage/spot-spot हर प्लान पर है, हर 60 सेकंड में नए snapshot के साथ। Start डेटा हर 30 सेकंड में ताज़ा करता है। $1,000 का Order-book Δ check सिर्फ़ Pro और Max पर काम करता है।

Bot ने ऐसा pair क्यों भेजा जिसमें एक्सचेंज पर spread नहीं बचा?

डेटा आपके प्लान की देरी से आता है, और दूसरे ट्रेडर भी अंतर बंद करते हैं। पंक्ति का spread आख़िरी ट्रेडों से निकलता है, जबकि आप सिर्फ़ ask पर ख़रीद और bid पर बेच सकते हैं। ट्रेड से पहले एक्सचेंज टर्मिनल में क़ीमतें और order book जाँचें।

क्या मैं bot को GitHub पर रख सकता हूँ?

हाँ: शर्तें Genesis API पर अपने bot बनाने की अनुमति देती हैं, और एकमात्र पाबंदी कच्चा डेटा जस का तस दोबारा बेचने की है। Key और token को repository से बाहर रखें। अगर key सार्वजनिक कोड में चली जाए, तो प्रोफ़ाइल में «Reissue» दबाएँ, और @BotFather में /token कमांड bot का token बदल देती है।