Claude Code usage limits: how plans, resets and API billing work

Claude Code usage limits on Pro and Max plans work in two layers: a session limit that resets every five hours and a weekly limit on top, both shared with your use of the Claude apps. This guide explains how each plan compares, how to check where you stand, what happens when you run out, when API billing makes more sense, and how to stretch your limits.

How do Claude Code usage limits work?

Claude Code usage limits on a subscription have two layers: a session limit on a rolling five-hour window, and a weekly limit on top. When either runs out, Claude Code stops sending new requests until the window resets or you add usage credits.

According to Anthropic's article on using Claude Code with a Pro, Max or Ultra plan, three rules shape your day:

• Shared pool: limits are shared across Claude and Claude Code. Chatting in the Claude app, on desktop or on mobile uses the same allowance your coding agent needs.
• Two clocks: the five-hour session limit protects against bursts, and the weekly limit caps total use. You can have plenty of session left and still be blocked by the weekly cap. On the Ultra plan, verified accounts have no five-hour limit, only the weekly one.
• Fable has its own budget on Max and Ultra: both plans have a separate weekly limit for the Fable models, listed on the pricing page as 50% of weekly limits.

Limits are measured in usage, not messages. A one-line question in a fresh session costs little; the same question in a session that has read fifty files and run the test suite ten times costs much more, because the whole conversation travels with every request.

How much Claude Code usage does each plan include?

Anthropic publishes limits as multipliers, not fixed numbers. The table below summarizes the official Claude pricing page at the time of writing (October 2026). Prices exclude tax.

The help article suggests moving from Pro to Max, or from Max to Ultra, if you consistently hit limits. In practice, the plan that fits depends less on how many hours you code and more on how you work: one focused session at a time on Sonnet goes a long way on Pro, while several parallel agents on Opus can exhaust Max in an afternoon.

How do I check my Claude Code usage?

Run /usage inside Claude Code. On a Pro, Max, Team or Enterprise plan it shows your plan usage bars, activity stats, and a breakdown of what is consuming your limits.

The costs documentation describes what the breakdown includes:

• Attribution: recent usage split by skills, subagents, plugins and individual MCP servers, each as a percentage.
• Recommendations: one row per change that would cut usage, such as Trim ~/code/api/CLAUDE.md · 49k tokens per request or Switch from max to high effort · /effort high.
• Loops: the heaviest recurring /loop tasks, with how often they fire and how many tokens each run uses.

Press d or w to switch between the last 24 hours and the last 7 days. When the footer shows a hint like f to fix 2 of 3, pressing f has Claude Code apply the recommendations it can (this needs a recent version). The breakdown comes from session history on this machine, so usage from claude.ai or other computers is not included.

Two other tools help while you work:

• /context shows what is filling the context window right now: system prompt, CLAUDE.md, MCP tools, conversation.
• A status line can display context usage continuously, so you notice a bloated session before it costs you.

What happens when you hit the limit?

You have three options: wait for the reset, turn on usage credits, or upgrade your plan. Which one is right depends on whether you hit the session window or the weekly cap.

1. Wait. If only the five-hour window is exhausted, a break is often the cheapest fix. Plan heavy work so a window resets over lunch or overnight.
2. Usage credits. Pro, Max and Ultra subscribers can enable usage credits to keep working after the session, weekly or Fable limit. They are billed at standard API rates. Run /usage-credits in Claude Code to open Settings > Usage on claude.ai, where you can turn them on, see this month's spend and set a monthly spend limit.
3. Upgrade. If you hit the weekly limit most weeks, a bigger plan usually costs less than paying API rates for the overflow.

One detail trips people up: the monthly API credits included with Max and Ultra plans are separate. Anthropic's help center says they do not apply to usage credits in Claude, Claude Code or Claude Cowork.

Fable deserves its own mention. Depending on your plan and seat, Fable requests can bill to usage credits instead of your included limits; the /model picker then shows "Requires usage credits" on the Fable row, and Claude Code asks for consent in interactive sessions. In non-interactive claude -p runs it bills without asking, per the model configuration docs.

Subscription or API billing: which is cheaper for Claude Code?

For a person coding most days, a subscription is almost always cheaper; the API fits automation, CI and teams that need hard per-key controls. With API billing there is no plan cap, but every token is charged at list price.

Anthropic's costs page gives a useful benchmark: across enterprise deployments on the API, the average is around $13 per developer per active day and $150 to $250 per developer per month, with 90% of users under $30 per active day. Compare that with $20 for Pro, $100 for Max or $200 for Ultra.

API list prices per million tokens, from the Claude API pricing page at the time of writing:

Cache hits matter because Claude Code resends your conversation on every request; most of those tokens are served from the prompt cache at a fraction of the input price. That is why a long session stays affordable until the cache expires, then suddenly costs more.

For headless runs on the API, two flags put a ceiling on a single job: --max-budget-usd stops a claude -p run once estimated spend reaches the amount you set, and --max-turns limits the number of agentic turns. Both are documented in the CLI reference; the budget check uses a client-side estimate, so leave some headroom.

Why does Claude Code use up limits so fast?

Because every request carries the whole conversation, and agents make many requests per task. A task that feels like one question may be thirty requests as Claude reads files, runs commands and checks results.

The costs documentation lists the usual causes of usage that climbs during a long session:

• Long context: a one-line question in a session open all day still draws usage for the entire history.
• Cache misses after a break: the first message after the cache lifetime expires reprocesses your full context at the uncached rate.
• Scheduled loops: a /loop task fires on its interval even while you are idle, sending the full context each time.
• Subagents and agent teams: each subagent has its own context; agent teams use roughly 7x more tokens than a standard session when teammates run in plan mode.
• Extended thinking: thinking tokens are billed as output tokens and can run to tens of thousands per request on hard tasks.
• Heavy instruction files and tools: a long CLAUDE.md loads on every session, and each enabled MCP server adds some overhead.

Vague prompts make all of this worse. "Improve this codebase" makes the agent scan widely; "add input validation to the login function in auth.ts" lets it read two files and finish.

How can you make Claude Code limits last longer?

Keep context small, pick the cheapest model that can do the job, and stop wrong turns early. These twelve habits come from Anthropic's guidance and from what moves the /usage numbers in practice.

1. Clear between tasks. Run /clear when you switch to unrelated work. Use /rename first so you can /resume later.
2. Compact with instructions. /compact Focus on the failing tests and the files we changed keeps what matters when you need to continue a long thread.
3. Default to Sonnet. Anthropic's docs say Sonnet handles most coding tasks well and costs less than Opus. Switch with /model sonnet, and reserve Opus or Fable for hard problems.
4. Try opusplan. This model setting uses Opus in plan mode and Sonnet for execution, so you pay for the stronger model only while deciding what to do.
5. Lower effort on easy work. /effort reduces thinking for routine edits. Thinking cannot be turned off on Opus 5.5, Sonnet 5.5, Haiku 5.5 or the Fable models, but effort still controls how much they use.
6. Keep CLAUDE.md short. The docs suggest under 200 lines. Move workflow-specific instructions (release steps, migration rules) into skills, which load only when used. Our guide to CLAUDE.md best practices shows what to keep.
7. Write specific prompts. Name files, functions and the expected outcome. The guide on writing tasks for AI coding agents has templates.
8. Plan before you build. Press Shift+Tab into plan mode for anything larger than a small fix. Rejecting a bad plan costs far less than undoing a bad implementation.
9. Interrupt early. Press Escape as soon as the agent heads the wrong way, and use /rewind to go back to a checkpoint.
10. Prefer CLI tools over MCP where both exist. The docs note that gh, aws and similar CLIs are more context-efficient than MCP servers. Disable servers you are not using with /mcp.
11. Filter noisy output. A PreToolUse hook can trim test output to failures only, turning tens of thousands of tokens of logs into a few hundred. The docs include a ready-made script; our post on Claude Code hooks explains how hooks work.
12. Send verbose work to cheap subagents. Delegate log reading or doc lookups to a subagent with model: haiku so only a summary comes back to the main conversation.

For broader techniques that also apply to your own API apps, see how to reduce LLM API costs.

How do you run agents unattended without burning your limits?

Give unattended agents narrow tasks, cheaper models and hard stops, and schedule them around your reset windows. An agent left alone with a vague goal can spend a week's allowance overnight.

• Write each task with a clear definition of done and a point where the agent should stop and ask.
• Start unattended sessions with /clear-fresh context and the model you actually need.
• On the API, wrap headless runs with --max-budget-usd and --max-turns.
• Avoid /loop tasks with short intervals in long sessions; each run resends the whole context.
• Check /usage in the morning and act on the top recommendation.

If you run agents on a remote machine so they keep going after you close your laptop, cost visibility matters even more. Orkio runs Claude Code on an always-on cloud box using your own Claude account, with no markup on model usage, and its Insights view shows real spend against API-equivalent usage per project, per model and per merged pull request, with project budgets and alerts.

Your usage checklist

Work through this once and you will rarely be surprised by a limit again.

• Run /usage now and note which of the two limits is closer.
• Check that ANTHROPIC_API_KEY is not set if you mean to use your subscription.
• Set Sonnet as your default model and switch up only when a task needs it.
• Trim CLAUDE.md below 200 lines and move workflow detail into skills.
• Disable MCP servers you have not used this week.
• Make /clear between tasks a habit.
• Decide whether you want usage credits as a safety net, and if so, set a monthly spend limit.
• If you hit the weekly cap three weeks in a row, compare the next plan up against your usage-credit spend.

Frequently asked questions