Claude Code rate limit reached: what to do right now

Which limit did you hit

Claude Code tells you exactly which ceiling you reached and when it resets. The wording matters more than it looks, because three of these four are unrelated mechanisms.

The 5-hour window is rolling, which people misread constantly. Capacity returns continuously as older usage ages past the five-hour mark rather than all at once at a round hour. The message gives you the point at which you are back in business, not the start of a fresh allowance.

The next five minutes

git add -A && git commit -m "wip: agent progress before usage limit"

/usage

/model sonnet

/usage-credits

Why usage climbs faster than your activity

People hit these limits after what feels like an hour of light work, then conclude the allowance shrank. It did not. A long-running session draws usage in ways that are invisible from the transcript.

• Every turn re-sends the whole conversation. A one-line question in a session that has been open all day still carries the entire history. Prompt caching makes that cheap, not free.
• Cache misses after a break reprocess everything. The cache lifetime is an hour on a subscription and drops to five minutes once you are drawing on usage credits, or on an API key. Lunch costs you a full re-read.
• Every tool result is another request. A thirty-step task is thirty requests, each carrying the growing prefix.
• Scheduled tasks fire while the session is idle, sending your full context each time.
• Agent teammates keep consuming until they exit. Agent teams use roughly 7x the tokens of a standard session when teammates run in plan mode.
• /compact is itself a large request, because it reads the conversation it summarises. /clear costs nothing.

Stopping it recurring

A 429 is not a usage limit

These two get filed under "rate limit" and neither is a plan allowance. Both resolve without you changing anything about how you work.

# fewer simultaneous tool calls per session
export CLAUDE_CODE_MAX_TOOL_USE_CONCURRENCY=2

# and check which credential is actually billing
# (inside a session)
/status

Claude reached its tool-use limit for this turn.

This one is not a limit on your account, and the wording invites the confusion. It caps how many tool calls Claude makes inside a single reply, and it stops the reply rather than your access. Nothing is exhausted, nothing resets, and there is no wait.

Claude reached its tool-use limit for this turn.

The ceiling is on Anthropic's side. When Claude runs server-executed tools such as web search, the sampling loop that drives them has an iteration limit, and the documented default is 10 iterations per request. On the API that arrives as stop_reason: "pause_turn", and the documented handling is to send the assistant content straight back so the model carries on from where it stopped. The apps do the same thing behind a button.

The reason the string started showing up in searches appears to be that the ceiling moved. The report that documented it describes Desktop runs that previously chained 60 to 80 tool calls in a turn now stopping at roughly 20, which is the difference between a run you leave alone and a run you sit with. Anthropic has not published the figure, so treat the numbers as one user's measurement rather than a specification.

• Click Continue. It picks up at the same point, in the same conversation, with the same context. Nothing is lost and nothing is re-done.
• Split the work into named steps and send them as separate turns. Three prompts of eight tool calls never touch a per-turn ceiling that one prompt of twenty-four does.
• Turn off connectors you are not using. Fewer available tools means fewer speculative lookups before Claude has what it needs.
• Name the file, repository, or document. A large share of a burned turn is spent finding the thing whose location you already knew.
• Calling the API yourself? Treat pause_turn as an ordinary continuation, and cap the number of continuations so a loop cannot run away.

messages = [{"role": "user", "content": prompt}]

for _ in range(5):                       # your own continuation cap
    response = client.messages.create(model=MODEL, messages=messages, tools=tools)
    if response.stop_reason != "pause_turn":
        break
    messages.append({"role": "assistant", "content": response.content})

API Error: 400 due to tool use concurrency issues.

Despite the name, this is not a throughput problem, and turning concurrency down is usually not the fix. A 400 means the API rejected the request as malformed before doing any work, and what it rejected is the shape of the conversation you sent.

API Error: 400 due to tool use concurrency issues. Run /rewind to recover the conversation.

Two unrelated causes produce that one string, and they want opposite responses. The tell is when it started.

The second is the one people describe as the conversation being permanently broken, and the mechanism explains why. The API enforces a strict message shape: every tool_use block must be answered by a tool_result carrying the same id, and two messages from the same role cannot sit next to each other. Claude Code resends the whole transcript on every turn, so a single malformed pair poisons every later request. It is not intermittent, it does not age out, and retrying is guaranteed to fail in exactly the same way.

• A turn interrupted while tool calls were still in flight, which leaves a tool_use with no matching result.
• Automatic compaction rebuilding the history. The reconstruction merges adjacent same-role messages, and it cannot merge a plain-string content field next to an array content field, so the merge is skipped and two same-role messages survive into the request.
• Dictated messages, which are the reported trigger for that merge. Voice input has been stored with content as a bare string while typed input is stored as an array of blocks.
• Compaction subagents inheriting the broken shape and failing in turn, which is why the failure can outlive the turn that caused it.

/model
/clear

/rewind

/clear

Questions people ask

Keep reading

Continue through Errors and fixes with Claude Code not working: a diagnostic order that finds it.