Ang 429 ay nangangahulugang lumampas ang traffic mo sa isang 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; para sa mga agent run na ilang oras ang tagal na may checkpoint at timeout, tingnan ang long-running agents: timeout at retry.
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 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, 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. Para sa isang fixed na job na maraming item, ginagawang run time ng 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 ang 13 sa kanila mula sa sarili nilang docs.
Paano isulat ang backoff na may jitter?
Ang karaniwang 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:
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. 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):
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:
// 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:
- Ilagay ang mga job sa isang shared na queue (Redis, SQS, isang database table).
- Magpatakbo ng fixed na bilang ng consumer na katumbas ng in-flight limit ng key.
- 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.
- 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.
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 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 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 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. Nasa API reference ang kasalukuyang mga limit.
