Exponential Backoff bij HTTP 429
Op deze pagina
Inzicht in de 429-fout
Een HTTP 429-fout betekent dat u de snelheidslimieten (rate limits) van de API hebt overschreden. De xAI-server weigert uw verzoeken tijdelijk om de infrastructuur te beschermen. Deze fout is normaal in een context van batchverwerking: het geeft simpelweg aan dat u verzoeken te snel verzendt.
De juiste reactie is niet opgeven, maar wachten voordat u het opnieuw probeert. Exponential backoff is de standaardstrategie om deze situatie af te handelen.
Hoe Exponential Backoff werkt
In plaats van onmiddellijk opnieuw te proberen (wat weer een 429 zou veroorzaken), wacht u een toenemende vertraging tussen elke poging:
- 1e mislukking: wacht 1 seconde
- 2e mislukking: wacht 2 seconden
- 3e mislukking: wacht 4 seconden
- 4e mislukking: wacht 8 seconden
- 5e mislukking: geef op
De vertraging verdubbelt bij elke poging, vandaar de term “exponentieel”. Dit geeft de server tijd om capaciteit te herstellen.
Handmatige implementatie
import asyncio
import random
from openai import RateLimitError
async def request_with_backoff(
prompt: str,
max_retries: int = 5,
base_delay: float = 1.0
) -> str:
for attempt in range(max_retries):
try:
response = await client.chat.completions.create(
model="grok-4.5",
messages=[{"role": "user", "content": prompt}]
)
return response.choices[0].message.content
except RateLimitError:
if attempt == max_retries - 1:
raise # last attempt, propagate the error
delay = base_delay * (2 ** attempt)
jitter = random.uniform(0, delay * 0.1)
wait_time = delay + jitter
print(f"Rate limit hit, attempt {attempt + 1}/{max_retries}. "
f"Waiting {wait_time:.1f}s")
await asyncio.sleep(wait_time)
De jitter (willekeurige variatie) is belangrijk. Als meerdere coroutines tegelijkertijd een 429 ontvangen, zouden ze zonder jitter allemaal op exact hetzelfde moment opnieuw proberen, wat weer een 429 zou veroorzaken. Jitter desynchroniseert de pogingen.
Gebruik van de tenacity-bibliotheek
Voor productiegebruik vereenvoudigt de tenacity-bibliotheek de implementatie:
from tenacity import (
retry,
stop_after_attempt,
wait_exponential,
retry_if_exception_type
)
from openai import RateLimitError
@retry(
stop=stop_after_attempt(5),
wait=wait_exponential(multiplier=1, min=1, max=60),
retry=retry_if_exception_type(RateLimitError)
)
async def robust_request(prompt: str) -> str:
response = await client.chat.completions.create(
model="grok-4.5",
messages=[{"role": "user", "content": prompt}]
)
return response.choices[0].message.content
De @retry-decorator onderschept RateLimitError, wacht een exponentiële vertraging (tussen 1 en 60 seconden) en probeert het maximaal 5 keer opnieuw. De functiecode blijft schoon en leesbaar.
Combinatie van Backoff en Semaphore
In de praktijk combineert u backoff met een semaphore voor volledige controle:
async def resilient_batch(prompts: list[str], max_concurrent: int = 5) -> list[str]:
sem = Semaphore(max_concurrent)
async def single_request(prompt: str) -> str:
async with sem:
return await request_with_backoff(prompt)
tasks = [single_request(p) for p in prompts]
return await asyncio.gather(*tasks, return_exceptions=True)
De semaphore voorkomt overbelasting van de API, en backoff handelt resterende 429-fouten af. Deze dubbele bescherming is de aanbevolen configuratie voor productie.
Backoff aanpassen aan het fouttype
Niet alle fouten rechtvaardigen een nieuwe poging. Hier is een classificatie:
from openai import RateLimitError, APITimeoutError, APIConnectionError, BadRequestError
async def smart_retry(prompt: str, max_retries: int = 5) -> str:
for attempt in range(max_retries):
try:
return await client.chat.completions.create(
model="grok-4.5",
messages=[{"role": "user", "content": prompt}]
)
except RateLimitError:
delay = 2 ** attempt
await asyncio.sleep(delay)
except (APITimeoutError, APIConnectionError):
delay = 2 ** attempt
await asyncio.sleep(delay)
except BadRequestError:
raise # error in prompt, retry useless
429-fouten (snelheidslimiet), time-outs en verbindingsfouten verdienen een nieuwe poging. Een BadRequestError (ongeldige prompt) wordt echter niet opgelost door opnieuw te proberen.
Belangrijkste punten
- Een 429-fout is normaal en verwacht tijdens batchverwerking
- Exponential backoff verdubbelt de vertraging tussen elke poging (1s, 2s, 4s, 8s…)
- Jitter desynchroniseert nieuwe pogingen om botsingen te voorkomen
- De
tenacity-bibliotheek vereenvoudigt de implementatie in productie - Combineer altijd semaphore en backoff voor maximale veerkracht
- Probeer geen ongeldige verzoekfouten opnieuw (
BadRequestError)