OpenAI 429 Rate Limit Exceeded: Causes, Fixes & Prevention

Rate limits by tier

OpenAI uses a five-tier system. Limits increase automatically as you spend more. The table below shows gpt-4o limits — gpt-4o-mini has higher TPM ceilings at each tier.

Source: platform.openai.com/docs/guides/rate-limits. Limits vary by model — verify yours at platform.openai.com/settings/organization/limits.

Step 1 — Read x-ratelimit headers

Every response from the OpenAI API includes six rate-limit headers. Read them before hitting the wall so you can slow down proactively:

x-ratelimit-limit-requests: 500
x-ratelimit-limit-tokens: 200000
x-ratelimit-remaining-requests: 12
x-ratelimit-remaining-tokens: 180423
x-ratelimit-reset-requests: 2026-07-17T12:00:05.123Z
x-ratelimit-reset-tokens: 2026-07-17T12:00:00.882Z

Access them from the raw HTTP response in Python and TypeScript:

# Python — read headers from the raw httpx response
from openai import OpenAI
import os

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

response = client.chat.completions.with_raw_response.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello"}],
)

remaining = int(response.headers.get("x-ratelimit-remaining-requests", 999))
reset_at   = response.headers.get("x-ratelimit-reset-requests", "")

print(f"Requests remaining this minute: {remaining}")
print(f"Resets at: {reset_at}")

completion = response.parse()
print(completion.choices[0].message.content)

// TypeScript — read headers via the APIResponse wrapper
import OpenAI from "openai";

const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

const response = await client.chat.completions
  .withResponse()
  .create({
    model: "gpt-4o",
    messages: [{ role: "user", content: "Hello" }],
  });

const remaining = response.response.headers.get("x-ratelimit-remaining-requests");
const resetAt   = response.response.headers.get("x-ratelimit-reset-requests");

console.log(`Remaining: ${remaining}, resets at: ${resetAt}`);
console.log(response.data.choices[0].message.content);

Step 2 — Implement exponential backoff

When you receive a 429, wait before retrying. Each retry doubles the wait with added random jitter to prevent thundering herd. OpenAI's Python SDK does not auto-retry 429s by default — you must add this yourself:

import time, random, os
from openai import OpenAI, RateLimitError

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

def chat_with_backoff(messages, model="gpt-4o", max_retries=5):
    for attempt in range(max_retries):
        try:
            return client.chat.completions.create(
                model=model,
                messages=messages,
            )
        except RateLimitError as e:
            if attempt == max_retries - 1:
                raise
            wait = (2 ** attempt) + random.random()
            print(f"429 rate limited. Retry {attempt + 1}/{max_retries} in {wait:.1f}s...")
            time.sleep(wait)

result = chat_with_backoff([{"role": "user", "content": "Hello"}])
print(result.choices[0].message.content)

# pip install tenacity
import os
from openai import OpenAI, RateLimitError
from tenacity import (
    retry,
    stop_after_attempt,
    wait_random_exponential,
    retry_if_exception_type,
)

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

@retry(
    retry=retry_if_exception_type(RateLimitError),
    wait=wait_random_exponential(min=1, max=60),
    stop=stop_after_attempt(6),
)
def chat(messages, model="gpt-4o"):
    return client.chat.completions.create(model=model, messages=messages)

result = chat([{"role": "user", "content": "Summarize this document..."}])
print(result.choices[0].message.content)

// npm install p-retry openai
import OpenAI from "openai";
import pRetry, { AbortError } from "p-retry";

const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

async function chat(messages: OpenAI.ChatCompletionMessageParam[]) {
  return pRetry(
    async () => {
      const res = await client.chat.completions.create({
        model: "gpt-4o",
        messages,
      });
      return res;
    },
    {
      retries: 5,
      minTimeout: 1000,
      maxTimeout: 60000,
      factor: 2,
      onFailedAttempt: (error) => {
        // only retry on 429; abort on 401/400
        if (error.status !== 429) throw new AbortError(error.message);
        console.log(`429 rate limit — attempt ${error.attemptNumber}, retrying...`);
      },
    }
  );
}

const result = await chat([{ role: "user", content: "Hello" }]);
console.log(result.choices[0].message.content);

Step 3 — Reduce token consumption

# Use gpt-4o-mini for high-volume tasks
response = client.chat.completions.create(
    model="gpt-4o-mini",   # was "gpt-4o"
    messages=[{"role": "user", "content": prompt}],
    max_tokens=256,         # cap output tokens
)

Step 4 — Upgrade your rate limit tier

Frequently asked questions

Monitor related services

Anthropic Claude API Google Gemini API Groq API Mistral API