AI API 레이트 리밋 대응 — 큐·지수 백오프·비용 상한 설계

AI API를 프로덕션에 연결하는 순간 반드시 마주치는 문제가 레이트 리밋(rate limit)입니다. 모델이 느려서가 아니라, 분당 요청 수(RPM)나 분당 토큰 수(TPM) 한도를 초과해 HTTP 429 응답을 받고 서비스가 멈추는 상황입니다. 이 글에서는 Anthropic·OpenAI·Gemini 세 제공사의 제한 구조를 비교하고, 지수 백오프 재시도·토큰 버킷 알고리즘·요청 큐 설계·비용 상한·API 키 로테이션까지 레이트 리밋을 실무에서 안정적으로 다루는 방법을 코드와 함께 정리합니다.

레이트 리밋의 기본 구조 — TPM·RPM·TPRD

AI API의 레이트 리밋은 단일 수치가 아니라 여러 차원이 동시에 적용됩니다. 제공사마다 표현이 조금씩 다르지만, 핵심 축은 세 가지입니다.

RPM(Requests Per Minute)은 1분에 보낼 수 있는 API 호출 횟수 제한입니다. 요청 크기와 무관하게 “몇 번 두드렸는가”만 셉니다. 개별 요청이 매우 작더라도 RPM을 초과하면 429가 납니다. TPM(Tokens Per Minute)은 1분에 소비할 수 있는 토큰의 총량입니다. 입력 토큰과 출력 토큰을 합산해 계산하며, 긴 컨텍스트를 자주 보내는 서비스라면 RPM보다 TPM이 먼저 한계에 닿습니다. TPRD(Tokens Per Day)는 하루 누적 토큰 소비량에 대한 상한으로, 무료 티어나 하위 티어에서 주로 적용됩니다.

중요한 점은 이 세 제한이 독립적으로 존재하며, 하나라도 초과하면 429가 발생한다는 것입니다. 트래픽이 낮은 시간대에 RPM은 여유롭더라도 긴 문서 처리를 몰아서 하면 TPM이 먼저 터질 수 있습니다. 실제 병목이 어느 축인지를 먼저 파악해야 대응 전략이 달라집니다.

주요 제공사별 레이트 리밋 비교

아래 표는 작성 시점의 공식 문서 기준 대표 수치입니다. 제공사마다 결제액이나 사용량에 따라 티어가 나뉘며, 상위 티어일수록 한도가 높아집니다. 정확한 최신 수치는 각 제공사의 공식 문서에서 반드시 확인하세요.

제공사주요 제한 축429 응답 헤더재시도 권장 대기한도 상향 방법
AnthropicRPM / TPM / TPRD (티어별 상이)anthropic-ratelimit-* 헤더군으로 남은 요청·토큰·리셋 시간 제공retry-after 헤더 값 사용결제 누적 후 자동 티어 승급, 또는 영업 문의
OpenAIRPM / TPM / RPD (모델·티어별)x-ratelimit-limit-*, x-ratelimit-remaining-*, x-ratelimit-reset-*retry-after 또는 리셋 헤더 기반결제 등록 후 사용량 누적 시 자동 승급
Google GeminiQPM(Queries Per Minute) / TPMRetry-After, X-RateLimit-* (일부 엔드포인트)지수 백오프 권장, 최소 1초Google Cloud 할당량 페이지에서 증가 요청

세 제공사 모두 429 응답에 재시도 대기 시간을 헤더로 안내합니다. Anthropic은 anthropic-ratelimit-requests-reset처럼 각 제한 축별로 세분화된 헤더를 제공해 어떤 제한에 걸렸는지 정확히 파악할 수 있습니다. 이 헤더를 읽지 않고 고정 대기 시간으로 재시도하면 불필요하게 오래 기다리거나, 너무 일찍 재시도해 429를 계속 받는 상황이 생깁니다.

429를 무시하고 즉시 재시도하면 상황이 더 악화됩니다.

429를 받자마자 다시 요청을 보내면 제한이 풀리지 않은 상태에서 요청만 쌓입니다. 제공사 서버 입장에서는 불량 클라이언트로 분류될 수 있고, 일시적으로 더 강한 제한이 걸릴 수 있습니다. 반드시 대기 후 재시도하세요.

지수 백오프 재시도 패턴

레이트 리밋(429)이나 일시적 서버 오류(500, 502, 503)에 대응하는 표준 패턴은 지수 백오프(exponential backoff)입니다. 재시도할 때마다 대기 시간을 지수적으로 늘리고, 여기에 작은 무작위 지터(jitter)를 더해 여러 클라이언트가 동시에 재시도해 다시 폭발하는 thundering herd 현상을 방지합니다.

// 지수 백오프 + 풀 지터 재시도 (TypeScript 개념 예시)
interface RetryOptions {
  maxAttempts: number;   // 최대 시도 횟수
  baseDelayMs: number;   // 첫 대기 시간 (ms)
  maxDelayMs: number;    // 최대 대기 시간 상한 (ms)
  retryOn: number[];     // 재시도할 HTTP 상태 코드
}

async function withRetry<T>(
  fn: () => Promise<T>,
  opts: RetryOptions
): Promise<T> {
  let attempt = 0;

  while (true) {
    try {
      return await fn();
    } catch (err: any) {
      attempt++;
      const status = err?.status ?? err?.response?.status;

      // 재시도 대상이 아닌 오류는 즉시 던짐
      if (!opts.retryOn.includes(status) || attempt >= opts.maxAttempts) {
        throw err;
      }

      // retry-after 헤더가 있으면 우선 사용
      const retryAfterSec = parseFloat(err?.headers?.['retry-after'] ?? '0');
      const retryAfterMs = retryAfterSec > 0
        ? retryAfterSec * 1000
        : Math.min(opts.baseDelayMs * 2 ** (attempt - 1), opts.maxDelayMs);

      // 풀 지터: 0 ~ retryAfterMs 사이 무작위 값
      const jitter = Math.random() * retryAfterMs;

      console.warn(`재시도 ${attempt}/${opts.maxAttempts} — ${Math.round(jitter)}ms 후`);
      await new Promise(res => setTimeout(res, jitter));
    }
  }
}

// 사용 예
const result = await withRetry(
  () => anthropic.messages.create({ /* ... */ }),
  { maxAttempts: 5, baseDelayMs: 1000, maxDelayMs: 60_000, retryOn: [429, 500, 502, 503] }
);

대기 시간 계산에서 풀 지터(full jitter) 방식이란 계산된 최대 대기 시간을 상한으로 삼아 0부터 그 사이에서 완전 무작위로 대기 시간을 뽑는 것입니다. AWS의 레이트 리밋 재시도 연구(Exponential Backoff And Jitter, 2015)에서 풀 지터가 평균 대기 시간과 서버 부하 분산 모두에서 가장 효과적임을 보여준 이후 업계 표준으로 자리 잡았습니다. 지수 증가만 쓰고 지터를 안 붙이면, 429를 동시에 받은 여러 인스턴스가 정확히 같은 시점에 다시 요청을 보내 다시 429를 받는 패턴이 반복됩니다.

토큰 버킷 알고리즘 — 클라이언트 사이드 제한

지수 백오프는 이미 429를 받은 이후의 사후 대응입니다. 더 나은 전략은 API에 요청을 보내기 전에 클라이언트 쪽에서 미리 속도를 제한해 429 자체가 나오지 않도록 하는 것입니다. 이때 사용하는 알고리즘이 토큰 버킷(token bucket)입니다.

토큰 버킷은 “버킷에 일정 속도로 토큰이 채워지고, 요청을 보낼 때 토큰을 소모한다”는 개념입니다. 버킷이 비어 있으면 요청은 토큰이 쌓일 때까지 대기합니다. 버킷 용량(burst capacity)이 있어 갑작스러운 트래픽 폭발을 일정 범위까지 허용합니다.

// 토큰 버킷 구현 (TypeScript 개념 예시)
class TokenBucket {
  private tokens: number;
  private lastRefill: number;

  constructor(
    private readonly capacity: number,     // 최대 버킷 용량
    private readonly refillRate: number,   // 초당 채워지는 토큰 수
  ) {
    this.tokens = capacity;
    this.lastRefill = Date.now();
  }

  private refill(): void {
    const now = Date.now();
    const elapsed = (now - this.lastRefill) / 1000;   // 경과 시간(초)
    this.tokens = Math.min(
      this.capacity,
      this.tokens + elapsed * this.refillRate
    );
    this.lastRefill = now;
  }

  async acquire(cost = 1): Promise<void> {
    while (true) {
      this.refill();
      if (this.tokens >= cost) {
        this.tokens -= cost;
        return;
      }
      // 부족한 토큰이 채워질 때까지 대기
      const waitMs = ((cost - this.tokens) / this.refillRate) * 1000;
      await new Promise(res => setTimeout(res, waitMs));
    }
  }
}

// RPM 60, 버스트 10 허용하는 버킷 (분당 60 = 초당 1)
const rpmBucket = new TokenBucket(10, 1);

// TPM 제한을 위한 토큰 버킷 (토큰 수 기반 차감)
const tpmBucket = new TokenBucket(100_000, 100_000 / 60);

async function callAPI(inputTokenEstimate: number) {
  await rpmBucket.acquire(1);                     // 요청 1건 소모
  await tpmBucket.acquire(inputTokenEstimate);    // 예상 토큰 소모
  return anthropic.messages.create({ /* ... */ });
}

토큰 버킷을 TPM 제한에 적용할 때는 실제 토큰 수를 사전에 정확히 알기 어렵다는 문제가 있습니다. 실무에서는 tiktoken(OpenAI용) 같은 토크나이저로 요청 전에 추정하거나, 평균 토큰 소비량에 여유 계수(예: 1.2~1.5배)를 곱한 값을 사용합니다. 정확성보다는 “충분히 안전한 쪽으로” 추정하는 것이 중요합니다.

요청 큐 설계

토큰 버킷이 속도를 조절한다면, 요청 큐는 레이트 리밋 상황에서 요청을 버리지 않고 순서대로 소화하기 위한 구조입니다. 큐에는 세 가지 핵심 설계 결정이 있습니다.

첫째, 큐 크기와 오버플로우 정책입니다. 큐가 무한히 크면 메모리가 고갈됩니다. 최대 크기를 정하고, 초과 시 새 요청을 거부(fail-fast)할지, 가장 오래된 요청을 버릴지(oldest-drop), 우선순위가 낮은 것을 버릴지 결정해야 합니다. 사용자 인터랙티브 요청은 배치 작업보다 우선순위가 높아야 하므로 우선순위 큐를 쓰는 경우가 많습니다.

둘째, 동시 실행 제한(concurrency limit)입니다. 큐에서 꺼낸 요청을 동시에 몇 개까지 실행할지를 정합니다. RPM 제한이 60이라면 동시 실행을 1개로 제한하고 초당 1개씩 꺼내는 것이 가장 안전하지만, 실제로는 각 요청의 처리 시간이 제각각이므로 세마포어(semaphore)로 동시 실행 수를 제한하는 방식이 유연합니다.

셋째, 요청 TTL(만료 시간)입니다. 큐에 너무 오래 쌓인 요청은 클라이언트가 이미 응답을 기다리지 않을 가능성이 높습니다. 각 요청에 만료 시간을 설정해, 큐에서 꺼낼 때 이미 만료된 요청은 실행하지 않고 버려야 합니다.

// 동시 실행 제한 세마포어 (TypeScript 개념 예시)
class Semaphore {
  private queue: Array<() => void> = [];
  private running = 0;

  constructor(private readonly limit: number) {}

  async acquire(): Promise<() => void> {
    if (this.running < this.limit) {
      this.running++;
      return this.release.bind(this);
    }
    // 자리가 날 때까지 대기
    return new Promise<() => void>(resolve => {
      this.queue.push(() => {
        this.running++;
        resolve(this.release.bind(this));
      });
    });
  }

  private release(): void {
    this.running--;
    const next = this.queue.shift();
    if (next) next();
  }
}

const sem = new Semaphore(5);   // 최대 5개 동시 실행

async function rateLimitedCall(fn: () => Promise<unknown>) {
  const release = await sem.acquire();
  try {
    return await fn();
  } finally {
    release();
  }
}

비용 상한 설정

레이트 리밋을 잘 처리해도, 예상치 못한 대량 요청이나 코드 버그로 API 호출이 폭발하면 비용 청구가 크게 늘 수 있습니다. 비용 상한(spending limit, budget cap)은 이를 사전에 차단하는 안전망입니다.

방법설명적용 층위
제공사 콘솔 월 예산 상한Anthropic·OpenAI 콘솔에서 월별 최대 지출 금액 설정. 초과 시 API 차단계정 수준
애플리케이션 레벨 토큰 카운터Redis 등에 일/월 누적 토큰을 집계. 상한 초과 시 요청 거부서비스 수준
사용자별 할당량사용자 ID별 일별·월별 토큰 사용량 추적. 무료/유료 플랜 구분에 활용사용자 수준
max_tokens 강제 설정API 호출 시 max_tokens를 필요 이상으로 높게 두지 않아 출력 토큰 낭비 방지요청 수준

가장 중요한 것은 제공사 콘솔에서 제공하는 월 예산 상한을 반드시 설정하는 것입니다. 이 설정이 없으면 버그나 악의적인 사용자로 인해 수백만 원의 비용이 순식간에 발생할 수 있습니다. 애플리케이션 레벨 카운터는 더 세밀한 제어가 가능하지만 제공사 콘솔 설정을 대체하지는 않습니다. 두 층위를 모두 사용하는 것이 안전합니다.

// Redis 기반 일별 토큰 예산 추적 (개념 예시)
async function checkBudget(userId: string, estimatedTokens: number): Promise<void> {
  const key = `budget:${userId}:${new Date().toISOString().slice(0, 10)}`;  // YYYY-MM-DD
  const DAILY_LIMIT = 100_000;   // 사용자당 하루 10만 토큰

  const current = await redis.incrby(key, estimatedTokens);
  if (current === estimatedTokens) {
    // 첫 사용이면 만료 시간 설정 (자정까지)
    await redis.expireat(key, tomorrowMidnight());
  }

  if (current > DAILY_LIMIT) {
    // 초과분 되돌리기
    await redis.decrby(key, estimatedTokens);
    throw new Error(`일일 사용량 한도(${DAILY_LIMIT} 토큰) 초과`);
  }
}

// 실제 사용 토큰으로 정산 (응답 후)
async function settleBudget(userId: string, estimated: number, actual: number) {
  const diff = actual - estimated;
  if (diff !== 0) {
    const key = `budget:${userId}:${new Date().toISOString().slice(0, 10)}`;
    await redis.incrby(key, diff);
  }
}

다중 API 키 로테이션

단일 API 키로는 계정 레벨의 레이트 리밋을 넘을 수 없습니다. 트래픽이 한 키의 TPM·RPM 한도를 넘는 서비스라면 여러 키를 병렬로 사용하는 키 로테이션 전략을 씁니다. 다만 이 방식에는 주의사항이 있습니다.

  • 제공사 이용 약관을 확인하세요. 일부 제공사는 레이트 리밋 우회 목적의 다중 계정 생성을 금지합니다. 한도 상향 요청이 먼저입니다.
  • 키마다 독립된 토큰 버킷을 유지하고, 각 키의 429 상태를 추적해 일시적으로 제외했다가 복구하는 서킷 브레이커 패턴을 적용하세요.
  • 키 로테이션은 라운드 로빈보다 “남은 한도가 가장 많은 키”를 선택하는 greedy 방식이 레이트 리밋 발생 확률을 낮춥니다.
  • API 키는 환경 변수나 시크릿 관리 서비스(AWS Secrets Manager, Vault 등)에 보관하고 코드에 하드코딩하지 마세요.
// 다중 API 키 로테이터 (개념 예시)
class ApiKeyRotator {
  private cooldowns = new Map<string, number>();   // key → 재사용 가능한 시각(ms)

  constructor(private readonly keys: string[]) {}

  getAvailableKey(): string | null {
    const now = Date.now();
    // 쿨다운이 지난 키 중 하나 반환
    for (const key of this.keys) {
      const ready = this.cooldowns.get(key) ?? 0;
      if (now >= ready) return key;
    }
    return null;   // 모든 키가 쿨다운 중
  }

  markRateLimited(key: string, retryAfterMs: number): void {
    this.cooldowns.set(key, Date.now() + retryAfterMs);
  }
}

const rotator = new ApiKeyRotator(
  process.env.API_KEYS!.split(',').map(k => k.trim())
);

async function callWithRotation(payload: object) {
  for (let attempt = 0; attempt < rotator['keys'].length; attempt++) {
    const key = rotator.getAvailableKey();
    if (!key) {
      await new Promise(r => setTimeout(r, 1000));
      continue;
    }
    try {
      return await anthropic.messages.create({ /* ...payload, apiKey: key */ });
    } catch (err: any) {
      if (err?.status === 429) {
        const retryAfter = parseFloat(err.headers?.['retry-after'] ?? '5') * 1000;
        rotator.markRateLimited(key, retryAfter);
      } else {
        throw err;
      }
    }
  }
  throw new Error('사용 가능한 API 키 없음');
}

모니터링 지표

레이트 리밋 대응은 구현만으로 끝나지 않습니다. 실제 운영에서 어떤 제한에 얼마나 자주 걸리는지, 재시도가 성공하는지, 큐 대기 시간이 사용자 경험에 영향을 주는지를 지속적으로 측정해야 합니다.

지표설명임계값 예시
429 발생률 (429_rate)전체 API 호출 대비 429 응답 비율1% 이상이면 경보
재시도 성공률 (retry_success_rate)429 이후 재시도 중 성공한 비율95% 미만이면 백오프 전략 재검토
평균 큐 대기 시간 (queue_wait_ms)요청이 큐에 진입한 후 실행까지의 시간p95 > 5초면 동시 실행 한도 조정 검토
토큰 사용률 (tpm_utilization)분당 TPM 한도 대비 실제 사용 비율80% 이상 지속되면 한도 상향 요청
일일 비용 누적 (daily_spend)당일 누적 API 비용예산의 80% 도달 시 알림
요청 오류율 (error_rate)429 외 5xx 오류 비율0.5% 이상이면 모델 상태 확인

모니터링 데이터는 단순히 보는 것에 그치지 않고 자동화 트리거로 연결해야 효과적입니다. 429 발생률이 임계값을 넘으면 Slack 알림을 보내거나, 토큰 사용률이 80%에 가까우면 배치 작업을 자동으로 지연시키는 식입니다. Prometheus + Grafana나 Datadog 같은 관측 도구와 API 응답 헤더 파싱을 연결하면 대부분의 지표를 자동으로 수집할 수 있습니다.

특히 API 응답 헤더에서 남은 한도 정보를 파싱해 기록하는 것이 중요합니다. Anthropic은 anthropic-ratelimit-requests-remaining, anthropic-ratelimit-tokens-remaining 같은 헤더로 현재 윈도우의 잔여 한도를 알려줍니다. 이 수치가 특정 값 이하로 떨어지면 즉시 요청 속도를 줄이는 예방적 스로틀링(proactive throttling)을 구현할 수 있습니다.

자주 묻는 질문

429와 503 오류는 어떻게 구분해야 하나요?
429는 클라이언트가 너무 많은 요청을 보낸 것(레이트 리밋 초과)이고, 503은 서버가 일시적으로 처리를 못 하는 것(서비스 불가)입니다. 429는 반드시 대기 후 재시도하고, 503은 지수 백오프로 재시도하면 됩니다. 실무에서는 둘 다 재시도 대상 목록에 넣되, 429는 retry-after 헤더를 우선 사용하고 503은 일반 백오프 계산을 적용합니다.
스트리밍 요청이 도중에 429를 받으면 어떻게 처리하나요?
스트리밍 도중 429가 발생하면 이미 받은 텍스트는 유실될 수 있습니다. 이미 받은 delta를 누적 저장해 두었다가, 재시도 시 지금까지 생성된 내용을 어시스턴트 메시지로 컨텍스트에 넣고 이어 생성하는 방식이 가장 매끄럽습니다. 단, 생성 중간에 연결이 끊긴 지점을 정확히 표시하기 어려우므로, 사용자에게 중단 사실을 알리고 “이어 생성” 버튼을 제공하는 UX가 현실적입니다.
무료 티어에서 빠르게 한도를 높이는 방법이 있나요?
Anthropic과 OpenAI 모두 결제 수단을 등록하고 일정 금액 이상을 사용하면 자동으로 상위 티어로 승급됩니다. 티어 기준은 공식 문서에 공개되어 있습니다. 그보다 높은 한도가 필요하다면 제공사 영업팀이나 엔터프라이즈 창구를 통해 직접 협의합니다. Google Gemini는 Google Cloud Console의 할당량(Quota) 페이지에서 증가 요청을 직접 제출할 수 있습니다.
여러 사용자의 요청을 하나의 큐로 합치면 공정성 문제가 생기지 않나요?
공정성(fairness)은 큐 설계에서 중요한 문제입니다. 한 사용자가 큰 요청을 여럿 넣으면 다른 사용자의 요청이 오래 기다리게 됩니다. 이를 해결하려면 사용자별 가중 공정 큐잉(weighted fair queuing)이나 최소 잔여 시간 우선(SFQ) 알고리즘을 사용합니다. 단순한 구현으로는 사용자별로 독립적인 서브 큐를 만들고 라운드 로빈으로 꺼내는 방식이 있습니다.
배치 작업과 실시간 요청이 같은 키를 공유할 때 우선순위를 어떻게 줘야 하나요?
우선순위 큐와 함께 별도의 TPM 할당량을 미리 분리하는 방식이 권장됩니다. 예를 들어 전체 TPM 한도의 70%는 실시간 요청 전용으로 예약하고, 30%는 배치 작업에 할당합니다. 실시간 요청이 없는 시간대에는 배치가 더 많이 쓸 수 있도록 예약 대역을 동적으로 조정하면 효율이 높아집니다. 배치 작업은 Anthropic의 Message Batches API처럼 비동기 배치 엔드포인트를 제공하는 경우 이를 활용하면 실시간 한도에 영향을 주지 않습니다.

TPM·RPM 한도와 429 응답 헤더 형식은 2026년 기준이며 정책에 따라 수시로 바뀌므로, 실제 적용 전 Anthropic 공식 문서의 레이트 리밋 항목에서 최신 값을 확인하세요.

이 글은 Anthropic·OpenAI·Google의 레이트 리밋 공식 문서, RFC 7231 HTTP 상태 코드 명세, 토큰 버킷 알고리즘 관련 문헌을 바탕으로 작성되었습니다. TPM·RPM 수치 등 구체적인 한도는 제공사 정책에 따라 수시로 변경되므로, 실제 적용 전에는 각 제공사의 최신 공식 문서를 확인하시기 바랍니다.

위로 스크롤