BroadRouter

LLM API में 429 एरर कैसे सँभालें: बैकऑफ़, जिटर और लिमिटर

BroadNet Inference टीम · 5 मिनट में पढ़ें · प्रकाशित · अपडेट किया गया

429 का मतलब है कि आप किसी रेट, कॉन्करेंसी या ख़र्च की सीमा तक पहुँच गए। इसे सीमित exponential backoff और रैंडम जिटर के साथ रीट्राई करें, और Retry-After मिले तो उसका पालन करें। फिर ज़्यादातर 429 पहले ही रोकें: semaphore से चालू अनुरोधों को key की सीमा पर रोकें और बाक़ी को क्यू में डालें। 5xx को भी ऐसे ही रीट्राई करें; बाक़ी 4xx एरर को ठीक करें।

429 का मतलब है कि आपका ट्रैफ़िक किसी रेट लिमिट को पार कर गया: प्रति मिनट अनुरोध, चालू अनुरोध, प्रति मिनट टोकन या ख़र्च। इसे दो हिस्सों में ठीक करें। सही तरीक़े से रीट्राई करें: सीमित exponential backoff, रैंडम जिटर के साथ, और Retry-After का पालन। एक साथ कम भेजें: key की चालू-अनुरोध सीमा पर एक semaphore, और साथ में एक क्यू। दोनों नीचे कोड के साथ दिए गए हैं।

सभी स्टेटस कोड की पूरी जानकारी के लिए एरर और रीट्राई गाइड देखें; चेकपॉइंट और टाइमआउट के साथ कई घंटे चलने वाले एजेंट के लिए लंबे चलने वाले एजेंट: टाइमआउट और रीट्राई देखें।

429 और 5xx में क्या फ़र्क़ है?

स्टेटस समस्या किसकी रीट्राई? कैसे
429 आपका ट्रैफ़िक किसी सीमा से ऊपर गया हाँ जिटर के साथ बैकऑफ़; Retry-After का पालन; कॉन्करेंसी घटाएँ
500 / 502 / 503 / 504 सर्वर की तरफ़ हाँ सीमित exponential backoff
कनेक्शन रीसेट, टाइमआउट नेटवर्क या सर्वर आम तौर पर बैकऑफ़; स्ट्रीम के लिए सिर्फ़ तब, जब नया बिल मंज़ूर हो
400 / 422 ग़लत अनुरोध नहीं पेलोड ठीक करें
401 / 402 / 403 key, बैलेंस या नीति नहीं key ठीक करें, अकाउंट में पैसे डालें, allow-list ठीक करें
413 अनुरोध बहुत बड़ा नहीं उसे छोटा करें

BroadNet Inference पर 429 का मतलब चार में से कोई भी सीमा हो सकता है: रेट, कॉन्करेंसी, टोकन रेट या ख़र्च। ख़र्च की सीमा 30 सेकंड में नहीं हटेगी। BroadNet का डॉक्यूमेंटेशन यह नहीं बताता कि एरर बॉडी का कौन-सा फ़ील्ड सीमा का नाम बताता है, इसलिए बॉडी लॉग करें और उसे अपनी key की डिटेल्स में दिखाई गई सीमाओं से मिलाएँ।

LLM API के फ़्री टियर और रेट लिमिट का हमारा ओपन डेटासेट तुलना करता है कि 14 प्रोवाइडर मुफ़्त एक्सेस, शुरुआती रेट लिमिट, कार्ड की ज़रूरत और फ़्री-टियर डेटा पर ट्रेनिंग के बारे में क्या प्रकाशित करते हैं, हर मान के स्रोत और तारीख़ के साथ।

कौन-सी सीमाएँ 429 की वजह बनती हैं?

जिन संख्याओं के साथ आप काम कर रहे हैं, उन्हें जानें। BroadNet Inference पर:

key का प्रकार अनुरोध / मिनट चालू अनुरोध अन्य
उपयोग के अनुसार भुगतान 30 4 साझा ख़र्च बजट
घंटे वाली key 120 1 स्ट्रीम 300,000 टोकन / मिनट
अनलिमिटेड प्लान सेशन — हर सेशन में 1 अनुरोध कोई टोकन मीटर नहीं

LLM के लिए सबसे अहम संख्या चालू अनुरोधों की है। स्ट्रीम किया गया जवाब आख़िरी टोकन आने तक अपना स्लॉट घेरे रहता है, इसलिए लंबा जवाब उसे तब तक व्यस्त रखता है जब तक मॉडल उसे लिख न ले (BroadNet आम स्पीड लगभग 100 टोकन प्रति सेकंड बताता है)। key के 4 स्लॉट से ज़्यादा समानांतर कॉल भेजें, तो अतिरिक्त कॉल को 429 मिलेगा, भले ही आपने उस मिनट गिनती के ही अनुरोध भेजे हों। यह कॉन्करेंसी की समस्या है, और सिर्फ़ बैकऑफ़ इसे ठीक से नहीं सँभालता। लॉन्च से पहले किसी सीमा के हिसाब से वर्कर तय करने के लिए मुफ़्त LLM रेट लिमिट कैलकुलेटर इस्तेमाल करें। कई आइटम वाले तय जॉब के लिए LLM बैच जॉब प्लानर इन्हीं सीमाओं को रन टाइम में बदल देता है। दूसरे प्रोवाइडर अलग तरह से गिनते हैं (प्रति मिनट टोकन, प्रति दिन अनुरोध या चालू अनुरोध); प्रोवाइडर के हिसाब से LLM API रेट लिमिट उनमें से 13 की तुलना उनके अपने डॉक्यूमेंटेशन से करता है।

जिटर के साथ बैकऑफ़ कैसे लिखें?

सामान्य exponential backoff 1, 2, 4, 8 सेकंड इंतज़ार करता है। अगर सौ वर्कर एक ही पल में थ्रॉटल हुए, तो वे सब एक ही पल में लौटते हैं। AWS ने 100 होड़ करते क्लाइंट का सिमुलेशन किया, जिसमें फ़ुल जिटर ने कॉल की संख्या आधी से भी ज़्यादा घटा दी और बिना जिटर वाले बैकऑफ़ से जल्दी काम पूरा किया। सबसे सरल रूप, फ़ुल जिटर, शून्य और exponential सीमा के बीच का कोई रैंडम समय इंतज़ार करता है:

import os, random, time
from openai import OpenAI, RateLimitError, APIStatusError, APIConnectionError

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"], max_retries=0)

RETRYABLE = {429, 500, 502, 503, 504}

def call_with_backoff(max_attempts=6, base=1.0, cap=60.0, **kwargs):
    for attempt in range(max_attempts):
        try:
            return client.chat.completions.create(**kwargs)
        except (RateLimitError, APIStatusError, APIConnectionError) as e:
            status = getattr(e, "status_code", None)
            if status is not None and status not in RETRYABLE:
                raise  # 400, 401, 403...: retrying will not help
            if attempt == max_attempts - 1:
                raise
            retry_after = None
            if getattr(e, "response", None) is not None:
                retry_after = e.response.headers.get("retry-after")
            wait = random.uniform(0, min(cap, base * 2 ** attempt))
            if retry_after and retry_after.isdigit():
                wait = max(wait, float(retry_after))
            time.sleep(wait)

max_retries=0 SDK के अपने रीट्राई बंद कर देता है, ताकि आप दो बार रीट्राई न करें। अगर SDK का बिल्ट-इन व्यवहार आपके लिए काफ़ी है, तो उल्टा भी चलता है: अपना लूप हटा दें और क्लाइंट पर max_retries=4 सेट करें, जैसा Python SDK गाइड में दिखाया गया है। आधिकारिक Python और Node SDK कनेक्शन एरर, 408, 409, 429 और 5xx को डिफ़ॉल्ट रूप से दो बार रीट्राई करते हैं।

Retry-After एक मानक हेडर (RFC 9110) है, जिसमें सेकंड या तारीख़ हो सकती है। BroadNet का डॉक्यूमेंटेशन इसका वादा नहीं करता, इसलिए कोड इसे वैकल्पिक मानता है।

429 को होने से पहले कैसे रोकें?

चालू अनुरोधों को key की सीमा पर रोकें। Python में asyncio.Semaphore यह एक ऑब्जेक्ट और एक async with ब्लॉक से कर देता है। कोड में उदाहरण के तौर पर 4 लिया गया है; इसे अपनी key की चालू अनुरोधों की सीमा पर सेट करें (BroadNet की उपयोग के अनुसार भुगतान वाली key पर 4):

import asyncio, os
from openai import AsyncOpenAI

client = AsyncOpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"], max_retries=4)
slots = asyncio.Semaphore(4)  # match the key's in-flight limit

async def ask(prompt):
    async with slots:
        r = await client.chat.completions.create(
            model="broadnet/gemma-4-26b-a4b",
            messages=[{"role": "user", "content": prompt}],
        )
        return r.choices[0].message.content

async def main(prompts):
    return await asyncio.gather(*(ask(p) for p in prompts))

results = asyncio.run(main(["Summarise A", "Summarise B", "Summarise C"]))

gather हर टास्क शुरू करता है, लेकिन एक साथ उतने ही चलते हैं जितने की semaphore अनुमति देता है। बाक़ी semaphore की क्यू में इंतज़ार करते हैं। Node में p-limit पैकेज यही करता है, यहाँ भी उदाहरण के तौर पर 4 के साथ:

// ES module (top-level await). npm install openai p-limit
import OpenAI from "openai";
import pLimit from "p-limit";

const client = new OpenAI({ baseURL: "https://inference.broadnet.ai/v1", apiKey: process.env.BROADNET_API_KEY, maxRetries: 4 });
const limit = pLimit(4); // match the key's in-flight limit

async function ask(prompt) {
  const r = await client.chat.completions.create({
    model: "broadnet/gemma-4-26b-a4b",
    messages: [{ role: "user", content: prompt }],
  });
  return r.choices[0].message.content;
}

const prompts = ["Summarise A", "Summarise B", "Summarise C"];
const results = await Promise.all(prompts.map((p) => limit(() => ask(p))));

प्रति मिनट की सीमा भी चाहिए, तो एक token bucket जोड़ें जो हर 60 / rpm सेकंड पर एक परमिट छोड़े, जहाँ rpm आपकी key की प्रति मिनट अनुरोधों की सीमा है (BroadNet की उपयोग के अनुसार भुगतान वाली key पर 30)।

असली क्यू की ज़रूरत कब पड़ती है?

semaphore एक ही प्रोसेस में रहता है। जब कई वर्कर या सर्वर एक key साझा करते हैं, तो सीमा भी साझा होती है और हर प्रोसेस सिर्फ़ अपना ट्रैफ़िक देखता है। तब:

  1. जॉब को एक साझा क्यू (Redis, SQS, डेटाबेस टेबल) में डालें।
  2. key की चालू-अनुरोध सीमा के बराबर, तय संख्या में कंज़्यूमर चलाएँ।
  3. हर जॉब को एक ID दें और नतीजे ID के हिसाब से सहेजें, ताकि रीट्राई हुआ जॉब दो बार न चले।
  4. इंटरैक्टिव ट्रैफ़िक और बैच ट्रैफ़िक को अलग key या अलग क्यू से भेजें, ताकि बैच का बैकलॉग जवाब का इंतज़ार कर रहे किसी यूज़र को कभी न रोके।

Batch API के बिना हज़ारों आइटम वाले बड़े जॉब के लिए फिर से शुरू हो सकने वाला बैच रनर देखें।

रीट्राई की कौन-सी ग़लतियाँ 429 को आउटेज बना देती हैं?

  • असीमित रीट्राई। लंबे आउटेज के दौरान बिना सीमा वाला रीट्राई लूप आपका लोड, और प्रति टोकन बिलिंग पर आपका बिल, कई गुना कर देता है।
  • आधी पूरी हुई स्ट्रीम को आँख मूँदकर रीट्राई करना। अगर स्ट्रीम टोकन लौटा चुकी है, तो रीट्राई एक नया इन्फ़रेंस है और यूज़र को टेक्स्ट दो बार दिख सकता है। अधूरी स्ट्रीम पहचानने के लिए स्ट्रीमिंग वाली पोस्ट देखें।
  • अकाउंट एरर को रीट्राई करना। उपयोग के अनुसार भुगतान का अलाउंस ख़त्म होने पर 401 या बैलेंस कम होने पर 402 अपने आप ठीक नहीं होगा।

हर रीट्राई को उसके स्टेटस, इंतज़ार के समय और X-Request-ID रिस्पॉन्स हेडर के साथ लॉग करें; BroadNet का डॉक्यूमेंटेशन सपोर्ट के लिए यह हेडर सँभालकर रखने को कहता है। बढ़ती रीट्राई दर सबसे पहली चेतावनी है कि आपको ज़्यादा क्षमता चाहिए; उपयोग की लॉगिंग बताती है कि इसे कैसे रिकॉर्ड करें।

BroadNet Inference कहाँ फ़िट होता है

BroadNet की सीमाएँ प्रकाशित हैं और इतनी छोटी हैं कि उनके हिसाब से डिज़ाइन किया जा सके: उपयोग के अनुसार भुगतान वाली key पर एक साथ 4 चालू अनुरोध। यह ऐप और एजेंट के लिए ठीक है, और उस बड़े जॉब के लिए बहुत तंग है जिसे एक key पर सैकड़ों समानांतर कॉल चाहिए। एजेंट के लिए अनलिमिटेड प्लान में कोई टोकन मीटर नहीं है और हर सेशन एक समय में एक अनुरोध चलाता है; समानांतर काम के लिए आप सेशन जोड़ते हैं, जैसा समानांतर कोडिंग एजेंट चलाना में बताया गया है। मौजूदा सीमाएँ API रेफ़रंस में हैं।

अक्सर पूछे जाने वाले सवाल

LLM API पर HTTP 429 का क्या मतलब है?

Too Many Requests। आपने प्रति मिनट अनुरोध, चालू अनुरोध, प्रति मिनट टोकन या ख़र्च की कोई सीमा पार कर दी। अनुरोध प्रोसेस नहीं हुआ, इसलिए थोड़ा इंतज़ार करके उसे दोबारा भेजना सुरक्षित है।

429 के बाद रीट्राई से पहले कितना इंतज़ार करें?

अगर सर्वर Retry-After भेजे तो उसका इस्तेमाल करें। वरना लगभग एक सेकंड से शुरू करें, हर कोशिश पर दोगुना करें, सीमा लगभग 30 से 60 सेकंड रखें, और शून्य से उस सीमा के बीच कोई रैंडम इंतज़ार चुनें। चार से छह कोशिशों के बाद रुक जाएँ।

क्या LLM API के 500 और 503 एरर रीट्राई करने चाहिए?

हाँ, उसी सीमित बैकऑफ़ के साथ। ये सर्वर की तरफ़ के एरर हैं। 400, 401, 403 या 422 हर बार उसी तरह फ़ेल होंगे, इसलिए उन्हें ठीक करें।

क्या OpenAI SDK 429 को अपने आप रीट्राई करता है?

हाँ। आधिकारिक Python और Node SDK कनेक्शन एरर, 408, 409, 429 और 5xx को डिफ़ॉल्ट रूप से दो बार, छोटे exponential backoff के साथ रीट्राई करते हैं। बैच जॉब के लिए max_retries बढ़ाएँ और अपनी कॉन्करेंसी सीमा जोड़ें।

प्रति मिनट अनुरोध की सीमा से नीचे होने पर भी 429 क्यों आता है?

आम तौर पर कॉन्करेंसी सीमा की वजह से। लंबे स्ट्रीमिंग जवाब कई सेकंड तक चालू रहते हैं, इसलिए कुछ ही समानांतर कॉल चालू-अनुरोध की सीमा छू सकती हैं, जबकि प्रति मिनट की गिनती कम दिखती है।

Markdown में पढ़ेंChatGPT से पूछेंClaude से पूछेंPerplexity से पूछें