Batas laju OpenAI API — batas mana yang terkena, cara membacanya, dan retry yang memperbaikinya

429 dari OpenAI berarti Anda telah melewati salah satu dari lima batas — dan tugas pertama adalah mencari tahu yang mana, karena perbaikannya mengarah ke solusi yang berlawanan. Halaman ini membahas apa yang diukur setiap batas, cara membaca jawabannya langsung dari header respons, logika percobaan ulang yang benar-benar menghentikan error, serta apa yang harus dilakukan ketika backoff yang tepat belum cukup.

Terverifikasi 30 September 2026 berdasarkan dokumentasi batas laju OpenAI.

Lima batas, dan salah satunya dapat terpicu

Batas mana pun yang habis lebih dahulu akan memicu error, jadi “kita masih jauh dari batas token” bukan alasan untuk mengesampingkan pembatasan laju — Anda mungkin masih jauh dari TPM tetapi tepat berada di batas RPM. Batas berlaku per organisasi dan per model, bukan per kunci: membuat kunci tambahan tidak membuat kuota tambahan.

Seperti apa 429

HTTP/1.1 429 Too Many Requests
retry-after: 12
x-ratelimit-limit-requests: 500
x-ratelimit-remaining-requests: 0
x-ratelimit-reset-requests: 12s
x-ratelimit-limit-tokens: 200000
x-ratelimit-remaining-tokens: 143820
x-ratelimit-reset-tokens: 17s

{
  "error": {
    "message": "Rate limit reached for gpt-5.4 in organization org-... on requests per min (RPM).",
    "type": "requests",
    "code": "rate_limit_exceeded"
  }
}

Semua yang Anda perlukan ada di respons tersebut. Isi respons menyebutkan dimensinya (“requests per min (RPM)”), sedangkan header memberi tahu batas persisnya, jumlah yang tersisa, dan kapan batas tersebut pulih.

Tier penggunaan

Batas Anda ditentukan oleh tier penggunaan, yang secara otomatis dinaikkan OpenAI seiring akumulasi pengeluaran kumulatif:

Sengaja tidak dicantumkan di sini: angka RPM dan TPM per model. Angka tersebut berbeda untuk setiap model, berubah ketika model baru dirilis, dan dapat disesuaikan per akun — jadi tabel apa pun yang dipublikasikan di halaman pihak ketiga hanyalah perkiraan yang berlaku pada tanggal tertentu. Dua sumber resmi untuk akun Anda sendiri adalah halaman batas di dashboard OpenAI dan header x-ratelimit-* pada setiap respons yang sudah Anda terima. Bacalah header tersebut.

Solusinya: patuhi Retry-After, lalu tambahkan jitter

Rekomendasi terdokumentasi OpenAI adalah exponential backoff dengan jitter, dengan mengikuti Retry-After jika respons menyertakannya. Kedua bagian ini penting. Tanpa header tersebut, Anda mungkin mencoba lagi terlalu cepat; tanpa jitter, setiap klien yang gagal pada saat yang sama akan mencoba lagi pada saat yang sama dan kembali gagal bersama-sama — thundering herd yang mengubah satu detik buruk menjadi satu menit buruk.

import random, time
import openai

client = openai.OpenAI()

def call_with_backoff(fn, *, max_attempts=6, base=0.5, cap=30.0):
    """Retry 429s: honour Retry-After when present, jittered backoff otherwise."""
    for attempt in range(max_attempts):
        try:
            return fn()
        except openai.RateLimitError as err:
            if attempt == max_attempts - 1:
                raise
            # The server's own answer beats any formula you invent.
            retry_after = (err.response.headers or {}).get("retry-after")
            if retry_after:
                delay = float(retry_after)
            else:
                # Full jitter: sleep a random point in [0, 2^n * base], capped.
                # Without the randomness every client that failed at the same
                # instant retries at the same instant and fails again together.
                delay = random.uniform(0, min(cap, base * 2**attempt))
            time.sleep(delay)

resp = call_with_backoff(lambda: client.responses.create(
    model="gpt-5.4",
    input="Summarise this changelog in three bullets.",
))

Bentuk yang sama dalam TypeScript:

import OpenAI from "openai";

const client = new OpenAI();
const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));

export async function callWithBackoff<T>(
  fn: () => Promise<T>,
  { maxAttempts = 6, baseMs = 500, capMs = 30_000 } = {},
): Promise<T> {
  for (let attempt = 0; ; attempt++) {
    try {
      return await fn();
    } catch (err) {
      const status = (err as { status?: number }).status;
      if (status !== 429 || attempt === maxAttempts - 1) throw err;

      const retryAfter = (err as { headers?: Headers }).headers?.get("retry-after");
      const delay = retryAfter
        ? Number(retryAfter) * 1000
        : Math.random() * Math.min(capMs, baseMs * 2 ** attempt);
      await sleep(delay);
    }
  }
}

const resp = await callWithBackoff(() =>
  client.responses.create({ model: "gpt-5.4", input: "Hello" }),
);

SDK resmi sudah mencoba ulang 429 untuk Anda, sehingga sebagian besar aplikasi hanya memerlukan ini ketika membungkus panggilan dalam klien HTTP sendiri, atau ketika menginginkan perilaku berbeda — batas yang lebih lama untuk pekerjaan latar belakang, atau kegagalan seketika untuk permintaan yang menghadap pengguna ketika menunggu 12 detik lebih buruk daripada menerima error.

Pantau sebelum bermasalah

Penghitung tersedia pada setiap respons, bukan hanya pada kegagalan. Mencatat nilai yang tersisa mengubah pembatasan laju dari insiden menjadi pengukur — Anda dapat melihat ruang tersisa menyusut beberapa hari sebelum peluncuran menghabiskannya.

# Log the remaining counters on every response, not just on failures.
# By the time you see a 429 the useful signal is already an hour old.
resp = client.responses.with_raw_response.create(model="gpt-5.4", input="…")
h = resp.headers

log.info(
    "openai_quota model=%s req_left=%s tok_left=%s reset_req=%s reset_tok=%s",
    "gpt-5.4",
    h.get("x-ratelimit-remaining-requests"),
    h.get("x-ratelimit-remaining-tokens"),
    h.get("x-ratelimit-reset-requests"),
    h.get("x-ratelimit-reset-tokens"),
)

parsed = resp.parse()   # the normal response object

Dua kebiasaan yang layak diterapkan bersamaan: beri peringatan ketika x-ratelimit-remaining-tokens turun di bawah fraksi tertentu dari batas, bukan berdasarkan jumlah 429, dan tambahkan jitter pada jadwal, bukan hanya pada percobaan ulang. Cron yang menjalankan semuanya pada :00 akan menciptakan burst-nya sendiri.

Ketika backoff bukan jawabannya

Backoff yang tepat memperbaiki burst. Backoff tidak melakukan apa pun untuk permintaan berkelanjutan yang melebihi batas Anda — dalam kondisi itu, percobaan ulang hanya menunda kegagalan. Perbaikan struktural, kira-kira berdasarkan tingkat usaha:

• Batasi output. Token penalaran ditagihkan dan dihitung sebagai output, sehingga generasi tanpa batas adalah cara tercepat menghabiskan TPM.
• Ringkas konteks hasil retrieval. Pada batas TPM, mengurangi separuh chunk yang diambil akan menggandakan throughput Anda tanpa biaya tambahan.
• Pilih model dengan ukuran yang tepat. Langkah klasifikasi tidak memerlukan model frontier, dan model kecil memiliki anggaran terpisahnya sendiri.
• Pisahkan beban kerja. Pekerjaan batch dan traffic sensitif-latensi yang bersaing untuk satu batas tingkat organisasi adalah bentuk masalah ini yang paling sering disebabkan oleh diri sendiri.
• Naikkan tier. Tier bergerak mengikuti pengeluaran kumulatif, jadi hal ini sering kali sudah berlangsung.

Menyebarkan beban di beberapa keluarga model

Item terakhir dalam daftar itulah tempat gateway menunjukkan manfaatnya. Kunavo menyediakan API yang kompatibel dengan OpenAI — SDK yang sama, bentuk panggilan yang sama, satu kunci — di beberapa keluarga model, sehingga memindahkan beban kerja dari batas yang jenuh cukup dengan mengubah string model, bukan melakukan integrasi kedua:

from openai import OpenAI

client = OpenAI(
    api_key="sk-kn-...",
    base_url="https://api.kunavo.com/v1",
)

# Same SDK, same call shape — the model string chooses the family.
client.chat.completions.create(
    model="gpt-5-6-terra",            # or claude-sonnet-5, claude-haiku-4-5, …
    messages=[{"role": "user", "content": "Hello"}],
)

Secara konkret: pekerjaan batch untuk meringkas yang sebelumnya bersaing dengan traffic produksi Anda dapat berjalan pada claude-haiku-4-5 dengan tarif $0,70 / $3,50 per 1M, sementara jalur sensitif-latensi tetap menggunakan gpt-5-6-terra ($0,70 / $4,20) atau claude-sonnet-5 ($1,40 / $7,00). Keluarga berbeda, antrean berbeda.

Perjelas apa yang dilakukan dan tidak dilakukan solusi ini. Solusi ini menghilangkan bottleneck satu akun-satu model dan menyediakan tempat untuk failover. Solusi ini tidak menciptakan kapasitas: jika volume total Anda benar-benar melebihi batas yang diizinkan tier mana pun, jawabannya tetap menaikkan tier atau mengurangi pekerjaan. Tarif untuk setiap model tersedia di halaman harga, dan panduan setara untuk batas Anthropic ada di Claude API 429 rate_limit_error.

Pertanyaan umum