Quick answer. Claude Code meters usage with a five-hour session limit plus a weekly limit, and a higher plan (Pro, Max 5x, Max 20x) raises your per-session capacity. You can't bypass these, but you go much further by matching the model to the task, keeping context lean with /clear and /compact, writing a tight CLAUDE.md, and moving heavy automated work to a pay-as-you-go API key.
Last checked: June 26, 2026. Anthropic adjusts Claude Code limits and billing frequently — confirm the current state against your own plan in Settings > Usage and the in-app limit notice.
If you live in Claude Code, you eventually hit a wall mid-task and see a limit notice. The fix is rarely "buy a bigger plan." Most developers burn their quota on avoidable things: an overgrown context window, the most expensive model running routine edits, and re-explaining the same project facts every session. This guide covers how the limits actually work in 2026, then the concrete habits that get more done inside them.
One honesty note up front: Anthropic does not publish exact token quotas, and it tunes the limits often. Treat every number here as a directional guide, not a contract, and check the meter on your own plan.
How do Claude Code usage limits work in 2026?
Claude Code runs on two stacked limits:
- A session limit that resets roughly every five hours. The window covers everything you do across Claude Code and Claude chat during that period, since both draw from the same pool. When you hit it, the limit notice and Settings > Usage show your reset time.
- A weekly limit that caps total usage over a 7-day period and resets at a fixed time assigned to your account (shown in Settings > Usage). On Max plans there are two weekly limits: one across all models and one specifically for Sonnet-class models.
Your plan raises capacity rather than exposing a published token number. Max 5x and Max 20x refer to roughly five and twenty times Pro's per-session capacity. Weekly limits also vary by plan, but Anthropic does not publish exact token or message amounts or a simple weekly multiplier — so don't assume the weekly tank scales 5x or 20x in lockstep. Anthropic is explicit that real burn rate depends on conversation length, complexity, model choice, and the features you use, which is why two people on the same plan can hit limits at very different times.
Two 2026 changes are worth knowing. On May 6, 2026 Anthropic permanently doubled the five-hour limits for Pro, Max, Team, and seat-based Enterprise, and removed peak-hour throttling for Pro and Max. Separately, a June 15, 2026 billing change that would have moved automated usage (the Agent SDK, claude -p headless runs, GitHub Actions, third-party apps) into a separate metered credit pool was announced and then paused — as of June 26, 2026 it has not taken effect, so the Agent SDK, claude -p, and third-party apps still draw from your normal subscription limits and the separate monthly credit isn't available. We break the shift down in our June 2026 billing change explainer; check it before you re-architect anything around a credit pool, since Anthropic may revisit this.
Why are you hitting Claude Code limits so fast?
If you feel like you run out early, it's almost always one of these:
- Context bloat. A long session with stale history and large file dumps means every new turn re-processes a huge context window. That is the single biggest silent cost.
- Wrong model for the job. Leaving the most powerful model on by default for renames, log lines, and boilerplate spends premium budget on cheap work.
- Re-explaining the project. No CLAUDE.md means you (or the model, by re-reading files) reconstruct the same conventions every session.
- Reading the whole repo. Letting the model pull large files in full instead of the relevant slice.
Fix those four and you'll often go a long way further on the same plan.
Which model should you use per task?
Model choice is the highest-leverage knob, because the strongest model uses meaningfully more of your quota per turn. Use /model to switch, and pick by task rather than leaving the heaviest one running by default:
- Sonnet — the default and the right call for the large majority of coding: features, tests, known bugs, ordinary refactors. Fast, capable, cost-efficient.
- Opus — reserve for genuinely hard problems: cross-cutting refactors, stubborn debugging, architecture decisions. Switch to it when you're stuck, not as a standing default.
- Haiku — the cheap, fast option for mechanical work: renames, log statements, regex explanations, boilerplate.
There's also /model opusplan, which plans with Opus and then executes with Sonnet. Because switching models doesn't clear the conversation, Sonnet still sees everything Opus produced — you get the strong plan without paying Opus rates for the whole implementation.
How does context hygiene save usage?
Every turn re-processes your context window, so a lean session is a cheap session. Three habits do most of the work:
/clearbetween tasks. This wipes the conversation but keeps your CLAUDE.md and project files available. It's the single most effective lever for both quality and cost — use it every time you switch to an unrelated task./compactwhen a session must continue. It summarizes the conversation so far into a short recap, freeing space while preserving the essentials, instead of carrying every old message forward./rewind(double-tap Escape) to a checkpoint. Roll back to just after Claude read your files; everything after that point is dropped from context. Great after a wrong-turn exploration that bloated the window.
The meta-habit: keep sessions small and focused. One task, one clean window, then clear.
What other tactics stretch your quota?
Beyond model choice and context hygiene, these compound:
- Write a tight CLAUDE.md. Conventions, stack, commands, and gotchas in one file mean you stop re-explaining the project every session and the model stops re-deriving it by reading files. Our guide to writing a CLAUDE.md covers what to include and what to leave out.
- Prune large file reads. Point the model at the relevant function or section instead of letting it ingest a 2,000-line file in full. Less context in, less budget spent.
- Batch related edits. Ask for the whole set of related changes in one instruction rather than ten back-and-forth turns; each round trip re-processes context.
- Use tools and MCP to skip turns — but only the ones you need. Letting Claude run the command, test, or query directly can replace several explanatory round trips. The flip side: connectors and tool definitions are themselves token-intensive, and verbose command output lands back in context. Disable connectors you aren't using and keep output tight.
- Delegate to subagents carefully. Subagents parallelize work, but each one runs its own context window, so cost multiplies with parallelism — a three-agent run can use several times the tokens of a single session. Use them for genuine parallel workloads, cap parallelism, and never leave a long subagent chain running unattended.
Tactics at a glance
| Tactic | What it saves |
|---|---|
/clear between tasks | Stops re-processing stale history every turn (biggest single lever) |
/compact mid-session | Keeps a long task going without carrying every old message |
| Right model per task | Premium budget reserved for hard problems, not boilerplate |
| Tight CLAUDE.md | No re-explaining conventions or re-reading files each session |
| Prune large file reads | Less context in, less quota per turn |
| Batch related edits | Fewer round trips, each of which re-processes context |
| Tools / MCP for actions | Cuts narration turns by letting Claude run things directly |
| Subagents (with caution) | Parallel throughput — but only when the work is genuinely parallel |
Should you switch to an API key or a different plan?
When habits aren't enough, the plan itself is the lever:
- Pick the right subscription. If you hit the weekly cap most weeks on Pro, Max 5x or Max 20x buys a proportionally bigger session and weekly budget. If you rarely come close, you're overpaying — stay where you are.
- Consider pay-as-you-go API for bursty or automated work. A pay-as-you-go API key is metered per token at API rates, so it suits light or spiky usage and headless automation. As a rough rule, daily heavy interactive use tends to favor a subscription, while bursty or sub-$1/day usage often favors the API — compare your actual usage against current API pricing rather than guessing. (The separate Agent SDK credit pool from the paused June change isn't available as of June 26, 2026.)
- Mix the two. Many developers keep a subscription for interactive day-to-day work and route heavy automated or batch jobs to an API key, where prompt caching and batch discounts cut cost further.
If you're seeing errors rather than clean limit notices, our Claude Code troubleshooting guide covers the common failure modes.
Frequently asked questions
Can you bypass Claude Code usage limits?
No, and you shouldn't try — the limits are part of the plan terms. What you can do is use them efficiently: the right model per task, lean context, and a good CLAUDE.md can materially increase how much real work fits inside the same quota.
How do I check my current limit and reset time?
Open Settings > Usage to see your session and weekly status and reset times. When you hit a limit in Claude Code, the in-app limit notice also tells you when it resets. Check there rather than relying on any fixed number you read online.
How often does the five-hour session limit reset?
The session limit resets roughly every five hours. When you reach it, the limit notice and Settings > Usage show the exact reset time for your account — so confirm there rather than assuming a fixed clock-hour.
What's the difference between the session limit and the weekly limit?
The session limit is the short-term ceiling that resets about every five hours. The weekly limit is the larger ceiling over a 7-day period that resets at a fixed time assigned to your account. They are separate ceilings — doubling the per-session limits in May 2026 did not widen the weekly tank.
Does choosing a cheaper model really save much?
Yes. The strongest model uses meaningfully more of your quota per turn, so running Sonnet or Haiku for routine and mechanical work and reserving Opus for hard problems is one of the biggest savings available — with little quality cost on the easy tasks.
Did the June 2026 billing change take effect?
The June 15, 2026 change that would have split automated usage into a separate credit pool was announced and then paused; as of June 26, 2026 it has not taken effect, so Claude Code — interactive and automated alike — still uses your normal subscription limits. Because Anthropic revisits this often, confirm the current state on your plan before re-architecting around it.
How do I tell which habit is burning my quota?
Watch for context bloat first — long sessions with stale history and full-file reads are the usual culprit. Clear between tasks, compact long ones, and check whether the heaviest model is running work a cheaper one could handle.
None of this is about gaming the system — it's about not wasting budget on bloated context and the wrong model. Build the habits once and the limits stop being something you think about. If your team is scaling agentic development and wants help getting the workflow right, Codersera can connect you with vetted remote developers who already work this way.