OpenAI API 429 Rate Limit 재시도·백오프 설계

import asyncio
import random
import time
from typing import Optional

import httpx

RETRYABLE_STATUS = {429, 500, 502, 503, 504}


def parse_retry_after(headers: httpx.Headers) -> Optional[float]:
    ra = headers.get("Retry-After")
    if not ra:
        return None
    # Retry-After: seconds (most common)
    try:
        return float(ra)
    except ValueError:
        return None


def full_jitter_sleep(base: float, attempt: int, cap: float) -> float:
    # random(0, min(cap, base * 2^attempt))
    return random.uniform(0, min(cap, base * (2 ** attempt)))


async def call_openai_with_retry(
    client: httpx.AsyncClient,
    url: str,
    json_body: dict,
    *,
    max_attempts: int = 6,
    base_backoff: float = 0.5,
    cap_backoff: float = 20.0,
    deadline_sec: float = 60.0,
) -> dict:
    start = time.monotonic()
    last_exc = None

    for attempt in range(max_attempts):
        # deadline 체크
        if time.monotonic() - start > deadline_sec:
            raise TimeoutError("deadline exceeded") from last_exc

        try:
            resp = await client.post(url, json=json_body, timeout=30.0)
        except (httpx.ConnectError, httpx.ReadTimeout, httpx.RemoteProtocolError) as e:
            last_exc = e
            sleep = full_jitter_sleep(base_backoff, attempt, cap_backoff)
            await asyncio.sleep(sleep)
            continue

        if resp.status_code < 400:
            return resp.json()

        # 재시도 비대상 4xx는 즉시 실패
        if 400 <= resp.status_code < 500 and resp.status_code != 429:
            resp.raise_for_status()

        if resp.status_code in RETRYABLE_STATUS:
            ra = parse_retry_after(resp.headers)
            if ra is not None:
                # 서버 권장 대기 + 소량 지터(최대 20%)
                sleep = ra * random.uniform(1.0, 1.2)
            else:
                sleep = full_jitter_sleep(base_backoff, attempt, cap_backoff)
            await asyncio.sleep(sleep)
            continue

        # 그 외는 기본적으로 실패
        resp.raise_for_status()

    raise RuntimeError("max attempts exceeded") from last_exc


async def main():
    semaphore = asyncio.Semaphore(8)  # 동시성 제한

    async with httpx.AsyncClient(headers={
        "Authorization": f"Bearer {"YOUR_API_KEY"}",
        "Content-Type": "application/json",
    }) as client:

        async def guarded_call(payload: dict):
            async with semaphore:
                return await call_openai_with_retry(
                    client,
                    url="https://api.openai.com/v1/responses",
                    json_body=payload,
                )

        payload = {
            "model": "gpt-4.1-mini",
            "input": "Explain exponential backoff with jitter in one paragraph."
        }

        results = await asyncio.gather(*(guarded_call(payload) for _ in range(20)))
        print(results[0])


if __name__ == "__main__":
    asyncio.run(main())

import pRetry from "p-retry";

type FetchLike = typeof fetch;

function parseRetryAfter(headers: Headers): number | null {
  const ra = headers.get("retry-after");
  if (!ra) return null;
  const sec = Number(ra);
  return Number.isFinite(sec) ? sec : null;
}

function sleep(ms: number) {
  return new Promise((r) => setTimeout(r, ms));
}

async function postWithRetry(fetchFn: FetchLike, url: string, body: unknown) {
  const controller = new AbortController();
  const timeout = setTimeout(() => controller.abort(), 30_000);

  try {
    return await pRetry(
      async (attempt) => {
        const res = await fetchFn(url, {
          method: "POST",
          headers: {
            Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
            "Content-Type": "application/json",
          },
          body: JSON.stringify(body),
          signal: controller.signal,
        });

        if (res.ok) return await res.json();

        // 4xx 중 429가 아니면 즉시 실패
        if (res.status >= 400 && res.status < 500 && res.status !== 429) {
          throw new pRetry.AbortError(await res.text());
        }

        // 429/5xx는 재시도
        const retryAfter = parseRetryAfter(res.headers);
        if (retryAfter != null) {
          // 서버 권장 대기 + 0~200ms 지터
          await sleep(retryAfter * 1000 + Math.floor(Math.random() * 200));
        }

        throw new Error(`retryable status: ${res.status} (attempt ${attempt})`);
      },
      {
        retries: 5,
        factor: 2,
        minTimeout: 300,
        maxTimeout: 10_000,
        randomize: true, // 기본 지터(완전하진 않지만 없는 것보단 낫다)
      }
    );
  } finally {
    clearTimeout(timeout);
  }
}

(async () => {
  const result = await postWithRetry(fetch, "https://api.openai.com/v1/responses", {
    model: "gpt-4.1-mini",
    input: "Give me a checklist for handling 429 rate limits.",
  });
  console.log(result);
})();