---
title: "LLM API 429 रेट लिमिट एरर: बैकऑफ़, जिटर और क्यू | BroadRouter"
description: "429 बनाम 5xx, फ़ुल जिटर के साथ exponential backoff, LLM API के लिए कॉन्करेंसी लिमिटर और क्यू, साथ में प्रोडक्शन में कॉपी करने लायक Python और Node कोड।"
url: https://broadrouter.com/hi/blog/handle-llm-api-429-rate-limits/
lang: hi
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

यह पेज अंग्रेज़ी से AI की मदद से अनुवाद किया गया है। [अंग्रेज़ी मूल पढ़ें](https://broadrouter.com/blog/handle-llm-api-429-rate-limits/) (2026-11-15 को अपडेट किया गया).

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

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

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

## मुख्य बातें

-   429 और 5xx को सीमित exponential backoff के साथ रीट्राई करें। 400, 401, 403, 413 या 422 को रीट्राई न करें: अनुरोध या अकाउंट ठीक करें।
-   फ़ुल जिटर (शून्य और exponential सीमा के बीच का रैंडम इंतज़ार) कई क्लाइंट को एक ही पल में रीट्राई करने से रोकता है।
-   ज़्यादातर 429 वॉल्यूम से नहीं, कॉन्करेंसी से आते हैं। key की चालू-अनुरोध सीमा पर सेट किया गया semaphore उन्हें जड़ से ख़त्म कर देता है।
-   BroadNet की उपयोग के अनुसार भुगतान वाली key प्रति मिनट 30 अनुरोध और एक साथ 4 चालू अनुरोध की अनुमति देती है; प्लान सेशन एक समय में एक अनुरोध चलाते हैं।
-   रीट्राई नए इन्फ़रेंस होते हैं। प्रति टोकन बिलिंग पर हर रीट्राई फिर से बिल होता है, इसलिए कोशिशें सीमित रखें।

**इस पेज पर**

1.  429 और 5xx में क्या फ़र्क़ है?
2.  कौन-सी सीमाएँ 429 की वजह बनती हैं?
3.  जिटर के साथ बैकऑफ़ कैसे लिखें?
4.  429 को होने से पहले कैसे रोकें?
5.  असली क्यू की ज़रूरत कब पड़ती है?
6.  रीट्राई की कौन-सी ग़लतियाँ 429 को आउटेज बना देती हैं?
7.  BroadNet Inference कहाँ फ़िट होता है

429 का मतलब है कि आपका ट्रैफ़िक किसी [रेट लिमिट](https://broadrouter.com/hi/glossary/rate-limit/) को पार कर गया: प्रति मिनट अनुरोध, चालू अनुरोध, प्रति मिनट टोकन या ख़र्च। इसे दो हिस्सों में ठीक करें। **सही तरीक़े से रीट्राई करें**: सीमित exponential backoff, रैंडम जिटर के साथ, और `Retry-After` का पालन। **एक साथ कम भेजें**: key की चालू-अनुरोध सीमा पर एक semaphore, और साथ में एक क्यू। दोनों नीचे कोड के साथ दिए गए हैं।

सभी स्टेटस कोड की पूरी जानकारी के लिए [एरर और रीट्राई गाइड](https://broadrouter.com/hi/guides/errors-and-retries/) देखें; चेकपॉइंट और टाइमआउट के साथ कई घंटे चलने वाले एजेंट के लिए [लंबे चलने वाले एजेंट: टाइमआउट और रीट्राई](https://broadrouter.com/hi/blog/long-running-agents-timeouts-retries/) देखें।

## 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 के फ़्री टियर और रेट लिमिट](https://broadrouter.com/data/llm-api-free-tiers-and-rate-limits/) का हमारा ओपन डेटासेट तुलना करता है कि 14 प्रोवाइडर मुफ़्त एक्सेस, शुरुआती रेट लिमिट, कार्ड की ज़रूरत और फ़्री-टियर डेटा पर ट्रेनिंग के बारे में क्या प्रकाशित करते हैं, हर मान के स्रोत और तारीख़ के साथ।

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

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

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

LLM के लिए सबसे अहम संख्या चालू अनुरोधों की है। स्ट्रीम किया गया जवाब आख़िरी टोकन आने तक अपना स्लॉट घेरे रहता है, इसलिए लंबा जवाब उसे तब तक व्यस्त रखता है जब तक मॉडल उसे लिख न ले (BroadNet आम स्पीड लगभग 100 टोकन प्रति सेकंड बताता है)। key के 4 स्लॉट से ज़्यादा समानांतर कॉल भेजें, तो अतिरिक्त कॉल को 429 मिलेगा, भले ही आपने उस मिनट गिनती के ही अनुरोध भेजे हों। यह [कॉन्करेंसी](https://broadrouter.com/hi/glossary/concurrency/) की समस्या है, और सिर्फ़ बैकऑफ़ इसे ठीक से नहीं सँभालता। लॉन्च से पहले किसी सीमा के हिसाब से वर्कर तय करने के लिए मुफ़्त [LLM रेट लिमिट कैलकुलेटर](https://broadrouter.com/tools/llm-rate-limit-calculator/) इस्तेमाल करें। कई आइटम वाले तय जॉब के लिए [LLM बैच जॉब प्लानर](https://broadrouter.com/tools/llm-batch-job-planner/) इन्हीं सीमाओं को रन टाइम में बदल देता है। दूसरे प्रोवाइडर अलग तरह से गिनते हैं (प्रति मिनट टोकन, प्रति दिन अनुरोध या चालू अनुरोध); [प्रोवाइडर के हिसाब से LLM API रेट लिमिट](https://broadrouter.com/hi/blog/llm-api-rate-limits-by-provider/) उनमें से 13 की तुलना उनके अपने डॉक्यूमेंटेशन से करता है।

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

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

```python
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 गाइड](https://broadrouter.com/hi/guides/openai-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):

```python
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 के साथ:

```javascript
// 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 के बिना हज़ारों आइटम वाले बड़े जॉब के लिए [फिर से शुरू हो सकने वाला बैच रनर](https://broadrouter.com/hi/blog/llm-batch-processing-without-batch-api/) देखें।

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

-   **असीमित रीट्राई।** लंबे आउटेज के दौरान बिना सीमा वाला रीट्राई लूप आपका लोड, और प्रति टोकन बिलिंग पर आपका बिल, कई गुना कर देता है।
-   **आधी पूरी हुई स्ट्रीम को आँख मूँदकर रीट्राई करना।** अगर स्ट्रीम टोकन लौटा चुकी है, तो रीट्राई एक नया इन्फ़रेंस है और यूज़र को टेक्स्ट दो बार दिख सकता है। अधूरी स्ट्रीम पहचानने के लिए [स्ट्रीमिंग वाली पोस्ट](https://broadrouter.com/hi/blog/llm-streaming-sse-explained/) देखें।
-   **अकाउंट एरर को रीट्राई करना।** उपयोग के अनुसार भुगतान का अलाउंस ख़त्म होने पर 401 या बैलेंस कम होने पर 402 अपने आप ठीक नहीं होगा।

हर रीट्राई को उसके स्टेटस, इंतज़ार के समय और `X-Request-ID` रिस्पॉन्स हेडर के साथ लॉग करें; BroadNet का डॉक्यूमेंटेशन सपोर्ट के लिए यह हेडर सँभालकर रखने को कहता है। बढ़ती रीट्राई दर सबसे पहली चेतावनी है कि आपको ज़्यादा क्षमता चाहिए; [उपयोग की लॉगिंग](https://broadrouter.com/hi/blog/llm-api-usage-logging/) बताती है कि इसे कैसे रिकॉर्ड करें।

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

BroadNet की सीमाएँ प्रकाशित हैं और इतनी छोटी हैं कि उनके हिसाब से डिज़ाइन किया जा सके: उपयोग के अनुसार भुगतान वाली key पर एक साथ 4 चालू अनुरोध। यह ऐप और एजेंट के लिए ठीक है, और उस बड़े जॉब के लिए बहुत तंग है जिसे एक key पर सैकड़ों समानांतर कॉल चाहिए। एजेंट के लिए [अनलिमिटेड प्लान](https://broadrouter.com/hi/guides/unlimited-llm-api-sessions/) में कोई टोकन मीटर नहीं है और हर सेशन एक समय में एक अनुरोध चलाता है; समानांतर काम के लिए आप सेशन जोड़ते हैं, जैसा [समानांतर कोडिंग एजेंट चलाना](https://broadrouter.com/hi/blog/run-parallel-coding-agents-flat-rate/) में बताया गया है। मौजूदा सीमाएँ [API रेफ़रंस](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-handle-llm-api-429-rate-limits&utm_content=body#limits) में हैं।

इस विषय के मुफ़्त टूल (अंग्रेज़ी में)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[मुफ़्त टूल (अंग्रेज़ी में)](https://broadrouter.com/tools/)

## इस लेख के शब्द

[कॉन्करेंसी (concurrency)](https://broadrouter.com/hi/glossary/concurrency/)

कॉन्करेंसी, किसी क्लाइंट के एक ही समय पर चल रहे (in-flight) अनुरोधों की संख्या है। LLM API अक्सर इसकी सीमा हर key या प्लान पर, प्रति मिनट अनुरोधों से अलग रखते हैं, क्योंकि हर खुला अनुरोध जवाब पूरा होने तक GPU क्षमता घेरे रहता है।

[उपयोग के अनुसार भुगतान (pay-as-you-go)](https://broadrouter.com/hi/glossary/pay-as-you-go/)

उपयोग के अनुसार भुगतान (pay-as-you-go) एक प्राइसिंग मॉडल है जिसमें आप सिर्फ़ उतना देते हैं जितना इस्तेमाल करते हैं, जिसे टोकन, अनुरोध या ऑडियो मिनट जैसी इकाइयों में मापा जाता है, बिना सब्सक्रिप्शन या न्यूनतम प्रतिबद्धता के। ज़्यादातर LLM API इसी तरह बिल बनाते हैं, प्रीपेड बैलेंस या समय-समय पर बनने वाले इनवॉइस से।

[टोकन (token)](https://broadrouter.com/hi/glossary/token/)

टोकन टेक्स्ट की वह इकाई है जिसे लैंग्वेज मॉडल पढ़ता और लिखता है: कोई शब्द, शब्द का हिस्सा, विराम चिह्न या बाइट का क्रम, जो मॉडल का टोकनाइज़र बनाता है। LLM API इस्तेमाल को टोकन में गिनते हैं, उसी में लिमिट लगाते हैं और आम तौर पर बिल भी बनाते हैं।

[रेट लिमिट (rate limit)](https://broadrouter.com/hi/glossary/rate-limit/)

रेट लिमिट वह सीमा है जो कोई API तय करता है कि एक क्लाइंट किसी समय-अवधि में उसका कितना इस्तेमाल कर सकता है, जैसे प्रति मिनट अनुरोध या प्रति मिनट टोकन। सीमा से ऊपर के अनुरोध ठुकरा दिए जाते हैं, आम तौर पर HTTP 429 Too Many Requests के साथ, जब तक इस्तेमाल फिर सीमा के नीचे न आ जाए।

[एक्सपोनेंशियल बैकऑफ़ (exponential backoff)](https://broadrouter.com/hi/glossary/exponential-backoff/)

एक्सपोनेंशियल बैकऑफ़ री-ट्राई की एक रणनीति है जिसमें क्लाइंट हर नाकाम कोशिश के बाद, दोबारा कोशिश करने से पहले, ज़्यादा देर इंतज़ार करता है, आम तौर पर देरी को एक सीमा तक दोगुना करते हुए। हर इंतज़ार में रैंडम jitter जोड़ने से कई क्लाइंट के री-ट्राई बिखर जाते हैं, ताकि वे एक ही पल सर्वर पर न पहुँचें।

[AI एजेंट (AI agent)](https://broadrouter.com/hi/glossary/agent/)

AI एजेंट ऐसा सिस्टम है जिसमें लैंग्वेज मॉडल किसी लक्ष्य की ओर अपने क़दम ख़ुद तय करता है: कौन-से टूल कॉल करने हैं, चुनता है, नतीजे पढ़ता है और अंतिम जवाब या किसी सीमा तक दोहराता रहता है। तय बिंदुओं पर मॉडल को कॉल करने वाली स्क्रिप्ट को आम तौर पर workflow कहते हैं।

[रिक्वेस्ट टाइमआउट (request timeout)](https://broadrouter.com/hi/glossary/request-timeout/)

रिक्वेस्ट टाइमआउट वह अधिकतम समय है जितना कोई HTTP क्लाइंट सर्वर का इंतज़ार करता है, उसके बाद अनुरोध छोड़ देता है। क्लाइंट आम तौर पर इसे कनेक्शन खोलने के connect टाइमआउट और डेटा के इंतज़ार वाले read टाइमआउट में बाँटते हैं। LLM कॉल को खुले read टाइमआउट चाहिए, क्योंकि लंबे जवाबों में समय लगता है।

[टूल कॉलिंग (tool calling)](https://broadrouter.com/hi/glossary/tool-calling/)

टूल कॉलिंग, जिसे function calling भी कहते हैं, LLM API की वह सुविधा है जिसमें मॉडल डेवलपर के तय किए किसी फ़ंक्शन को चलाने का एक स्ट्रक्चर्ड अनुरोध, JSON आर्ग्युमेंट के साथ, लौटाता है। ऐप्लिकेशन फ़ंक्शन चलाकर नतीजा वापस भेजता है; मॉडल ख़ुद कभी कोड नहीं चलाता।

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

### 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 क्यों आता है?

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

## आगे पढ़ें

-   [लंबे चलने वाले एजेंट: टिकाऊ timeout, retry और checkpoint](https://broadrouter.com/hi/blog/long-running-agents-timeouts-retries/)
-   [LLM स्ट्रीमिंग समझें: SSE चंक, डेल्टा, usage और कैंसल](https://broadrouter.com/hi/blog/llm-streaming-sse-explained/)
-   [फ़्लैट-रेट LLM API पर पैरेलल कोडिंग एजेंट कैसे चलाएँ](https://broadrouter.com/hi/blog/run-parallel-coding-agents-flat-rate/)
-   [LLM API usage लॉगिंग: हर यूज़र और फ़ीचर की लागत, PII हटाकर](https://broadrouter.com/hi/blog/llm-api-usage-logging/)
-   [Batch API के बिना LLM बैच प्रोसेसिंग: दोबारा शुरू होने वाला runner](https://broadrouter.com/hi/blog/llm-batch-processing-without-batch-api/)
-   [BroadNet का GPU हार्डवेयर और सर्विंग का तरीक़ा, BroadNet के शब्दों में](https://broadrouter.com/hi/blog/broadnet-gpu-fleet-and-serving/)
-   [LLM API रिस्पॉन्स कैश करके लागत घटाएँ: Python में एक्ज़ैक्ट-मैच कैश](https://broadrouter.com/hi/blog/cache-llm-responses-cut-cost/)
-   [गाइड: BroadNet Inference के एरर कोड और रीट्राई कब करें](https://broadrouter.com/hi/guides/errors-and-retries/)
-   [गाइड: BroadNet Inference के साथ OpenAI Python SDK इस्तेमाल करें](https://broadrouter.com/hi/guides/openai-python-sdk/)
-   [गाइड: एजेंट के लिए अनलिमिटेड LLM API प्लान कैसे काम करते हैं](https://broadrouter.com/hi/guides/unlimited-llm-api-sessions/)

इसे अपने असली वर्कलोड पर आज़माएँ। नए अकाउंट Gemma और ट्रांसक्रिप्शन के लिए US$5 के क्रेडिट से शुरू होते हैं। DeepSeek, GLM, और Qwen3.8 के लिए टॉप-अप ज़रूरी है।

[शुरू करें](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-handle-llm-api-429-rate-limits&utm_content=page-cta) ·

**स्रोत**

-   [BroadNet Inference API रेफ़रंस, एरर और सीमाएँ (2026-11-14 को देखा गया) (अंग्रेज़ी में)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-handle-llm-api-429-rate-limits&utm_content=sources#errors)
-   [AWS Architecture Blog, Exponential Backoff and Jitter (2026-11-14 को देखा गया)](https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/)
-   [RFC 6585, स्टेटस कोड 429 Too Many Requests (2026-11-14 को देखा गया)](https://www.rfc-editor.org/rfc/rfc6585#section-4)
-   [RFC 9110, Retry-After हेडर (2026-11-14 को देखा गया)](https://www.rfc-editor.org/rfc/rfc9110#field.retry-after)
-   [openai-python README, ऑटोमैटिक रीट्राई (2026-11-14 को देखा गया)](https://github.com/openai/openai-python)
-   [openai-node README, रीट्राई (2026-11-14 को देखा गया)](https://github.com/openai/openai-node)
