Claude Pro and Max Limits: Usage Windows and /usage

Practical information about working with Ailoot is in the documentation.

How many tokens does Claude Pro really give you?#

I looked for that number myself when I was figuring out the plans. You paid $20 and want to know what you bought. There is no number, and the sooner you accept that, the less time you will waste looking for one.

Open the Claude pricing page: it lists features, prices, and one line about limits:

That’s all. No number of messages, no token count, no number of hours. That is by design: Anthropic’s limits are not expressed as a fixed number at all.

Anthropic’s limit system works differently. You have a time window, and within it a share of usage. If you have used half of the five-hour window, it shows 50 percent.

How many tokens fit into those 50 percent depends on three things: which model you used, how long your context was, and whether you hit the cache. One hour of work can use 10 percent of the window or all 80 percent.

That leads to three conclusions that answer half the questions right away:

1. Comparing your usage with someone else’s is pointless. The same percentage means a different amount of work for someone with a clean project containing 20 files and someone with a project containing 2,000 files.
2. Check the dates on figures in English-language articles. The latest confirmed change was on May 6, 2026, when five-hour windows were doubled (more on that below). An article from a year ago describes a different product.
3. Your own dashboard is the only reliable source. It is built into Claude Code and opens with a single command.

If you need a one-sentence answer for the table below: as of October 3, 2026, Pro costs $20 per month ($17 with annual billing), gives at least five times the Free plan’s usage, and has one weekly limit; Max starts at $100 and gives five or 20 times Pro’s capacity, plus a second weekly limit specifically for Sonnet. None of the plans states an exact token count.

Next, I’ll explain how the windows work, where to check what remains, and how to figure out in one day which plan suits you.

How do Claude’s three layers of limits work?#

Almost everyone knows about the five-hour window. People remember the weekly one when they have already hit it. And they learn about the Opus limit when they see an unfamiliar message and wonder why it is different from yesterday’s.

The first layer is the five-hour session. The window is rolling: it is not tied to calendar hours and does not begin at midnight. Capacity returns after five hours; Claude Code gives the exact reset time in the limit message. This is the cap people hit most often when working intensively.

The second layer is the week. Everything you have used over seven days is added up here. The weekly window is not rolling. It resets at a fixed time assigned to your account, and the reset day does not change based on when you started working. Hitting the weekly limit is the most unpleasant: you can wait out a five-hour window over lunch, but the weekly one can cut you off from the tool for several days. Stories like this regularly come up on specialist sites.

The third layer is model-specific. Opus has its own separate counter, which works in the user’s favor: when the Opus limit runs out, you can switch to Sonnet and keep working.

Max plans have two weekly counters. The official wording says Max has “two weekly usage limits: one applies across all models, and the other only to Sonnet models.” On the /usage screen, they are labeled Current week (all models) and Current week (Sonnet only).

The first two layers are shared across all models; the third is not. Claude Code’s documentation states this directly:

Here is the practical rule. If you see a message about Opus, press /model, choose Sonnet, and keep working. If it is about a session or the week, switching models will not help; you have to wait or buy extra usage.

For weeks at a time, I never run into the five-hour window. But I hit the weekly limit on the very first day when I sent batches of agents to work overnight. So it is worth watching the second limit, even though the first one flashes more often.

The pool is shared with chat. For Team plans, the documentation says directly that a workspace’s capacity is shared across Claude Code, claude.ai chat, and Cowork. Pro and Max work the same way. Spend the morning in chat reviewing a contract, and there will be less capacity in Claude Code that evening. This is one of the most common reasons people wonder, “I barely coded—where did it all go?”

Where can you check how much you have left?#

Launch Claude Code and enter:

/usage

The /cost command does exactly the same thing; it is an alias.

Here is what you will see:

1. Bars for each window: five-hour, weekly, and Opus separately, with a percentage and reset time.
2. A breakdown by usage source. Claude Code shows what share went to skills, subagents, plugins, and each connected server individually.
3. Behavior warnings about things that use up capacity. If a long context or cache misses consume 10 percent or more, the system highlights it in a separate line with a suggestion.
4. Period switching with the d (day) and w (week) keys.

If you work in a code editor extension, the same breakdown is in the account information dialog, with a “Day / Week” switch.

I only look at the weekly bar and the breakdown below it. The five-hour allowance will return by lunchtime anyway, while the weekly one tells me whether I’ll make it to Friday.

There are two caveats that lead people to the wrong conclusions.

First: the dollar amount in the session block is not your bill. Claude Code calculates it locally using standard token prices, and it has nothing to do with your subscription. The documentation says so directly:

Second: the numbers are calculated from this machine’s local history. Usage from another computer or from web chat is not included in this breakdown. If you have a work laptop and a home computer, each dashboard shows only its own share, while the limit itself is shared.

What do the English limit messages mean?#

Here are the exact messages from the Claude Code documentation and what to do for each:

You can also check what remains before you run out. The documentation suggests two ways: show rate_limits fields in your status line or, in the desktop app, click the usage ring next to the model selector. The web version displays Approaching 5-hour limit. as you approach the limit.

Another message people confuse with a limit is the context auto-compaction warning. It means the conversation has reached the model’s context-window limit and Claude is about to rebuild the history as a compressed summary. It has nothing to do with subscription capacity, even though it looks alarming.

How does Pro compare with Max?#

Here is what the prices look like as of October 3, 2026. Prices are from the official page:

Anthropic describes the difference using multipliers. There are no absolute numbers anywhere. “Five times more than Pro” is all that is officially known. How many hours of your work that amounts to depends entirely on how you work.

One detail that confuses people looking at old articles: as of October 2026, Claude Cowork is rolling out as-is in Claude, without a separate name, on Pro and Max. This is an interface renaming, not a new plan or a change to the prices in the table above.

The price difference between Pro and Max is fivefold, and the capacity difference is fivefold too. The cost per unit of work on Pro and Max 5x is roughly the same.

I use the higher-tier plan myself, and the question of which plan to choose was settled for me when I started running agents in groups and leaving tasks overnight. With that pattern, you hit the ceiling regardless of how carefully you clean up context. If you work manually in one window, you do not need it.

Max removes the ceiling while keeping the cost per hour of work the same. So the question comes down to one thing: how often do you hit that ceiling? Once a week and it pays for itself. Once a month, and that is an extra $80 for nothing.

Why does the limit run out faster than your work would suggest?#

I’ll go through each cause, how it works, and what to do. The first one catches me most often: a session opened in the morning and forgotten until evening.

Long context. The model does not remember between requests, so the entire history is sent to the server again with every message. By evening, a session opened in the morning has become a hefty package that is sent to the server every time you say, “yeah, fix this.” The solution is simple: use /clear between unrelated tasks. I covered this mechanism in detail in a separate guide, “Where Claude Code tokens go”.

Cache miss. Repeated parts of the context are cached, which is noticeably cheaper. But the cache has a time to live: on a subscription, it is one hour; if you have switched to extra usage, it is five minutes. Return to work after a long break, and the very first request recalculates the entire context.

Scheduled tasks. A scheduled task runs at its own interval even when you have not gone near your computer. And it sends the full context.

Agent teams. This is when Claude runs several assistants in parallel on one task. Each holds its own context window and uses capacity until it finishes. The documentation gives a specific estimate: in plan mode, agent teams use about seven times as many tokens as a regular session. If you ran agents in parallel and were surprised by the counter, this is probably why.

Compaction itself. The /compact command reads the conversation it is compacting. With a large context, that is an expensive operation. When you do not need continuity, /clear is free and does the job better.

Background activity. Claude Code uses a small amount even when you are doing nothing: it summarizes past conversations to restore sessions and processes housekeeping commands. According to the documentation, this is usually less than four cents per session, so it is negligible overall.

You do not have to investigate this manually. The /usage panel highlights behavior that consumed more than 10 percent of your recent usage and labels what to do about it.

The thresholds that trigger panel warnings are built into Claude Code:

The last line usually means an overnight run or a forgotten window. All sessions use the same limit, so four parallel windows consume capacity four times faster; they do not have a separate quota.

What clears the cache, and why is that expensive?#

This is the most underestimated source of usage because it is invisible. You make one short change, and the next request recalculates the entire history at full price.

What clears the cache:

1. Switching models with /model. Each model has its own cache. Switch, and the next request reads the entire conversation without a single cache hit, even though the content is the same.
2. Changing the effort level. The cache is tied to it as well.
3. Connecting or disconnecting a server whose tools load immediately.
4. Updating Claude Code. Resuming an old session after an update recalculates the entire history from scratch.
5. Pausing longer than the cache lifetime. One hour on a subscription, five minutes with extra usage.

This leads to a non-obvious point about the advice “hit the Opus limit? Switch to Sonnet.” It works, but it has a cost: the first request after switching misses the cache. With a long conversation, that is a noticeable one-time expense. If you are going to clear the context soon anyway, it is better to use /clear and start fresh on Sonnet than to carry the whole history along.

One more detail about subagents: their cache lasts five minutes even on a subscription, because the one-hour lifetime applies only to the main conversation. That is why batches of subagents with long pauses between runs are doubly expensive.

How much does extra usage cost?#

When your subscription capacity runs out but you need to finish your work, pay-as-you-go billing kicks in. Rates as of October 3, 2026 (standard price, without fast mode):

Sonnet 5’s price was introduced as an introductory rate through August 31, 2026, with a promise to increase to $3 and $15. Anthropic canceled that increase: $2 for input and $10 for output remain the permanent price. If you are reading material that still says “introductory price through the end of August,” that caveat has been withdrawn; the current rate is permanent.

The practical point of this table is simple. Opus costs roughly twice as much as Sonnet. If you keep Opus as your default model because “it might as well be the best,” you pay twice as much for tasks where you will not notice a difference. Sonnet handles most coding work; save Opus for architectural decisions and untangling difficult problems.

The second point is when extra usage stops being worthwhile. If you buy an extra $80–$100 every month on top of Pro, you are already paying about as much as Max, but without its capacity or priority during periods of high demand.

How do you calculate which plan you need?#

The method takes three days, and all you need is the built-in panel.

1. Work for three typical days on your current plan. Do not deliberately economize or run a stress test; you need your normal routine.
2. Open /usage every evening and write down the percentage of the weekly window. Record the weekly one; it gives the overall picture.
3. Calculate your average daily usage. Three days at 18 percent means the weekly window should last about 5.5 workdays.
4. Look at the result. If it lasts five days or more, stay on Pro. If it runs out by Wednesday, consider Max 5x. If it runs out in two days, consider Max 20x and clean up your context at the same time, because that level of usage often comes from a forgotten open session.

If you do not want to guess during those first three days, here are some benchmarks by workload. This is my estimate based on observation; Anthropic does not publish official figures of this kind:

There is a simple sign that the plan is not the problem. You hit the limit, but did no more than a couple of edits all day. In that case, context is the issue, and buying a higher-tier plan will only push the wall back by a week.

For reference, here are Anthropic’s official figures for enterprise deployments, where usage is charged directly in dollars:

Read this carefully: these figures are for pay-as-you-go token usage; subscriptions are calculated differently. The benchmark is still useful. If someone coding all day spends $150–$250 at API prices, Max at $100 with its allowance looks like a reasonable middle ground for intensive work.

One caveat from me. When you hit the limit even on the higher-tier plan, your first instinct may be to get a second subscription and carry on.

Before paying twice, check /usage once to see what is using your capacity. Most often, you will find forgotten groups of agents and context that no one has cleared in three days. That costs nothing to fix.

What should you do right now if you hit a limit?#

Here are the steps, from the cheapest option to the most expensive:

1. Read which limit ran out. The message always shows the reset time. It is often just a couple of hours away, and the problem will resolve itself.
2. If it is the Opus limit, enter /model and switch to Sonnet. You can continue working right away. Sonnet handles most coding tasks and saves a noticeable amount of capacity.
3. Check /usage. The panel shows what used up the window. If 40 percent went to agent teams you forgot to stop, you can fix that without spending money.
4. Buy extra capacity with /usage-credits. It opens the billing settings in a browser. On Pro and Max, you can do this yourself; on Team plans, the request goes to an administrator. Extra capacity is charged at regular API prices, with a daily cap of $2,000. There is a side effect: the cache lifetime with extra usage is five minutes instead of one hour—and usage grows faster than you expect.
5. Change plans if you hit the limit regularly. A one-off extra purchase costs more than a subscription over the long run.

A separate note about a second account, because the question comes up constantly. Anthropic’s public documents do not directly say, “You may not buy a second subscription for yourself,” and I will not make that up. There are three related rules.

Sharing access is explicitly prohibited: the Terms of Service say you may not give your login details, key, or account access to anyone else. Buying one subscription for two people falls under that.

Claude Code’s documentation separately explains what the stated limits are designed for.

The Usage Policy separately prohibits creating a new account to get around a suspension already imposed. That is a different situation, but remember: restoring a disabled account is almost impossible, Anthropic may delete the data associated with it, and under the Terms of Service, no refund is due after termination for a material breach.

In practical terms, two workspaces for your own tasks do not raise questions. But Anthropic monitors a single account spread across a team.

How can you avoid accidentally switching to hourly billing?#

This is the most frustrating money trap because it is quiet. You pay for a subscription and work as usual, but usage is billed separately at API rates.

How to check that you are using your subscription:

/status

The command shows the active credentials. If it lists an API key and you expected to be using your subscription, that is the source of the unexpected bill.

What to do:

1. Ask Claude Code: “check whether I have the ANTHROPIC_API_KEY environment variable and show me where it is set.” It will find it and tell you. The key may have come with someone else’s setup instructions or been left over from an experiment six months ago.
2. Ask it to remove the variable if you are using a subscription.
3. Sign in again through /login with your claude.ai account.
4. Check /status again; the line about the key should be gone.

People who use the API or cloud providers follow a different model. They do not have five-hour windows; they get billed for actual usage and have a request-frequency limit. The advice here does not apply to them.

What changed to the limits on May 6, 2026?#

I noticed it about a week later: I stopped hitting the five-hour window by lunchtime. Here is the wording from the official announcement:

What this means in practice:

• Old measurements of the five-hour window are no longer valid. The estimate “Pro lasts two hours,” written before May, is now understated by half.
• But weekly estimates should not be doubled. The announcement covers only five-hour windows; it does not mention the weekly allowance at all. That is why the plan calculation above uses the weekly window: you need to measure it yourself. Other people’s measurements are useless here.
• The feeling that “limits have become stricter” is usually explained by usage. Capacity grew, but people’s usage grew faster: agents, skills, connected servers, and parallel sessions. The /usage panel shows this line by line.

Which tips about limits do not work?#

The advice “hit a limit? Switch models.” It works only for the Opus limit. Session and weekly limits are shared across all models, and /model will not restore them. The advice persists because it worked for the author once—when they hit the Opus limit.

The advice “compact context more often.” Compaction itself reads the entire conversation being compacted. Running /compact every twenty minutes means paying to process the same history again and again. When continuity is not needed, /clear is free.

The advice “here is the exact Pro token count.” There is no number; there are windows and shares within them. Any specific figure is either someone’s one-off measurement on their own project or a secondhand retelling of one.

The advice “keep a second subscription just in case.” A second workspace may make sense for a real workload, but more often you are paying twice for your own uncleared context. Check /usage before reaching for your wallet.

Context hygiene works: clear between tasks, keep your rules file compact, and turn off what you do not use. I have a separate guide to basic usage-saving practices, “How not to burn through Claude Code limits in a day”, and another about measurement tools, “How to track token usage”.

Open Ailoot.