---
title: "Paano ayusin ang 429 rate limit sa LLM API | BroadRouter"
description: "429 vs 5xx, exponential backoff na may full jitter, concurrency limiter at queue para sa LLM API, may Python at Node code na puwedeng kopyahin sa production."
url: https://broadrouter.com/fil/blog/handle-llm-api-429-rate-limits/
lang: fil
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Isinalin mula sa Ingles sa tulong ng AI. [Basahin ang orihinal sa Ingles](https://broadrouter.com/blog/handle-llm-api-429-rate-limits/) (na-update noong 2026-11-15).

# Paano ayusin ang 429 error sa LLM API: backoff, jitter at limiter

Ng BroadNet Inference team · 5 minutong basa · Nailathala 2026-11-14 · Na-update 2026-11-15

Ang 429 ay nangangahulugang tumama ka sa rate, concurrency o spend limit. I-retry ito gamit ang exponential backoff na may cap at random na jitter, at sundin ang Retry-After kapag ipinadala. Pagkatapos, pigilan ang karamihan ng 429: limitahan ang mga request na in flight gamit ang semaphore sa limit ng key, at i-queue ang iba. Ganoon din i-retry ang 5xx; ayusin naman ang ibang 4xx error.

## Mga pangunahing punto

-   I-retry ang 429 at 5xx gamit ang exponential backoff na may hangganan. Huwag i-retry ang 400, 401, 403, 413 o 422: ayusin ang request o ang account.
-   Pinipigilan ng full jitter (random na paghihintay mula zero hanggang sa exponential na cap) ang sabay-sabay na pag-retry ng maraming client.
-   Karamihan ng 429 ay galing sa concurrency, hindi sa volume. Inaalis ito sa pinagmulan ng semaphore na naka-set sa in-flight limit ng key.
-   Ang pay-as-you-go key ng BroadNet ay may 30 request kada minuto at 4 in flight; isang request sa bawat pagkakataon ang plan session.
-   Bagong inference ang bawat retry. Sa per-token billing, sinisingil ulit ang bawat isa, kaya limitahan ang bilang ng subok.

**Sa page na ito**

1.  Ano ang pagkakaiba ng 429 at 5xx?
2.  Aling mga limit ang nagdudulot ng 429?
3.  Paano isulat ang backoff na may jitter?
4.  Paano pigilan ang 429 bago pa ito mangyari?
5.  Kailan mo kailangan ng totoong queue?
6.  Aling mga pagkakamali sa retry ang ginagawang outage ang 429?
7.  Saan pumapasok ang BroadNet Inference

Ang 429 ay nangangahulugang lumampas ang traffic mo sa isang [rate limit](https://broadrouter.com/fil/glossary/rate-limit/): request kada minuto, request na in flight, token kada minuto o paggastos. Dalawang bahagi ang pag-aayos nito. **Mag-retry nang tama**: exponential backoff na may cap at random na jitter, at sinusunod ang `Retry-After`. **Magpadala nang mas kaunti nang sabay-sabay**: isang semaphore sa in-flight limit ng key, dagdag ang isang queue. Nasa ibaba ang dalawa, may code.

Para sa kumpletong reference ng status code, tingnan ang [gabay sa errors at retries](https://broadrouter.com/fil/guides/errors-and-retries/); para sa mga agent run na ilang oras ang tagal na may checkpoint at timeout, tingnan ang [long-running agents: timeout at retry](https://broadrouter.com/fil/blog/long-running-agents-timeouts-retries/).

## Ano ang pagkakaiba ng 429 at 5xx?

| Status | Kaninong problema | I-retry? | Paano |
| --- | --- | --- | --- |
| 429 | Lumampas sa limit ang traffic mo | Oo | Backoff na may jitter; sundin ang `Retry-After`; babaan ang concurrency |
| 500 / 502 / 503 / 504 | Sa server | Oo | Exponential backoff na may hangganan |
| Connection reset, timeout | Network o server | Kadalasan | Backoff; para sa stream, kung katanggap-tanggap lang ang bagong singil |
| 400 / 422 | Maling request | Hindi | Ayusin ang payload |
| 401 / 402 / 403 | Key, balance o patakaran | Hindi | Ayusin ang key, lagyan ng pondo ang account, ayusin ang allow-list |
| 413 | Masyadong malaki ang request | Hindi | Paliitin ito |

Sa BroadNet Inference, puwedeng alinman sa apat na limit ang ibig sabihin ng 429: rate, concurrency, token rate o paggastos. Hindi mawawala sa loob ng 30 segundo ang spend limit. Hindi sinasabi ng docs ng BroadNet kung aling field ng error body ang nagpapangalan sa limit, kaya i-log ang body at ikumpara ito sa mga limit na nakalagay sa detalye ng key mo.

Ikinukumpara ng bukas naming dataset ng [free tier at rate limit ng mga LLM API](https://broadrouter.com/data/llm-api-free-tiers-and-rate-limits/) ang inilalathala ng 14 na provider tungkol sa libreng access, panimulang rate limit, pangangailangan ng card at training sa data ng free tier, kasama ang source at petsa ng bawat value.

## Aling mga limit ang nagdudulot ng 429?

Alamin ang mga numerong kinakalaban mo. Sa BroadNet Inference:

| Uri ng key | Request / minuto | In flight | Iba pa |
| --- | --- | --- | --- |
| Pay-as-you-go | 30 | 4 | Shared na spend budget |
| Hourly key | 120 | 1 stream | 300,000 token / minuto |
| Unlimited na plan session | — | 1 request kada session | Walang token meter |

Ang bilang na in flight ang pinakamahalaga para sa mga LLM. Hawak ng naka-stream na sagot ang slot nito hanggang dumating ang huling token, kaya okupado ng mahabang sagot ang slot habang isinusulat pa ito ng model (ayon sa BroadNet, karaniwang bilis ang mga 100 token bawat segundo). Kapag nagpadala ka ng mas maraming parallel na call kaysa sa 4 slot ng key, tatama sa 429 ang mga sobra, kahit iilang request lang ang ipinadala mo sa minutong iyon. Problema iyan sa [concurrency](https://broadrouter.com/fil/glossary/concurrency/), at hindi ito maayos na nahahawakan ng backoff lang. Para tantiyahin ang bilang ng worker laban sa isang limit bago mag-launch, gamitin ang libreng [LLM rate limit calculator](https://broadrouter.com/tools/llm-rate-limit-calculator/). Para sa isang fixed na job na maraming item, ginagawang run time ng [LLM batch job planner](https://broadrouter.com/tools/llm-batch-job-planner/) ang parehong mga limit. Iba ang pagbilang ng ibang provider (token kada minuto, request kada araw o request na in flight); ikinukumpara ng [rate limit ng LLM API ayon sa provider](https://broadrouter.com/fil/blog/llm-api-rate-limits-by-provider/) ang 13 sa kanila mula sa sarili nilang docs.

## Paano isulat ang backoff na may jitter?

Ang karaniwang [exponential backoff](https://broadrouter.com/fil/glossary/exponential-backoff/) ay naghihintay ng 1, 2, 4, 8 segundo. Kung sabay-sabay na na-throttle ang isandaang worker, sabay-sabay din silang babalik. Sa simulation ng AWS na may 100 nag-aagawang client, nabawasan ng full jitter nang higit sa kalahati ang bilang ng call at mas maaga itong natapos kaysa backoff na walang jitter. Ang pinakasimpleng bersyon, ang **full jitter**, ay naghihintay ng random na tagal mula zero hanggang sa exponential na cap:

```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)
```

Pinapatay ng `max_retries=0` ang sariling retry ng SDK para hindi ka mag-retry nang doble. Kung ayos ka na sa built-in na behavior ng SDK, puwede rin ang kabaligtaran: huwag nang gamitin ang sarili mong loop at i-set ang `max_retries=4` sa client, gaya ng ipinapakita ng [gabay sa Python SDK](https://broadrouter.com/fil/guides/openai-python-sdk/). Nire-retry ng opisyal na Python at Node SDK ang connection error, 408, 409, 429 at 5xx nang dalawang beses by default.

Ang `Retry-After` ay standard na header (RFC 9110) na puwedeng maglaman ng bilang ng segundo o ng petsa. Hindi ito ipinapangako ng docs ng BroadNet, kaya optional ito sa code.

## Paano pigilan ang 429 bago pa ito mangyari?

Limitahan ang mga request na in flight sa limit ng key. Sa Python, kaya ito ng `asyncio.Semaphore` gamit ang isang object at isang `async with` block. 4 ang ginagamit ng code bilang halimbawa; i-set ito sa in-flight limit ng key mo (4 sa pay-as-you-go key ng BroadNet):

```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"]))
```

Sinisimulan ng `gather` ang bawat task, pero kung ilan lang ang pinapayagan ng semaphore, iyon lang ang sabay-sabay na tumatakbo. Naghihintay ang iba sa queue ng semaphore. Sa Node, ganito rin ang ginagawa ng package na `p-limit`, na 4 ulit ang halimbawang value:

```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))));
```

Kung may per-minute cap din, magdagdag ng token bucket na naglalabas ng isang permit kada 60 / rpm segundo, kung saan ang rpm ay ang limit ng key mo sa request kada minuto (30 sa pay-as-you-go key ng BroadNet).

## Kailan mo kailangan ng totoong queue?

Nasa iisang process lang ang semaphore. Kapag maraming worker o server na ang naghahati sa iisang key, shared na ang limit at sariling traffic lang ang nakikita ng bawat process. Kaya:

1.  Ilagay ang mga job sa isang shared na queue (Redis, SQS, isang database table).
2.  Magpatakbo ng fixed na bilang ng consumer na katumbas ng in-flight limit ng key.
3.  Bigyan ng ID ang bawat job at i-store ang resulta ayon sa ID, para hindi tumakbo nang dalawang beses ang na-retry na job.
4.  Paghiwalayin ang interactive traffic at batch traffic sa magkaibang key o magkaibang queue, para hindi kailanman maharangan ng nakapilang batch ang user na naghihintay ng sagot.

Para sa bulk job na libu-libo ang item at walang Batch API, tingnan ang [resumable na batch runner](https://broadrouter.com/fil/blog/llm-batch-processing-without-batch-api/).

## Aling mga pagkakamali sa retry ang ginagawang outage ang 429?

-   **Retry na walang hangganan.** Ang retry loop na walang cap habang may mahabang outage ay nagpaparami ng load mo at, sa per-token billing, ng bill mo.
-   **Bulag na pag-retry sa stream na kalahati pa lang ang tapos.** Kung may naibalik nang token ang stream, bagong inference ang retry at puwedeng makita ng user ang text nang dalawang beses. Tingnan ang [post tungkol sa streaming](https://broadrouter.com/fil/blog/llm-streaming-sse-explained/) para malaman kung paano matukoy ang hindi kumpletong stream.
-   **Pag-retry sa account error.** Hindi kusang maaayos ang 401 dahil ubos na ang pay-as-you-go allowance o ang 402 dahil kulang ang balance.

I-log ang bawat retry kasama ang status, tagal ng paghihintay at ang `X-Request-ID` response header, na hinihiling ng docs ng BroadNet na itago mo para sa support. Ang tumataas na retry rate ang pinakamaagang babala na kailangan mo ng dagdag na capacity; ipinapakita ng [usage logging](https://broadrouter.com/fil/blog/llm-api-usage-logging/) kung paano ito i-record.

## Saan pumapasok ang BroadNet Inference

Nakalathala ang mga limit ng BroadNet at sapat ang liit para pagdisenyuhan: 4 request na in flight sa isang pay-as-you-go key. Bagay iyon sa mga app at agent, pero masyadong masikip para sa bulk job na gustong magpatakbo ng daan-daang parallel na call sa iisang key. Para sa mga agent, walang token meter ang isang [unlimited na plan](https://broadrouter.com/fil/guides/unlimited-llm-api-sessions/) at isang request sa bawat pagkakataon ang tinatakbo nito kada session; nagdadagdag ka ng session para sa parallel na trabaho, gaya ng inilalarawan sa [pagpapatakbo ng parallel na coding agent](https://broadrouter.com/fil/blog/run-parallel-coding-agents-flat-rate/). Nasa [API reference](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-handle-llm-api-429-rate-limits&utm_content=body#limits) ang kasalukuyang mga limit.

Mga libreng tool para rito (Ingles)

-   [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.

[Libreng tools (Ingles)](https://broadrouter.com/tools/)

## Mga termino sa artikulong ito

[API key](https://broadrouter.com/fil/glossary/api-key/)

Ang API key ay isang lihim na string na kumikilala at nagpapahintulot sa client na tumatawag sa isang API. Kadalasang hinihingi ito ng mga LLM API sa Authorization: Bearer header, at ang sinumang may hawak ng key ay makakagawa ng mga request na sisingilin sa account na may-ari nito.

[Pay-as-you-go](https://broadrouter.com/fil/glossary/pay-as-you-go/)

Ang pay-as-you-go ay paraan ng pagpepresyo kung saan ang nagamit mo lang ang binabayaran mo, sinusukat kada yunit gaya ng token, request o minuto ng audio, nang walang subscription o minimum na commitment. Ganito naniningil ang karamihan ng LLM API, mula sa prepaid na balance o sa pana-panahong invoice.

[Rate limit](https://broadrouter.com/fil/glossary/rate-limit/)

Ang rate limit ay hangganang itinatakda ng API sa dami ng paggamit ng isang client sa isang yugto ng oras, gaya ng request kada minuto o token kada minuto. Tinatanggihan ang mga request na lampas sa limit, kadalasan na may HTTP 429 Too Many Requests, hanggang bumaba ulit ang paggamit.

[Token](https://broadrouter.com/fil/glossary/token/)

Ang token ay ang yunit ng text na binabasa at isinusulat ng isang language model: isang salita, bahagi ng salita, bantas o byte sequence na ginawa ng tokenizer ng model. Sa token binibilang, nililimitahan at kadalasang sinisingil ng mga LLM API ang paggamit.

[Concurrency](https://broadrouter.com/fil/glossary/concurrency/)

Ang concurrency ay ang bilang ng request na sabay-sabay na in flight mula sa isang client. Madalas itong nililimitahan ng mga LLM API kada key o plan, hiwalay sa requests per minute, dahil humahawak ng GPU capacity ang bawat bukas na request hanggang matapos ang response nito.

[AI agent](https://broadrouter.com/fil/glossary/agent/)

Ang AI agent ay isang system kung saan ang language model mismo ang nagdidirekta ng mga hakbang nito tungo sa isang layunin: pinipili nito kung aling tools ang tatawagin, binabasa ang mga resulta at umuulit hanggang makabuo ng huling sagot o maabot ang limit. Workflow naman ang karaniwang tawag sa fixed na script na tumatawag sa model sa takdang punto.

[Exponential backoff](https://broadrouter.com/fil/glossary/exponential-backoff/)

Ang exponential backoff ay estratehiya sa pag-retry kung saan mas matagal na naghihintay ang client pagkatapos ng bawat pumalyang attempt, kadalasang dinodoble ang delay hanggang sa isang cap, bago sumubok ulit. Ikinakalat ng random na jitter sa bawat paghihintay ang mga retry ng maraming client para hindi sila sabay-sabay na tumama sa server.

[Flat-rate LLM plan (unlimited na plan)](https://broadrouter.com/fil/glossary/flat-rate-llm-plan/)

Ang flat-rate LLM plan ay naniningil ng fixed na presyo para sa isang period, gaya ng isang buwan, para sa access sa language model API sa halip na maningil kada token. Kadalasang may ibang nililimitahan ang ganitong plan, gaya ng concurrency, bilis, mga model o usage window, kaya kasinghalaga ng presyo ang mga limit.

## Mga tanong

### Ano ang ibig sabihin ng HTTP 429 sa isang LLM API?

Too Many Requests. Lumampas ka sa limit ng request kada minuto, request na in flight, token kada minuto o paggastos. Hindi naproseso ang request, kaya ligtas itong ipadala ulit pagkatapos maghintay.

### Gaano katagal ako dapat maghintay bago i-retry ang 429?

Gamitin ang Retry-After kung ipinapadala ito ng server. Kung hindi, magsimula sa mga isang segundo, doblehin sa bawat subok, mag-cap sa mga 30 hanggang 60 segundo, at pumili ng random na paghihintay mula zero hanggang sa cap na iyon. Huminto pagkatapos ng apat hanggang anim na subok.

### Dapat ko bang i-retry ang 500 at 503 error mula sa LLM API?

Oo, gamit ang parehong backoff na may hangganan. Sa server ang problema. Ang 400, 401, 403 o 422 ay papalya sa parehong paraan sa bawat pagkakataon, kaya ayusin na lang ito.

### Awtomatiko bang nire-retry ng OpenAI SDK ang 429?

Oo. Nire-retry ng opisyal na Python at Node SDK ang connection error, 408, 409, 429 at 5xx nang dalawang beses by default, na may maikling exponential backoff. Taasan ang max\_retries para sa mga batch job at magdagdag ng sarili mong concurrency limit.

### Bakit ako nakakakuha ng 429 kahit mababa pa ako sa requests-per-minute limit?

Kadalasan, dahil sa concurrency limit. Ilang segundong in flight ang mahahabang streaming response, kaya puwedeng tumama sa in-flight cap ang ilang parallel na call kahit mukhang mababa ang bilang kada minuto.

## Magbasa pa

-   [Matagal na tumatakbong agent: timeout, retry at checkpoint na matibay](https://broadrouter.com/fil/blog/long-running-agents-timeouts-retries/)
-   [Paliwanag sa LLM streaming: SSE chunk, delta, usage at cancel](https://broadrouter.com/fil/blog/llm-streaming-sse-explained/)
-   [Paano magpatakbo ng sabay-sabay na coding agent sa flat-rate LLM API](https://broadrouter.com/fil/blog/run-parallel-coding-agents-flat-rate/)
-   [Usage logging ng LLM API: gastos kada user at feature, walang PII](https://broadrouter.com/fil/blog/llm-api-usage-logging/)
-   [LLM batch processing nang walang Batch API: resumable na runner](https://broadrouter.com/fil/blog/llm-batch-processing-without-batch-api/)
-   [GPU hardware at paraan ng serving ng BroadNet, ayon sa BroadNet](https://broadrouter.com/fil/blog/broadnet-gpu-fleet-and-serving/)
-   [I-cache ang LLM API response, makatipid: exact-match cache sa Python](https://broadrouter.com/fil/blog/cache-llm-responses-cut-cost/)
-   [Gabay: Mga error code ng BroadNet Inference at kailan dapat mag-retry](https://broadrouter.com/fil/guides/errors-and-retries/)
-   [Gabay: Paano gamitin ang OpenAI Python SDK sa BroadNet Inference](https://broadrouter.com/fil/guides/openai-python-sdk/)
-   [Gabay: Paano gumagana ang unlimited LLM API plans para sa mga agent](https://broadrouter.com/fil/guides/unlimited-llm-api-sessions/)

Subukan ito sa totoong workload mo. May US$5 na panimulang credit ang mga bagong account para sa Gemma at transcription. Kailangan ng top-up para sa DeepSeek, GLM, at Qwen3.8.

[Magsimula](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-handle-llm-api-429-rate-limits&utm_content=page-cta) ·

**Mga source**

-   [API reference ng BroadNet Inference, errors at limits (kinuha noong 2026-11-14) (Ingles)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-handle-llm-api-429-rate-limits&utm_content=sources#errors)
-   [AWS Architecture Blog, Exponential Backoff and Jitter (kinuha noong 2026-11-14)](https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/)
-   [RFC 6585, status code 429 Too Many Requests (kinuha noong 2026-11-14)](https://www.rfc-editor.org/rfc/rfc6585#section-4)
-   [RFC 9110, Retry-After header (kinuha noong 2026-11-14)](https://www.rfc-editor.org/rfc/rfc9110#field.retry-after)
-   [README ng openai-python, awtomatikong retry (kinuha noong 2026-11-14)](https://github.com/openai/openai-python)
-   [README ng openai-node, mga retry (kinuha noong 2026-11-14)](https://github.com/openai/openai-node)
