LLM API Errors and Rate Limits Explained: 401, 403, 429 and 529 for OpenAI, Claude and Gemini (2026)

Below are the exact messages each provider returns, how their rate limits work, and a retry pattern we tested.

The same error, three providers

We sent requests with an invalid key to each provider on October 15, 2026:

Gemini signals a bad key with 400, not 401. Error handlers that only treat 401 as "auth failed" will misclassify it.

Error codes by status

429: rate limit or out of money?

The status code is the same, but the fix is the opposite.

OpenAI: read error.code.

OpenAI's docs are explicit: retrying billing, spend or quota errors won't restore access.

Anthropic: a normal rate-limit 429 usually carries a retry-after header. The monthly spend-cap 429 never does. It says your organization "has crossed its monthly API usage threshold" and keeps failing until the 1st of next month (UTC) or until you move up a tier. A sudden traffic spike can also trigger acceleration limits. Ramp up gradually.

Gemini: limits are enforced per project as RPM, TPM and RPD, plus spend-based limits over a rolling 10-minute window on paid tiers ($10 per 10 minutes on Tier 1, $50 on Tier 2, $200 on Tier 3). Exceeding them returns 429 RESOURCE_EXHAUSTED.

How each provider's rate limits work

The Claude caching detail is easy to miss and very useful. With a 2,000,000 input-tokens-per-minute limit and an 80% cache hit rate, Anthropic's docs show you can process about 10M total input tokens a minute, because cache reads don't count. Caching raises throughput as well as cutting cost (see Claude API pricing).

Retry the right way

First, use the SDK's built-in retries. The official OpenAI and Anthropic SDKs already retry connection errors, 429s and 5xx responses with exponential backoff, twice by default, and honor retry-after. Raising max_retries is often all you need:

from openai import OpenAI
client = OpenAI(max_retries=5)

If you need control (for example, to stop immediately on billing errors), here's a pattern we tested with openai 3.31.0:

import time
from openai import OpenAI, APIStatusError, APIConnectionError

client = OpenAI(max_retries=0)  # we handle retries ourselves

RETRY_STATUS = {429, 500, 502, 503, 504, 529}
# Quota and spend-limit errors also arrive as 429, but retrying won't fix them.
NO_RETRY_CODES = {"insufficient_quota", "credit_balance_exhausted",
                  "organization_spend_limit_exceeded", "project_spend_limit_exceeded"}

def create_with_retry(attempts=5, **kwargs):
    delay = 1.0
    for attempt in range(1, attempts + 1):
        try:
            return client.chat.completions.create(**kwargs)
        except APIStatusError as e:
            if e.status_code not in RETRY_STATUS or e.code in NO_RETRY_CODES or attempt == attempts:
                raise
            wait = float(e.response.headers.get("retry-after") or delay)
        except APIConnectionError:
            if attempt == attempts:
                raise
            wait = delay
        time.sleep(wait)
        delay = min(delay * 2, 30)

Running it with an invalid key raised the 401 immediately, without retrying. That's what you want: auth, permission and validation errors fail the same way every time. If many workers retry at once, add a little random jitter to wait so they don't all hit the API in the same second.

Errors through an API gateway

If you call models through a gateway or proxy, an error can come from the gateway (your gateway key, balance or model name) or be passed through from the upstream provider. The body usually tells you which. For example, api.foo, the gateway behind these docs, returns:

{"error":{"code":"","message":"Invalid token (request id: …)","type":"new_api_error"}}

type: new_api_error and the gateway's own request ID mean the gateway rejected the request before it reached any model provider. (api.foo shows the message in Chinese unless the request includes Accept-Language: en.) Messages without that wrapper usually came from the upstream provider.

Debugging checklist

1. Log the status code, the full error body and the request ID. OpenAI returns an x-request-id header, Anthropic includes request_id in the body, and most gateways include their own.
2. Check the base URL and path. A doubled /v1/v1 or a missing /v1 produces a 404.
3. Check the model ID against the provider's current list. Models get renamed and retired.
4. Check where you are calling from. A 403 "country not supported" is about location, not the key.
5. Check billing pages before retrying 429s, to make sure it's actually a rate limit.

Related

• OpenAI-compatible APIs explained
• How to get an OpenAI API key · How to get a Claude API key
• Claude API pricing