OpenAI 429 Rate Limit 재시도·백오프 실전 가이드

// retry.js
function sleep(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

function parseRetryAfterMs(res) {
  const v = res.headers.get('retry-after');
  if (!v) return null;

  // retry-after: seconds or http-date
  const asNum = Number(v);
  if (!Number.isNaN(asNum)) return Math.max(0, asNum * 1000);

  const asDate = Date.parse(v);
  if (!Number.isNaN(asDate)) return Math.max(0, asDate - Date.now());

  return null;
}

function fullJitterDelayMs({ attempt, baseMs, capMs }) {
  const exp = Math.min(capMs, baseMs * (2 ** attempt));
  return Math.floor(Math.random() * exp);
}

export async function fetchWithRetry(url, options, config = {}) {
  const {
    maxAttempts = 6,
    baseMs = 300,
    capMs = 15000,
    retryOnStatuses = [429, 500, 502, 503, 504]
  } = config;

  let lastErr;

  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    try {
      const res = await fetch(url, options);

      if (!retryOnStatuses.includes(res.status)) {
        return res;
      }

      const retryAfter = parseRetryAfterMs(res);
      const delay = retryAfter ?? fullJitterDelayMs({ attempt, baseMs, capMs });

      // 응답 바디는 로깅용으로만 소량 읽고, 스트림은 재사용 불가에 유의
      const bodyText = await res.text().catch(() => '');

      lastErr = new Error(
        `retryable status=${res.status} attempt=${attempt + 1}/${maxAttempts} delayMs=${delay} body=${bodyText.slice(0, 300)}`
      );

      if (attempt === maxAttempts - 1) break;
      await sleep(delay);
      continue;
    } catch (e) {
      lastErr = e;
      const delay = fullJitterDelayMs({ attempt, baseMs, capMs });
      if (attempt === maxAttempts - 1) break;
      await sleep(delay);
    }
  }

  throw lastErr;
}

import { fetchWithRetry } from './retry.js';

export async function callOpenAI({ apiKey, payload }) {
  const res = await fetchWithRetry(
    'https://api.openai.com/v1/responses',
    {
      method: 'POST',
      headers: {
        'content-type': 'application/json',
        'authorization': `Bearer ${apiKey}`
      },
      body: JSON.stringify(payload)
    },
    { maxAttempts: 7, baseMs: 250, capMs: 20000 }
  );

  if (!res.ok) {
    const text = await res.text().catch(() => '');
    throw new Error(`openai error status=${res.status} body=${text}`);
  }

  return res.json();
}

import time
import random
import requests


def parse_retry_after_seconds(resp):
    v = resp.headers.get("retry-after")
    if not v:
        return None
    try:
        return max(0.0, float(v))
    except ValueError:
        return None


def full_jitter_delay(attempt, base=0.3, cap=15.0):
    exp = min(cap, base * (2 ** attempt))
    return random.random() * exp


def post_with_retry(url, headers, json_payload, max_attempts=6):
    last_exc = None

    for attempt in range(max_attempts):
        try:
            resp = requests.post(url, headers=headers, json=json_payload, timeout=60)

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

            ra = parse_retry_after_seconds(resp)
            delay = ra if ra is not None else full_jitter_delay(attempt)

            last_exc = RuntimeError(
                f"retryable status={resp.status_code} attempt={attempt+1}/{max_attempts} delay={delay:.2f} body={resp.text[:300]}"
            )

            if attempt == max_attempts - 1:
                break
            time.sleep(delay)

        except requests.RequestException as e:
            last_exc = e
            if attempt == max_attempts - 1:
                break
            time.sleep(full_jitter_delay(attempt))

    raise last_exc


def call_openai(api_key, payload):
    resp = post_with_retry(
        "https://api.openai.com/v1/responses",
        headers={
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json",
        },
        json_payload=payload,
        max_attempts=7,
    )

    if not resp.ok:
        raise RuntimeError(f"openai error status={resp.status_code} body={resp.text}")

    return resp.json()