A Claude Code stop can come from a subscription usage limit, a request or conversation that exceeds the model’s context capacity, or an API rate limit. Those are different checks. Start with the exact error and sign-in method; then compare the right reading in /status, /usage, or the API response instead of treating every “limit” message as a depleted plan allowance.
Claude Code usage limit: how to tell what stopped the request
Claude Code usage is not one interchangeable counter. If you signed in with a Claude plan, its included usage is shared with other Claude surfaces. If Claude Code is using an API key, requests are billed to the API account instead. A context ceiling and a request-rate limit are separate again. The message, meter, and authentication route have to agree before you pick a remedy.
Claude Code limit reached: identify the kind of stop first
Record the message exactly as shown. Keep its timestamp and time zone, the selected model, the sign-in method, and the output of the status command. Do not paraphrase “usage limit reached,” “rate limit reached,” and “prompt is too long” into the same error. They point to different layers.
| What you see | What it can tell you | Next check |
|---|---|---|
| A plan reset message | A plan allowance may be the enforced limit. The displayed reset is the relevant timing clue. | Confirm that the session is signed in to the intended plan; compare /status with the account’s Usage page. |
| A context or prompt-length message | The current request may not fit the model’s available context. This is not the same measurement as a plan’s usage allowance. | Preserve the exact error and inspect the current context; reduce or summarize the conversation only if the error identifies context size. |
| An API rate-limit response | An API request or spend constraint may be active. A subscription usage bar is not an API response header. | Keep the HTTP status, error type, endpoint, and any retry-after header together. |
| The error and meter disagree | The report does not establish which subsystem caused the block. | Capture a fresh meter reading and the full error from the same attempt; do not infer a reset or upgrade need from the mismatch. |
Claude Code limits: subscription usage is different from context length
For a Claude plan sign-in, the plan’s usage allowance applies across Claude and Claude Code. The current usage guidance states: Paid plans have two types of usage limits: a session limit that resets every five hours, and weekly limits that reset once every week.
It also states: Verified Ultra accounts don't have a five-hour limit.
Both quotations were checked in “How do usage and length limits work?” on November 6, 2026. Check the account’s displayed reset rather than calculating one from the time you opened the terminal.
A conversation-length or context limit answers a different question: how much material can fit in the current model request. Starting a new conversation can change that context, but it does not refill the account’s allowance. Conversely, a remaining usage bar does not prove that the current prompt fits the chosen model’s context.
Claude Code token limit: check the request’s context, not its plan meter
“Token limit” is often used loosely. A context ceiling applies to what the model can process in one request: the prompt, prior conversation, project material, and other context sent with it. A plan usage bar describes an account allowance over time. The two can move independently, so do not convert a context warning into a remaining-quota estimate.
If the exact response says the prompt is too long, preserve that text and identify the model and the current conversation state. A shorter prompt or a summarized conversation may address a context-size problem; it cannot be presented as restoring a subscription meter. If the response instead says a plan limit was reached, inspect the plan usage and reset display.
Claude Code rate limit: distinguish API throttling from plan quota
An API key changes the billing path: usage is charged to the Console or configured cloud provider rather than deducted from a Claude plan’s included allowance. The API documentation says: If you exceed any of the rate limits, you will get a 429 error describing which rate limit was exceeded.
It further states: When the response has a
A user-set spend limit is a separate case: retry-after header, wait that many seconds before retrying.When usage reaches a spend limit you set, requests return HTTP 400 with error type
These quotations were checked in “Rate limits” on November 6, 2026. Read the error body, not just the status code.invalid_request_error.
For a plan sign-in, a failed request to refresh the usage panel can itself be rate-limited. The Code documentation says the panel may label bars as last-known usage when it cannot fetch fresh data. That message means the reading could be stale; it does not by itself prove that your next coding request is blocked by the same limit.
Claude Code 5 hour limit: use the displayed session reset
When the plan session window is the issue, compare its current-session reading with the reset time displayed in the account. Remember that usage on Claude and Claude Code is shared for plan sign-ins. Do not assume that opening another terminal, changing a chat, or restarting the app starts a fresh plan allowance. The five-hour wording describes the plan window, not an API request-rate interval.
Claude Code quota: the sign-in route changes what “remaining” means
For a plan account, look at the plan usage bars and reset shown for that account. For API-key authentication, look at the response and the API account’s usage dashboard; token spend is not a subscription quota. An environment API key can take precedence over plan authentication, so a terminal session can use a different billing route from the account you expected. Check the active login method before interpreting any meter.
When “rate limited” appears beside a Claude Code usage reading
Two individual error reports show why the message and the visible meter should be kept as separate observations. In one, the reporter saw API Error: Rate limit reached while /status identified a Claude Max sign-in and still showed session capacity. The reporter said the plan was not recognized before a fresh login; afterward the plan appeared, but the same API error continued. The report also says API credits were tried as a workaround and quickly left the account in debt. That is one person’s account, not a normal charge estimate or a recommended fix.
In a different report, Claude Code returned Usage limit reached while the visible plan meters showed little use. Repeating the rejected prompt did not move those meters. No matching raw API response was supplied in that report, so its displayed message alone cannot identify the enforcing service.
| Reported signal | What the report records | What it does not establish |
|---|---|---|
API Error: Rate limit reached | Plan sign-in was later shown after re-login; the API error remained. The attempted credit workaround was reported as costly for that account. | It does not prove the plan meter caused the refusal or that credits will resolve another user’s issue. |
Usage limit reached | The visible meters appeared nearly unused; repeated rejected prompts left the displayed readings unchanged. | Without a raw response, it does not show whether the block was a plan limit, a request-size error, or another service-side condition. |
The labels are not interchangeable: one report names an API rate-limit error after the plan login was recognized; the other names a usage-limit error while the meter appeared low. This contrast does not prove either report’s root cause. It does show why copying a single remedy from one case to another is not supported by these observations.
Keep the two traces separate when reading them. In the first, the visible account state changed after re-login but the refusal did not. That makes “the CLI still shows the wrong plan” an incomplete explanation for that report; it does not prove that the request was billed to the plan or identify which credential the request actually used. The reporter’s description of a credit workaround ending in debt is a warning about that account’s experience, not a forecast for another user and not evidence that buying credits diagnoses a rate-limit response.
In the second trace, the message sounded like an exhausted allowance, but the meter looked nearly unused and stayed still as attempts were rejected. Without the underlying response, it is impossible to tell whether those attempts reached the same enforcement layer as the displayed plan meter. The page reading and the stop message are two separate observations; neither one validates the other.
That difference matters in practice. A rate-limit label plus a recognized plan is not the same evidence as a usage-limit label plus a low meter. Combining both into “Claude is secretly reducing everyone’s quota” would claim more than either report contains. Combining them into “the meter is definitely wrong” would do the same. The narrow supported conclusion is that these two user-reported traces disagree internally, and their root causes remain unresolved.
Keep one evidence row for each stopped request
| Field | Record this | Why the two reports make it useful |
|---|---|---|
| Sign-in label | What /status says the session is using; note whether an API-key environment variable is set, without copying its value. | A plan becoming visible after re-login did not, by itself, make the reported API error disappear. |
| Usage-panel freshness | Whether the bar is freshly fetched or marked as last-known. | A bar that did not move during rejected attempts is not a fresh server-side explanation unless its fetch succeeded. |
| Request refusal | The exact message, HTTP status and response fields that the client exposes. | The two reports used different error labels; the second supplied no raw response to resolve its label. |
| Attempt result | Whether the next permitted request succeeds and whether a fresh meter changes afterward. | This is the missing link between a visible allowance and a refusal; the reports do not provide a controlled comparison. |
Only compare values captured for the same attempt. If the usage panel says “last-known,” preserve that note and refresh the panel before treating the percentage as current. If the response remains unavailable, record “unknown” instead of choosing between a plan limit, a request-rate limit, and a context error. This evidence row is a way to make a report diagnosable; it does not promise a fix or infer how much quota remains.
The current Code usage guide describes a failed plan-limit refresh that can leave last-known bars on screen. That reading concerns meter retrieval; it does not, on its own, confirm that a separate coding request was blocked. No general cause for the two reports is established.
What to save before retrying
- Copy the full error text, including any HTTP status, error type, and response headers.
- Record whether Claude Code is using a Claude plan, Console API key, or a cloud-provider credential.
- Save
/statusfor plan state,/usagefor the current usage view, and/costwhen using API billing; keep the API account’s usage record with its response. - Keep the model and context-related error alongside the usage reading; do not compare readings from different attempts as if they were one measurement.
- If the limit is an API rate limit, follow the returned retry instruction when present. If the response is unclassified, stop the retry loop and retain it for diagnosis.
This evidence does not reveal a universal number of prompts remaining. It tells you which limit is being reported and which reading can actually confirm it.
For a retry decision after identifying an API response, see Claude usage limit retry-after. For account-level session and weekly usage, see Claude Pro usage limit. To compare usage pace without treating it as a quota forecast, see Claude usage limit pace check.