Anthropic Claude 429 Rate Limit Error: Causes and Fixes

Anthropic returns HTTP 429 with type: "rate_limit_error" when you exceed your account’s per-minute allowance. Claude meters three things separately — requests per minute (RPM), input tokens per minute (ITPM), and output tokens per minute (OTPM) — so you can be well under your request count and still get throttled on tokens. Almost every 429 is recoverable with backoff; the rest is a tier upgrade.

What this error means

{
"type": "error",
"error": {
  "type": "rate_limit_error",
  "message": "Number of request tokens has exceeded your per-minute rate limit."
}
}

The response carries headers that tell you exactly which ceiling you hit and when it resets:

429 vs 529 — don’t treat them the same

If you’re chasing 529s rather than 429s, use the dedicated Claude 529 Overloaded fix.

Common causes

• Bursty concurrency. A parallel fan-out or retry storm exceeds RPM in one window even when your average rate is fine.
• Token throughput, not request count. Long prompts (big context, documents, tool results) burn ITPM fast; large generations burn OTPM. Check which header hit zero.
• Low tier. New accounts start at Tier 1 with modest limits that rise as you spend and age.
• Shared key across workloads. One key for app + cron + dev means a batch job starves live traffic.

How to fix it

Exponential backoff that honors retry-after

The official SDKs retry 429/529 automatically (twice by default). Raise that, and add your own loop for control:

import anthropic, time, random

client = anthropic.Anthropic(max_retries=5)  # SDK retries 429/529 with backoff

def chat_with_backoff(messages, model="claude-sonnet-4-6", max_attempts=6):
  for attempt in range(max_attempts):
      try:
          return client.messages.create(model=model, max_tokens=1024, messages=messages)
      except anthropic.RateLimitError as e:
          if attempt == max_attempts - 1:
              raise
          retry_after = None
          if e.response is not None:
              retry_after = e.response.headers.get("retry-after")
          delay = float(retry_after) if retry_after else (2 ** attempt) + random.random()
          time.sleep(delay)

msg = chat_with_backoff([{"role": "user", "content": "Hello"}])
print(msg.content[0].text)

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({ maxRetries: 5 });
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

async function chatWithBackoff(messages, { model = "claude-sonnet-4-6", maxAttempts = 6 } = {}) {
for (let attempt = 0; attempt < maxAttempts; attempt++) {
  try {
    return await client.messages.create({ model, max_tokens: 1024, messages });
  } catch (err) {
    if (err?.status !== 429 || attempt === maxAttempts - 1) throw err;
    const retryAfter = Number(err?.headers?.["retry-after"]);
    const backoff = Number.isFinite(retryAfter)
      ? retryAfter * 1000
      : 2 ** attempt * 1000 + Math.random() * 1000;
    await sleep(backoff);
  }
}
}

const msg = await chatWithBackoff([{ role: "user", content: "Hello" }]);
console.log(msg.content[0].text);

Throttle proactively and watch the headers

Read anthropic-ratelimit-*-remaining on each response and slow down as any bucket nears zero — cheaper than absorbing 429s. For batch work, put requests behind a token bucket sized just under your tier’s RPM and token limits.

Tier up or cut token throughput

• Raise your tier by adding credits and accumulating spend — limits scale with tier. See the Anthropic Claude rate limits reference.
• Use the Message Batches API for non-realtime work — separate, higher throughput at a discount, off your live budget.
• Cut tokens with prompt caching for long, repeated prefixes (system prompts, few-shot, big context) so they don’t recount against ITPM every call.
• Route tolerant work to a smaller model (e.g. Haiku) with higher headroom.

How to prevent it

• Throttle every batch behind a limiter under your real ceilings.
• Adapt to the remaining-token headers instead of waiting for the 429.
• Cache repeated context to shrink ITPM.
• Separate keys per workload so bulk jobs can’t starve live traffic.

Related errors and providers

• Claude 529 Overloaded — the capacity-side sibling.
• OpenAI 429 rate limit and Gemini RESOURCE_EXHAUSTED — the same class on other providers.
• Sizing a move onto Claude? See OpenAI vs Anthropic pricing and the OpenAI → Anthropic migration guide.

What to do next

1. Honor retry-after and add capped backoff with jitter.
2. Read the anthropic-ratelimit-* headers to know whether requests, input, or output tokens hit zero.
3. Throttle batch work under your tier limits and cache repeated context.
4. Tier up or use the Batches API if you’re consistently at the ceiling.