Understanding API Rate Limits

HTTP/1.1 429 Too Many Requests
Retry-After: 30
X-RateLimit-Limit: 500
X-RateLimit-Remaining: 0
X-RateLimit-Reset: 1744480000
Content-Type: application/json

{
  "error": {
    "type": "rate_limit_error",
    "message": "Rate limit exceeded. Retry after 30 seconds."
  }
}

import time, httpx

def make_request_with_retry(client, url, **kwargs):
    resp = client.get(url, **kwargs)
    if resp.status_code == 429:
        retry_after = int(resp.headers.get("Retry-After", 60))
        print(f"Rate limited. Waiting {retry_after}s before retry.")
        time.sleep(retry_after)
        resp = client.get(url, **kwargs)
    resp.raise_for_status()
    return resp

import time, random, httpx

def backoff_retry(client, url, max_retries=5, **kwargs):
    """Exponential backoff with full jitter."""
    for attempt in range(max_retries):
        resp = client.request(**kwargs, url=url)

        if resp.status_code not in (429, 500, 502, 503, 504):
            return resp

        if attempt == max_retries - 1:
            resp.raise_for_status()
            return resp

        # Respect Retry-After if present, otherwise use exponential backoff
        retry_after = resp.headers.get("Retry-After")
        if retry_after:
            delay = float(retry_after)
        else:
            # Full jitter: sleep random(0, min(cap, base * 2^attempt))
            cap = 60
            base = 1
            delay = random.uniform(0, min(cap, base * (2 ** attempt)))

        print(f"Attempt {attempt + 1} failed ({resp.status_code}). "
              f"Retrying in {delay:.1f}s.")
        time.sleep(delay)

    return None

// TypeScript: backoff retry with Retry-After support
async function fetchWithRetry(
  url: string,
  options: RequestInit,
  maxRetries = 5
): Promise<Response> {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const res = await fetch(url, options);

    if (res.ok) return res;
    if (![429, 500, 502, 503, 504].includes(res.status)) {
      throw new Error(`Request failed: ${res.status}`);
    }
    if (attempt === maxRetries - 1) throw new Error("Max retries exceeded");

    const retryAfter = res.headers.get("Retry-After");
    const delay = retryAfter
      ? parseFloat(retryAfter) * 1000
      : Math.min(60_000, 1000 * 2 ** attempt) * (0.5 + Math.random() * 0.5);

    console.log(`Retry ${attempt + 1} after ${(delay / 1000).toFixed(1)}s`);
    await new Promise((r) => setTimeout(r, delay));
  }
  throw new Error("Max retries exceeded");
}