Claude Code 429 Errors Still Burn Your Plan Quota

Q: How do I tell if I have orphan Claude Code processes burning my quota?

Run ps aux | grep -i claude on macOS or Linux, or Get-Process | Where-Object { $_.ProcessName -like '*claude*' } on Windows. Any process you did not explicitly start that is older than the current session is suspect. Kill it. If killing it resolves the 429 immediately, you have found one of the orphans documented in #22876.

Guides

Neural-LLM Admin 13 December 2025 9 min read

Claude Code 429 rate limit error burns plan quota despite available capacity

The dashboard says 6 percent of your weekly limit used. The session indicator says 72 percent. The API returns a 429 with a flat "rate limit exceeded" message. Every retry burns more of the quota that was already not the problem. Same account on claude.ai web works fine. Back in Claude Code: still 429. The bug is documented, the cost is real, and the routing logic that gets the work moving again is not what most users reach for first.

The bug, in numbers

GitHub issue #22876 documents the canonical reproduction. A developer on the Max plan submits requests until the session usage indicator climbs to roughly 70 percent. The dashboard at the same moment shows weekly limits at 6 percent used and Claude Code itself at 0 percent used. The next requests return 429s. The error body is the bare rate_limit_error shape with no detail on which limit was hit.

The interesting part is what works and what does not in that moment. The same account, opened in a browser to claude.ai, serves chat responses without error. Back in Claude Code through the API: 429. The two surfaces hit different rate-limit accounting, and the API surface is exhausted while the web surface is not.

The cost is real. The reporter documented roughly $40 of additional usage that piled up on the affected account during the investigation, plus a $20 new Pro subscription on a second account, plus a $100 Max upgrade on a third (pro-rated to $80). The suspected mechanism: an interaction with issue #22297's "infinite loop" agent dispatcher, which the reporter believed had spawned background Claude Code sessions that continued to count against the quota while returning errors visible only after the fact.

Anthropic has not, at time of writing, published a root-cause analysis. The community reports are consistent enough to treat as a class of bug rather than an isolated incident: the API-side rate-limit accounting can be exhausted while the dashboard insists otherwise.

Why 429 retries make it worse

The intuitive response to a 429 is "wait a bit and retry." Claude Code's built-in retry logic does roughly that — it honors the Retry-After header where present and re-issues the request after a backoff. The intuition fails when the 429 is the symptom and not the cause.

A failing 429 retry still costs:

Prompt cache eviction. If the original request was warmed in the cache, every retry that lands outside the TTL window re-builds the prompt. Each retry pays full price to set up a request that fails. The error response does not refund the prompt.
Plan-quota accounting. On consumer subscriptions, retries against the same endpoint can count toward the plan's request budget regardless of whether the response was a success. The plan was designed for live conversation, not for retry storms; the accounting was not built to distinguish "your code retried" from "you sent another message." The developer is paying for both.
Background processes. Claude Code can dispatch background subagents and tool calls that the user is not directly watching. A 429 on one of these does not always surface in the editor. The dispatcher retries. The retry fails. The dispatcher retries again. The user sees a stuck editor and does not see the retry storm running underneath until the dashboard catches up.

The pattern compounds. The reporter in #22876 had ps aux | grep claude revealing background processes they did not start themselves. Killing them stopped the bleed. Discovering them required knowing to look.

What developers try first

The community workarounds, in order of how often they appear:

claude logout followed by claude login. Clears cached OAuth credentials. This sometimes resolves phantom rate-limit states that were sitting in the local credential cache. When it works, it works immediately. When it does not, the user has now logged out of their session and lost in-flight state for nothing.
ps aux | grep claude to find orphaned processes. Surfaces background Claude Code sessions that started during a crash, subagent dispatch, or earlier session and were never reaped. kill the orphans. Watch the quota stabilize.
Wait for a reset cycle. The 5-hour rolling window and the 7-day weekly window both decay over time. Waiting long enough will return the account to a healthy state. The cost is the wait, plus the fact that during the wait the developer has nothing productive to do.
Switch to a different account. Manual switching by swapping ~/.claude/credentials.json files. Works for the rate-limit accounting, because the new account's headers are clean. Breaks the active session, including the TodoWrite list and the conversation history. This is the same workaround the multi-account threads converge on — and the friction is the same: a lossy, fragile manual swap.
File another issue. The reporter in #22876 did. The thread accumulates duplicate reports.

A second cluster of 429-related bugs deserves naming: issue #42947 reports the /batch command returning 429 "rate limited" on Max 20x plans. The mechanism differs but the surface is the same — the user pays the higher tier, the higher tier returns errors that consume plan quota, and the official guidance loops back to "wait and retry."

A Windows-specific variant has been reported under issue #51291, with the failure mode that 429s on the Windows client appear to count differently against the plan than on macOS or Linux. The reports are less voluminous, which means the class of users affected is smaller, but the cost on the affected platform is real.

Why account rotation handles this differently

The structural issue with all the manual workarounds is that they require the developer to notice. Notice that the 429 is the symptom of the burn. Notice the orphan process. Notice the quota draining while the dashboard says otherwise.

A rotation layer sitting between Claude Code and Anthropic does the noticing. It sees the 429 the moment it arrives. It checks the requesting account's projected remaining budget. If the budget is exhausted, it routes the next request to an account in the pool that has headroom. The original 429 does not get retried against the same account; it gets re-routed.

The detail that matters is the routing logic respecting the projected cost of the next request, not just the request-count. A retry to an account that has just enough headroom for a tiny request, when the next request is a heavy one, produces the same problem on the next account. A working rotator looks ahead: which account has the most remaining budget, accounting for the size of this turn? Route there.

Anti-ping-pong matters here. A naive rotator that round-robins between two accounts both near their caps will produce alternating 429s — first account, then the second, then back to the first as it cycles. A working rotator tracks each account's remaining budget independently and skips accounts that are projected to fail on the current turn. The next request goes to a fresh account or the session pauses with a clear message, not a phantom retry loop.

The retry storm goes away. The orphan-process burn goes away. The "dashboard says I'm fine but the API says I'm not" mismatch becomes irrelevant — the rotator's local accounting is faster than Anthropic's batched dashboard, and the local accounting drives the routing decisions. This is the noticing most people never wire up by hand, which is why we ship it as a one-line install — the work keeps moving on a fresh account instead of stalling on a burned one. It's free to download and try, no credit card needed.

What rotation does not fix

Account rotation does not bypass any rate limit on any individual account. It does not change what Anthropic bills per request. It does not address the underlying bug in #22876 — the API accounting and the dashboard accounting still diverge on the affected account. It does not stop a destructive command on a single account from running through to whatever damage it can do before the request resolves.

What rotation does is change the felt experience. Instead of "the 429 burns the quota and I cannot get unstuck," the experience becomes "the account that hit the bug is parked, the work continued on the next account, and the bug is now a forensic problem for later instead of a productivity blocker now." The bug still exists. The workaround stops being a manual scavenger hunt.

Frequently asked questions

Is the 429-burns-quota behavior an Anthropic-acknowledged bug?

Anthropic has not, at the time of writing, published a root-cause analysis or fix confirmation for the specific mismatch documented in #22876. The thread shows community-level investigation; Anthropic staff comments on the issue are present but do not commit to a fix timeline. Track the issue for updates.

Why does claude.ai web work when Claude Code is returning 429s on the same account?

The two surfaces hit different rate-limit accounting. The web product has its own limit class; the API surface that Claude Code uses has another. The accounts share an identity, but the rate-limit budgets the two surfaces see are not the same. A user can be exhausted on one and clean on the other for the same account.

Will retrying a 429 cost me money?

On the API directly: each retry that includes a non-cached prompt is billed at the relevant token rate, regardless of whether the response was a success. On consumer subscriptions: the plan-quota accounting can count retries against the request budget in some configurations. Either way, retrying a 429 with no diagnostic information is not free.

Should I just use `--dangerously-skip-permissions` to avoid the retry loop?

No. The skip-permissions flag is unrelated to the 429 behavior. The permission gate is separate from the rate-limit accounting. Skipping permissions does not make the rate limit go away and adds a much larger risk (destructive commands running unattended) on top.

How do I tell if I have orphan Claude Code processes burning my quota?

Run ps aux | grep -i claude on macOS or Linux, or Get-Process | Where-Object { $_.ProcessName -like '*claude*' } on Windows. Any process you did not explicitly start that is older than the current session is suspect. Kill it. If killing it resolves the 429 immediately, you have found one of the orphans documented in #22876.

What developers are reporting

The single most-reacted issue in the entire Claude Code repo is about exactly this: anthropics/claude-code #38335 (500+ reactions, 700+ comments) reports the 5-hour window "now hit within 1-2 hours instead of the usual full 5-hour window" on identical workloads. Pre-emptive, header-driven rotation is what turns that hard wall back into a smooth handoff.

Closing

A 429 that costs you both the request and the quota is the worst class of rate-limit bug, because every diagnostic move makes it slightly worse. The first-party fix is whatever Anthropic eventually ships on #22876. The structural fix is to stop relying on a single account being the only thing between the work and a wall. The rotation layer we ship is the version that took our own 429 retry storms off the table, and the version that turned "the API and the dashboard disagree" from a productivity blocker into a routing decision.

If you want to put it on a real session of your own, the 14-day Premium Trial is $0 today and you can cancel anytime before day 15 — it layers the watchdog and usage analytics on top of the rotation. Not ready to enter a card? Install Power Claude Free instead: the 7-day free trial gives you full Pro access, no credit card.

{{{_source.title}}} {{#_source.showPrice}} {{{_source.displayPrice}}} {{/_source.showPrice}}