BroadRouter

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

Ng BroadNet Inference team · 5 minutong basa · Nailathala · Na-update

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.

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:

  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.

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.

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.

Basahin bilang MarkdownTanungin ang ChatGPTTanungin ang ClaudeTanungin ang Perplexity