Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Exponential Backoff bij HTTP 429

Les 6 van 12 Bijgewerkt op 30 juli 2026 Gevorderd
Op deze pagina
  1. Inzicht in de 429-fout
  2. Hoe Exponential Backoff werkt
  3. Handmatige implementatie
  4. Gebruik van de tenacity-bibliotheek
  5. Combinatie van Backoff en Semaphore
  6. Backoff aanpassen aan het fouttype
  7. Belangrijkste punten

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)