Genesis Arbitrage

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

Crypto market API की पोलिंग rate limit में फँसे बिना: ETag, gzip, फ़िल्टर और 429 के बाद रीट्राई

संक्षेप में

  • किसी API में आमतौर पर तीन लिमिट होती हैं: प्रति सेकंड रिक्वेस्ट, प्रति अवधि कॉल कोटा और डाउनलोड वॉल्यूम। Genesis API में ये हैं: 1 से 15 रिक्वेस्ट प्रति सेकंड, 30 दिन में 500K से 10M कॉल और हर key पर 10 सेकंड में 60 MB कंप्रेस्ड डेटा।
  • पोलिंग अंतराल meta.freshness_sec से तय करें: इससे तेज़ पोलिंग वही स्नैपशॉट लौटाती है। If-None-Match दोहराव को मुफ़्त 304 में बदल देता है, gzip और फ़िल्टर ट्रैफ़िक घटाते हैं, और हर coin की अलग रिक्वेस्ट की जगह एक पूरा डेटासेट कॉल बचाता है।
  • 429 और 503 को Retry-After सेकंड बाद, या यह हेडर न हो तो random jitter के साथ exponential backoff से दोबारा आज़माएँ। क्लाइंट-साइड token bucket आपकी रफ़्तार लिमिट के नीचे रखता है, और X-RateLimit-* व X-Quota-* हेडर बची हुई गुंजाइश दिखाते हैं।

429 एरर के बिना API की पोलिंग करने के लिए अपनी रिक्वेस्ट तीन लिमिट के हिसाब से एक साथ ढालें: प्रति सेकंड रिक्वेस्ट, अवधि का कॉल कोटा और आपके डाउनलोड किए डेटा का वॉल्यूम। पाँच तकनीकें इसे संभालती हैं: डेटा रिफ़्रेश से छोटा न होने वाला अंतराल, ETag वाली कंडीशनल रिक्वेस्ट, gzip कंप्रेशन, भारी डाउनलोड की जगह फ़िल्टर, और सर्वर जितना रुकने को कहे उसके बाद रीट्राई। नीचे के आँकड़े और कोड Genesis API के हैं, जो crypto market डेटा का REST API है, पर तकनीकें किसी भी HTTP API पर चलती हैं, एक्सचेंज API पर भी।

API की तीन लिमिट: प्रति सेकंड रिक्वेस्ट, कोटा और वॉल्यूम

प्रति सेकंड rate limit बर्स्ट पकड़ती है: एक साथ भेजी गई रिक्वेस्ट का समूह। कोटा पूरी अवधि में आपकी औसत रफ़्तार पकड़ता है, और वॉल्यूम लिमिट रिक्वेस्ट कम होने पर भी भारी डाउनलोड पकड़ती है।

लिमिटक्या गिनती हैGenesis APIलिमिट पार होने पर
प्रति सेकंड रिक्वेस्टहर रिक्वेस्ट, 304 और एरर समेतTrial में 1, Start में 2, Pro में 5, Max में 15429 rate_limited, Retry-After: 1
अवधि का कोटासिर्फ़ 200 रिस्पॉन्स30 दिन में 500K, 2M, 5M, 10M कॉल429 rate_limited, कोटा रीसेट होने तक Retry-After
डाउनलोड वॉल्यूम64 KB और उससे बड़े कंप्रेस्ड रिस्पॉन्सहर key पर 10 सेकंड में 60 MB, सभी प्लान मेंविंडो ख़त्म होने तक 429 download_limited

Genesis API लिमिट से ऊपर की रिक्वेस्ट का कभी बिल नहीं बनाता: 429 कोटा नहीं घटाता और उसकी कोई क़ीमत नहीं। सारे नियम Genesis API की सीमाएँ गाइड में और डॉक्यूमेंटेशन के प्लान और लिमिट सेक्शन में हैं।

एक्सचेंज API ज़्यादा जटिल हो सकते हैं। Binance हर IP पते पर रिक्वेस्ट का वज़न गिनता है, और हर endpoint का अपना वज़न है। 429 के बाद भी रिक्वेस्ट भेजते रहने वाले क्लाइंट को 418 स्टेटस के साथ ऑटोमैटिक IP बैन मिलता है, और बार-बार चूकने वालों को लंबा बैन (Binance docs)।

पोलिंग अंतराल: 30 दिन में कितने कॉल लगते हैं

डेटा रिफ़्रेश होने से तेज़ पोलिंग सिर्फ़ दोहराव लाती है। Genesis Arbitrage का कोर डेटा हर सेकंड रिफ़्रेश करता है, जबकि आपके प्लान का API आउटपुट हर meta.freshness_sec सेकंड में एक बार रिफ़्रेश होता है: Trial में 60, Start में 30, Pro में 10 और Max में 5। यही आपके प्लान की डेटा फ्रेशनेस है और पोलिंग अंतराल की निचली सीमा। Genesis API में WebSocket या webhooks नहीं हैं, इसलिए डेटा REST पर पोलिंग से मिलता है।

उदाहरण (समझाने के लिए): Start प्लान पर एक बॉट — $50 महीना, 2M कॉल, 2 रिक्वेस्ट प्रति सेकंड, 30 सेकंड फ्रेशनेस — चार endpoint पोल करता है: /arbitrage/spot-spot, /arbitrage/spot-futures, /funding/spread और /market/open-interest।

अंतराल30 दिन में कॉलStart कोटे का हिस्साएक स्नैपशॉट के दोहराव
60 सेकंड172,8008.64%कोई नहीं
30 सेकंड345,60017.28%कोई नहीं
10 सेकंड1,036,80051.84%3 में से 2
5 सेकंड2,073,600103.68%6 में से 5

हर 5 सेकंड पर पोलिंग 29वें दिन कोटा ख़त्म कर देती है: 4 × 86,400 / 5 = 69,120 कॉल प्रति दिन, और 2,000,000 / 69,120 ≈ 28.9 दिन। हर छह में से पाँच रिस्पॉन्स एक ही meta.updated_at वाला वही स्नैपशॉट दोहराते हैं, और If-None-Match के बिना हर एक पर एक कॉल लगता है।

हर 30 सेकंड में एक पोल पर औसत रफ़्तार 4 / 30 ≈ 0.13 रिक्वेस्ट प्रति सेकंड है। पर एक साथ भेजी गई चार रिक्वेस्ट एक ही सेकंड में गिरती हैं, और उनमें से दो को 429 मिलता है। अगर 30 सेकंड से ताज़ा डेटा चाहिए, तो जवाब कम freshness_sec वाला प्लान है: Pro स्नैपशॉट हर 10 सेकंड में रिफ़्रेश करता है, Max हर 5 में।

कंडीशनल रिक्वेस्ट: ETag, If-None-Match और 304

ETag रिस्पॉन्स का वर्ज़न टैग है। क्लाइंट उसे सँभालकर रखता है और उसी URL पर अगली रिक्वेस्ट के If-None-Match हेडर में लौटा देता है; वर्ज़न नहीं बदला हो तो सर्वर 304 Not Modified देता है। RFC 9110 के अनुसार 304 हेडर के बाद ख़त्म हो जाता है और उसमें बॉडी नहीं होती, इसलिए आप डेटा की अपनी कॉपी इस्तेमाल करते हैं।

Genesis API में 304 कोटा नहीं घटाता, पर प्रति सेकंड रिक्वेस्ट लिमिट में एक स्लॉट लेता है। टैग सिर्फ़ बिना फ़िल्टर वाले पूरे डेटासेट को मिलता है। coin, exchange, min_spread या दूसरे फ़िल्टर वाली रिक्वेस्ट के रिस्पॉन्स, साथ ही /orderbooks/book और /orderbooks/coin/{coin}, हर रिक्वेस्ट पर बनते हैं और बिना ETag के आते हैं।

ETag वहाँ कोटा बचाता है जहाँ डेटा आपके माँगने से कम बदलता है। स्प्रेड का टैग हर स्नैपशॉट के साथ बदलता है, इसलिए जब आप हर freshness_sec पर एक बार पोल करते हैं तो लगभग हर रिस्पॉन्स 200 होता है।

Pro पर उदाहरण (समझाने के लिए): funding analytics के दैनिक योग, /funding/analytics/daily, हर घंटे दोबारा बनते हैं; जब एक साल का इतिहास जमा हो जाता है, तो पूरा सेक्शन लगभग 12 MB gzip होता है और coin के बिना वह अधिकतम हर 300 सेकंड में एक बार दिया जाता है। हर 300 सेकंड पर पोलिंग का मतलब 30 दिन में 2,592,000 / 300 = 8,640 रिक्वेस्ट। If-None-Match के साथ सेक्शन 30 × 24 = 720 बार डाउनलोड होता है, और बाक़ी 8,640 − 720 = 7,920 रिस्पॉन्स 304 में लौटते हैं।

नतीजा: 8,640 की जगह 720 कॉल, और 104 GB की जगह लगभग 8.6 GB ट्रैफ़िक। 304 रिस्पॉन्स पूरे डाउनलोड की लिमिट में नहीं गिने जाते।

फ़िल्टर और coin: क्या कॉल बचाता है और क्या ट्रैफ़िक

फ़िल्टर रिस्पॉन्स छोटा करता है, कॉल की संख्या नहीं: कोटा रिस्पॉन्स गिनता है, और coin=BTC वाली रिक्वेस्ट की क़ीमत पूरे डेटासेट जितनी ही है। इसलिए चुनाव इस पर टिका है कि पहले क्या ख़त्म होता है, कॉल या ट्रैफ़िक।

Start पर उदाहरण (समझाने के लिए): एक बॉट पाँच coin की funding ट्रैक करता है। हर 30 सेकंड में coin के साथ /funding/rates पर पाँच रिक्वेस्ट का मतलब 30 दिन में 5 × 86,400 = 432,000 कॉल, और हर चक्र में पाँच रिक्वेस्ट 2 प्रति सेकंड की लिमिट के सामने। कोड में coin छाँटते हुए एक पूरा /funding/rates 86,400 कॉल का पड़ता है, यानी पाँच गुना कम, और उसे ETag भी मिलता है।

कामकैसे माँगेंक्या बचता है
एक डेटासेट से कई coinIf-None-Match के साथ पूरा डेटासेट, फ़िल्टर कोड मेंकॉल: कई की जगह एक रिक्वेस्ट
भारी सेक्शन से एक coincoin पैरामीटरट्रैफ़िक और वॉल्यूम लिमिट
थ्रेशहोल्ड से ऊपर की पंक्तियाँmin_spread, min_volumeट्रैफ़िक, पर हर पोल एक कॉल है
धीमा सेक्शन पूराIf-None-Match के साथ पूरा डेटासेटकॉल और ट्रैफ़िक

सबसे भारी सेक्शन funding analytics के हैं: पूरा सारांश लगभग 600 KB gzip, 7 दिन के भुगतान लगभग 1 MB और दैनिक योग 12 MB तक (Funding endpoints)। coin वाला एक coin का स्लाइस पूरे डाउनलोड की लिमिट से मुक्त है, जो सारांश और भुगतान के लिए हर 60 सेकंड में एक बार और दैनिक योग के लिए हर 300 में एक बार है।

gzip कंप्रेशन

कंप्रेशन तार पर जाने वाले बाइट घटाता है। क्लाइंट Accept-Encoding: gzip से उसे माँगता है, और सर्वर कंप्रेस्ड बॉडी और Content-Encoding: gzip हेडर के साथ जवाब देता है। Python का requests Accept-Encoding में gzip जोड़ता है और रिस्पॉन्स ख़ुद डिकंप्रेस करता है; curl --compressed से यही करता है।

Genesis API में कंप्रेशन एक लिमिट से जुड़ा है: डाउनलोड वॉल्यूम कंप्रेस्ड डेटा में गिना जाता है, हर key पर 10 सेकंड में 60 MB, और 64 KB से छोटे रिस्पॉन्स नहीं गिने जाते। क्लाइंट माँगे तो पूरे डेटासेट और बड़े रिस्पॉन्स gzip में आते हैं (Genesis API रिस्पॉन्स और एरर)। असल में नेटवर्क पर कितने बॉडी बाइट गए, यह देखने के लिए curl का size_download वेरिएबल इस्तेमाल करें:

# body bytes on the wire with and without gzip; each request is a call
URL="https://api.genesisarbitrage.com/v1/funding/rates"
curl -s -o /dev/null --compressed -w "gzip: %{size_download}\n" \
  -H "X-API-Key: $GENESIS_API_KEY" "$URL"
curl -s -o /dev/null -w "uncompressed: %{size_download}\n" \
  -H "X-API-Key: $GENESIS_API_KEY" "$URL"

429 के बाद रीट्राई: Retry-After और jitter वाला backoff

HTTP 429 Too Many Requests उस क्लाइंट को सर्वर का जवाब है जो लिमिट पार कर गया। RFC 6585 के अनुसार रिस्पॉन्स में Retry-After हेडर हो सकता है, और RFC 9110 के अनुसार उसका मान या तो सेकंड की संख्या है या तारीख़। Genesis API हर 429 और 503 के साथ Retry-After सेकंड में भेजता है।

बिना रुके रीट्राई को लगभग हमेशा वही एरर मिलता है और वह प्रति सेकंड विंडो का एक और स्लॉट ले लेती है। Retry-After हो तो उतना रुकें जितना सर्वर माँगता है। न हो तो हर असफलता के बाद घातांक में ज़्यादा रुकें: 1, 2, 4, 8 सेकंड तक।

Jitter, यानी रुकने में random जोड़, तब मायने रखता है जब क्लाइंट कई हों: इसके बिना जिन सबको एक ही सेकंड में एरर मिला, वे एक ही सेकंड में रीट्राई भी करते हैं। backoff फ़ंक्शन शून्य और मौजूदा चरण के बीच random अवधि चुनता है और Retry-After में सेकंड का एक अंश जोड़ता है। fetch 429, 500 और 503 को रीट्राई करता है, और रुकने की अवधि 10 मिनट से ज़्यादा हो तो रुक जाता है: चुका हुआ कोटा ऐसा ही दिखता है।

import os
import random
import time

import requests

BASE = "https://api.genesisarbitrage.com/v1"
api = requests.Session()  # reuses the TCP connection, gzip is on
api.headers["X-API-Key"] = os.environ["GENESIS_API_KEY"]
cache = {}  # path -> (ETag, data): full datasets only


def backoff(attempt, retry_after=None, cap=60.0):
    """Pause before a retry, in seconds."""
    if retry_after and retry_after.isdigit():
        return int(retry_after) + random.uniform(0, 1)
    return random.uniform(0, min(cap, 2 ** attempt))


def fetch(path, params=None, tries=5):
    """GET from the API: returns (data, response headers)."""
    for attempt in range(tries):
        tag = None if params else cache.get(path, (None,))[0]
        try:
            r = api.get(BASE + path, params=params, timeout=15,
                        headers={"If-None-Match": tag} if tag else {})
        except (requests.ConnectionError, requests.Timeout):
            time.sleep(backoff(attempt))
            continue
        if r.status_code == 304:  # same snapshot, no quota used
            return cache[path][1], r.headers
        if r.status_code in (429, 500, 503):
            wait = backoff(attempt, r.headers.get("Retry-After"))
            if wait > 600:  # this is what an exhausted quota looks like
                raise RuntimeError(f"quota resets in {wait:.0f} s")
            time.sleep(wait)
            continue
        r.raise_for_status()  # 400, 401, 403, 404, 410: do not retry
        data = r.json()["data"]
        if not params and "ETag" in r.headers:
            cache[path] = (r.headers["ETag"], data)
        return data, r.headers
    raise RuntimeError(f"{path}: no response after {tries} tries")
रिस्पॉन्सरुकनारीट्राई
429 rate_limited, प्रति सेकंडRetry-After: 1 और सेकंड का एक अंशहाँ
429 rate_limited, कोटाकोटा रीसेट होने तक, कई दिन हो सकते हैंनहीं
429 download_limitedRetry-After, विंडो ख़त्म होने तकहाँ, संकरी रिक्वेस्ट के साथ
503 snapshot_not_readyRetry-Afterहाँ
500, टाइमआउट, टूटा कनेक्शनjitter के साथ exponentialहाँ
400, 401, 403, 404, 410—नहीं, रिक्वेस्ट ठीक करें

चुका हुआ कोटा और प्रति सेकंड लिमिट Retry-After से अलग पहचानी जाती हैं: एक सेकंड बनाम रीसेट तक घंटे या दिन, और रिस्पॉन्स बॉडी में Monthly call quota exceeded.। एरर कोड और बॉडी डॉक्यूमेंटेशन के एरर सेक्शन में हैं।

क्लाइंट-साइड रेट लिमिटर: token bucket

रीट्राई 429 से निपटती है; क्लाइंट-साइड लिमिटर उसे रोकता है। Token bucket ऐसे काम करता है: टोकन rate प्रति सेकंड की दर से आते हैं, हर रिक्वेस्ट एक लेती है, और ख़ाली बकेट आपको इंतज़ार कराता है। क्षमता burst तय करती है कि कितनी रिक्वेस्ट बिना रुके एक के बाद एक जा सकती हैं।

import time


class TokenBucket:
    """At most rate requests per second, up to burst back to back."""

    def __init__(self, rate, burst=1):
        self.rate, self.burst = rate, burst
        self.tokens = float(burst)
        self.last = time.monotonic()

    def take(self):
        while True:
            now = time.monotonic()
            self.tokens = min(self.burst, self.tokens
                              + (now - self.last) * self.rate)
            self.last = now
            if self.tokens >= 1:
                self.tokens -= 1
                return
            time.sleep((1 - self.tokens) / self.rate)

लिमिट /account/usage के rps_limit फ़ील्ड (उपयोग सेक्शन) या X-RateLimit-Limit हेडर से लें। दर लिमिट से थोड़ी नीचे रखें, उदाहरण के लिए 0.9 * rps_limit: नेटवर्क लेटेंसी एक-सी नहीं रहती, इसलिए आधे सेकंड के अंतर से भेजी गई रिक्वेस्ट सर्वर तक और क़रीब पहुँच सकती हैं।

मॉनिटरिंग: X-RateLimit-* और X-Quota-* हेडर

डेटा रिस्पॉन्स आपकी लिमिट की स्थिति साथ लाता है: X-RateLimit-Remaining और X-RateLimit-Reset प्रति सेकंड विंडो में बचा हिस्सा और उसका रीसेट समय देते हैं, जबकि X-Quota-Remaining, X-Quota-Limit और X-Quota-Reset बचा कोटा, उसका आकार और रीसेट का unix समय देते हैं। किसी एक बचे हुए आँकड़े से ज़्यादा काम की चीज़ रफ़्तार है: अवधि के इस बिंदु पर कोटे का कितना हिस्सा जा चुका है।

PERIOD = 30 * 86400  # Genesis API counts quota per 30 days


def watch(h):
    """Checks limit headroom from the response headers."""
    if h.get("X-RateLimit-Remaining") == "0":  # window used up
        reset = float(h.get("X-RateLimit-Reset", 0))
        time.sleep(max(0.0, reset - time.time()))
    try:
        left = int(h["X-Quota-Remaining"])
        limit = int(h["X-Quota-Limit"])
        reset = int(h["X-Quota-Reset"])
    except (KeyError, ValueError):
        return  # 429 responses carry no X-Quota-* headers
    used = 1 - left / limit
    passed = 1 - (reset - time.time()) / PERIOD
    if used > passed + 0.05:
        print(f"quota is running ahead: {used:.0%} used"
              f" with {passed:.0%} of the period gone")

लिमिट चुक जाए तो फ़ंक्शन विंडो रीसेट होने तक रुकता है, और कोटे का उपयोग कैलेंडर से 5 प्रतिशत अंक से ज़्यादा आगे निकल जाए तो चेतावनी देता है। उदाहरण (समझाने के लिए): 15वें दिन तक 70% कोटा जा चुका है, तो इसी रफ़्तार पर कॉल अवधि के 15 / 0.7 ≈ 21.4 दिन पर ख़त्म हो जाते हैं। /account/usage यही आँकड़े बिना हेडर के देता है: calls_used, calls_limit और period_resets_at।

कई endpoint के लिए शेड्यूल

कई endpoint हों तो हर एक को अपना अंतराल मिलता है, और पहली रिक्वेस्ट फैलाई जाती हैं ताकि वे एक साथ न जाएँ। अंतराल काम के हिसाब से चुनें, पर freshness_sec से कभी कम नहीं: स्प्रेड को आपके प्लान की पूरी दर चाहिए, जबकि कई रणनीतियों के लिए funding और open interest पर एक मिनट काफ़ी है।

import heapq

usage, _ = fetch("/account/usage")  # does not use a call
fresh = usage["freshness_sec"]
bucket = TokenBucket(rate=0.9 * usage["rps_limit"])

JOBS = {  # path -> polling interval, s
    "/arbitrage/spot-spot": fresh,
    "/funding/spread": max(fresh, 60),
    "/market/open-interest": max(fresh, 60),
}
t0 = time.monotonic()
queue = [(t0 + i * fresh / len(JOBS), path, every)
         for i, (path, every) in enumerate(JOBS.items())]
heapq.heapify(queue)

while True:
    due, path, every = heapq.heappop(queue)
    time.sleep(max(0.0, due - time.monotonic()))
    bucket.take()
    data, hdrs = fetch(path)
    watch(hdrs)
    print(path, len(data))
    heapq.heappush(queue, (due + every, path, every))

Start पर यह 30 दिन में 86,400 + 43,200 + 43,200 = 172,800 कॉल है, यानी कोटे का 8.64%: स्प्रेड हर 30 सेकंड, funding और open interest हर 60। पहली रिक्वेस्ट 30 / 3 = 10 सेकंड के अंतर से जाती हैं, उसके बाद हर endpoint अपनी लय रखता है, और bucket.take() टकराव से बचाता है। इसी पोलिंग पर बना, Telegram अलर्ट वाला बॉट Python में Crypto Arbitrage Bot में है।

503 और सर्वर एरर पर क्या करें

RFC 9110 के अनुसार 503 Service Unavailable का मतलब अस्थायी ओवरलोड या मेंटेनेंस है, और सर्वर Retry-After में रुकने की अवधि सुझा सकता है। Genesis API में यह 503 snapshot_not_ready है: डेटा दोबारा बन रहा है या उसका स्रोत रीस्टार्ट हो रहा है। Retry-After सेकंड बाद रीट्राई करें; अवधि आमतौर पर कुछ सेकंड की होती है।

जब तक ताज़ा रिस्पॉन्स नहीं आता, आपके बॉट के पास पिछली पोलिंग का डेटा रहता है, और वह डेटा पुराना होता जाता है। सिग्नल भेजने से पहले meta.updated_at को मौजूदा समय से मिलाएँ: मिनट भर पुराने स्नैपशॉट की कोई जोड़ी एक्सचेंज पर ग़ायब हो चुकी हो सकती है। बाक़ी जोखिम ऑटोमेशन के जोखिम पाठ में हैं।

500 internal_error, टाइमआउट और टूटे कनेक्शन को exponential backoff से रीट्राई करें। एरर बना रहे तो X-Request-Id मान, UTC में रिक्वेस्ट का समय, endpoint और स्टेटस कोड के साथ सपोर्ट से संपर्क करें। अपनी key कभी न भेजें।

सवाल और जवाब

Genesis API पर मैं प्रति सेकंड कितनी रिक्वेस्ट भेज सकता हूँ?

जितनी आपका प्लान अनुमति दे: Trial में 1, Start में 2, Pro में 5 और Max में 15। लिमिट हर key पर है और उसमें 304 रिस्पॉन्स और एरर भी गिने जाते हैं। आपके प्लान का मान X-RateLimit-Limit हेडर में और /account/usage के rps_limit फ़ील्ड में है।

क्या एरर और 304 रिस्पॉन्स मेरे कोटे से कटते हैं?

नहीं। सिर्फ़ 200 रिस्पॉन्स कोटा घटाता है; 304, 429, 503 और बाक़ी एरर मुफ़्त हैं और उनकी कोई क़ीमत नहीं। हाँ, वे प्रति सेकंड रिक्वेस्ट लिमिट में स्लॉट लेते हैं, इसलिए बिना रुके रीट्राई नए 429 रिस्पॉन्स लाती हैं।

10 सेकंड में 60 MB से नीचे कैसे रहूँ?

gzip चालू करें: लिमिट कंप्रेस्ड डेटा गिनती है। पूरे डेटासेट के साथ If-None-Match भेजें: 304 में बॉडी नहीं होती। funding analytics जैसे भारी सेक्शन coin स्लाइस के रूप में लें, और वही पूरा डेटासेट हर freshness_sec से ज़्यादा बार डाउनलोड न करें। 64 KB से छोटे रिस्पॉन्स नहीं गिने जाते, और डॉक्यूमेंटेशन के अनुसार हर डेटासेट को आपके प्लान की फ्रेशनेस पर पोल करना लिमिट के नीचे काफ़ी गुंजाइश के साथ आ जाता है।

429 Too Many Requests एरर का क्या मतलब है?

सर्वर ने रिक्वेस्ट ठुकरा दी क्योंकि क्लाइंट ने किसी समय-विंडो में लिमिट पार कर ली। रिस्पॉन्स में Retry-After हो सकता है, यानी इंतज़ार के सेकंड; वह न हो तो हर असफलता के बाद रुकने की अवधि दोगुनी करें। Genesis API में 429 के साथ कोड rate_limited या download_limited आता है।