Ir al contenido principal
Español— Elegir un idioma
Menú

Retroceso exponencial ante HTTP 429

Lección 6 de 12 Actualizado el 30 de julio de 2026 Avanzado
En esta página
  1. Comprensión del error 429
  2. Funcionamiento del retroceso exponencial
  3. Implementación manual
  4. Uso de la biblioteca tenacity
  5. Combinación de retroceso y semáforo
  6. Adaptación del retroceso al tipo de error
  7. Puntos clave

Comprensión del error 429

Un error HTTP 429 indica que has superado los límites de tasa (rate limits) de la API. El servidor de xAI rechaza temporalmente tus solicitudes para proteger la infraestructura. Este error es normal en un contexto de procesamiento por lotes: simplemente señala que estás enviando peticiones con demasiada rapidez.

La reacción adecuada no es abandonar, sino esperar antes de reintentar. El retroceso exponencial es la estrategia estándar para gestionar esta situación.

Funcionamiento del retroceso exponencial

En lugar de reintentar de inmediato (lo que provocaría otro 429), esperas un tiempo de espera creciente entre cada intento:

  • 1.º fallo: esperar 1 segundo
  • 2.º fallo: esperar 2 segundos
  • 3.º fallo: esperar 4 segundos
  • 4.º fallo: esperar 8 segundos
  • 5.º fallo: abandonar

El retraso se duplica en cada intento, de ahí el término «exponencial». Esto otorga al servidor tiempo para recuperar capacidad.

Implementación manual

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  # último intento, propagar el error

            delay = base_delay * (2 ** attempt)
            jitter = random.uniform(0, delay * 0.1)
            wait_time = delay + jitter

            print(f"Límite de tasa alcanzado, intento {attempt + 1}/{max_retries}. "
                  f"Esperando {wait_time:.1f}s")
            await asyncio.sleep(wait_time)

El jitter (variación aleatoria) es crucial. Si varias corrutinas reciben un 429 al mismo tiempo, sin jitter todas reintentarían exactamente en el mismo instante, provocando otro 429. El jitter desincroniza los intentos.

Uso de la biblioteca tenacity

Para entornos de producción, la biblioteca tenacity simplifica la implementación:

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

El decorador @retry intercepta RateLimitError, espera un retraso exponencial (entre 1 y 60 segundos) y reintenta hasta 5 veces. El código de la función permanece limpio y legible.

Combinación de retroceso y semáforo

En la práctica, combinas el retroceso con un semáforo para un control total:

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)

El semáforo evita sobrecargar la API, mientras que el retroceso gestiona los errores 429 residuales. Esta doble protección es la configuración recomendada para producción.

Adaptación del retroceso al tipo de error

No todos los errores justifican un reintento. Aquí tienes una clasificación:

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 en el prompt, el reintento es inútil

Los errores 429 (límite de tasa), los tiempos de espera agotados y los errores de conexión merecen un reintento. Sin embargo, un BadRequestError (prompt no válido) no se resolverá reintentando.

Puntos clave

  • Un error 429 es normal y esperado durante el procesamiento por lotes
  • El retroceso exponencial duplica el retraso entre cada intento (1 s, 2 s, 4 s, 8 s…)
  • El jitter desincroniza los nuevos intentos para evitar colisiones
  • La biblioteca tenacity simplifica la implementación en producción
  • Combina siempre semáforo y retroceso para lograr la máxima resiliencia
  • No reintentes errores de solicitud no válida (BadRequestError)