429 Too Many Requests: handle API rate limits with retries that work

HTTP/1.1 429 Too Many Requests
Content-Type: application/json; charset=utf-8
Retry-After: 1
X-RateLimit-Limit: 10
X-RateLimit-Remaining: 0
X-RateLimit-Policy: 10;w=1

import os
import random
import time
from email.utils import parsedate_to_datetime

import requests

BASE_URL = "https://api.tickerlayer.com"
RETRYABLE = {429, 500, 502, 503, 504}

session = requests.Session()
session.headers["x-api-key"] = os.environ["TICKERLAYER_API_KEY"]


class QuotaExceeded(Exception):
    """The monthly quota is used up. Retrying will not help until it resets."""


def body_of(resp):
    try:
        body = resp.json()
    except ValueError:
        return {}
    return body if isinstance(body, dict) else {}


def server_wait(resp, body):
    """Seconds the server asked us to wait, or None if it did not say."""
    if isinstance(body.get("retryAfterMs"), (int, float)):
        return body["retryAfterMs"] / 1000  # more precise than the header
    value = resp.headers.get("Retry-After")
    if not value:
        return None
    if value.strip().isdigit():
        return float(value)
    try:  # the HTTP-date form: "Wed, 21 Oct 2026 07:28:00 GMT"
        return max(0.0, parsedate_to_datetime(value).timestamp() - time.time())
    except (TypeError, ValueError):
        return None


def get(path, params=None, max_attempts=5, base=0.5, cap=20.0):
    """GET a TickerLayer path, retrying 429 and transient 5xx responses."""
    for attempt in range(1, max_attempts + 1):
        resp = session.get(BASE_URL + path, params=params, timeout=10)
        if resp.status_code not in RETRYABLE:
            resp.raise_for_status()  # 400, 401, 403, 404: fix the request instead
            return resp.json()

        body = body_of(resp)
        if body.get("error") == "REST_QUOTA_EXCEEDED":
            raise QuotaExceeded(f"monthly quota of {body.get('limit')} requests used up")
        if attempt == max_attempts:
            resp.raise_for_status()

        hint = server_wait(resp, body)
        if hint is not None:
            delay = hint + random.uniform(0, base)  # honour the server, de-synchronise a little
        else:
            delay = random.uniform(0, min(cap, base * 2 ** attempt))  # full jitter
        print(f"{resp.status_code} on {path} (attempt {attempt}), retrying in {delay:.2f}s")
        time.sleep(delay)


if __name__ == "__main__":
    quote = get("/forex/quote/EURUSD")
    print(quote["symbol"], quote["bid"], quote["ask"], quote["timestamp"])

EURUSD 1.137233 1.137242 1790592920001

429 on /forex/quote/EURUSD (attempt 1), retrying in 0.27s
429 on /forex/quote/EURUSD (attempt 2), retrying in 1.32s
503 on /forex/quote/EURUSD (attempt 3), retrying in 1.67s
EURUSD 1.137233 1.137242 1790592920001

const BASE_URL = "https://api.tickerlayer.com";
const API_KEY = process.env.TICKERLAYER_API_KEY;
const RETRYABLE = new Set([429, 500, 502, 503, 504]);
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

class QuotaExceeded extends Error {}

// Milliseconds the server asked us to wait, or null if it did not say.
function serverWaitMs(res, body) {
  if (typeof body.retryAfterMs === "number") return body.retryAfterMs;
  const value = res.headers.get("retry-after");
  if (!value) return null;
  if (/^\d+$/.test(value.trim())) return Number(value) * 1000;
  const at = Date.parse(value); // the HTTP-date form
  return Number.isNaN(at) ? null : Math.max(0, at - Date.now());
}

async function get(path, { maxAttempts = 5, baseMs = 500, capMs = 20_000 } = {}) {
  for (let attempt = 1; ; attempt++) {
    const res = await fetch(BASE_URL + path, {
      headers: { "x-api-key": API_KEY },
      signal: AbortSignal.timeout(10_000),
    });
    const body = await res.json().catch(() => ({}));
    if (res.ok) return body;
    if (!RETRYABLE.has(res.status)) {
      throw new Error(`${res.status} ${body.message ?? res.statusText}`); // fix the request
    }
    if (body.error === "REST_QUOTA_EXCEEDED") {
      throw new QuotaExceeded(`monthly quota of ${body.limit} requests used up`);
    }
    if (attempt >= maxAttempts) throw new Error(`${res.status} after ${attempt} attempts`);

    const hint = serverWaitMs(res, body);
    const delay = hint !== null
      ? hint + Math.random() * baseMs                            // honour the server
      : Math.random() * Math.min(capMs, baseMs * 2 ** attempt);  // full jitter
    console.warn(`${res.status} on ${path} (attempt ${attempt}), retrying in ${Math.round(delay)} ms`);
    await sleep(delay);
  }
}

const quote = await get("/forex/quote/EURUSD");
console.log(quote.symbol, quote.bid, quote.ask, quote.timestamp);

EURUSD 1.13725 1.13726 1790592934000

429 on /forex/quote/EURUSD (attempt 1), retrying in 394 ms
429 on /forex/quote/EURUSD (attempt 2), retrying in 1222 ms
503 on /forex/quote/EURUSD (attempt 3), retrying in 1529 ms
EURUSD 1.137233 1.137242 1790592920001

import os
import threading
import time

import requests

BASE_URL = "https://api.tickerlayer.com"
session = requests.Session()
session.headers["x-api-key"] = os.environ["TICKERLAYER_API_KEY"]


class Pacer:
    """Spaces requests evenly so a burst never exceeds the per-second budget."""

    def __init__(self, per_second, headroom=0.8):
        self.interval = 1.0 / (per_second * headroom)
        self.next_at = time.monotonic()
        self.lock = threading.Lock()

    def wait(self):
        with self.lock:
            now = time.monotonic()
            start = max(now, self.next_at)
            self.next_at = start + self.interval
        time.sleep(max(0.0, start - now))


first = session.get(f"{BASE_URL}/forex/quote/EURUSD", timeout=10)
first.raise_for_status()
limit = int(first.headers.get("X-RateLimit-Limit", "10"))
pacer = Pacer(limit)
print(f"limit {limit}/s, one request every {pacer.interval * 1000:.0f} ms")

for symbol in ["GBPUSD", "USDJPY", "AUDUSD"]:
    pacer.wait()
    resp = session.get(f"{BASE_URL}/forex/quote/{symbol}", timeout=10)
    resp.raise_for_status()
    quote = resp.json()
    print(symbol, quote["bid"], quote["ask"], "remaining:", resp.headers["X-RateLimit-Remaining"])

limit 10/s, one request every 125 ms
GBPUSD 1.325809 1.325879 remaining: 8
USDJPY 157.0403 157.0573 remaining: 7
AUDUSD 0.701173 0.701233 remaining: 6