The Real Cost of Claude Code: Why a $20 Plan Can Subsidize a $30,000 Month

There's a thread on Indie Hackers (May 2026) in which a developer worked out that, in a single month on the $200/month Claude Max plan, they had consumed roughly $30,983 worth of equivalent API usage. Their conclusion was somewhere between gleeful and uneasy: am I doing something wrong, or is this just what it costs Anthropic to keep me on a subscription?

The short answer is: the subscription is doing exactly what it's supposed to, you are doing exactly what it's supposed to encourage, and this post is about why that arithmetic is sustainable for Anthropic, when it stops being sustainable for you, and which plan actually fits your shape. All pricing and limit numbers below are as of May 2026 and will drift — verify the current state on Anthropic's pricing page before making a decision.

The three doors

You have three real ways to access Claude in May 2026:

What the table doesn't tell you is the shape of the limits on the subscription tiers, which is the whole game.

The two windows you actually live inside

Every Claude Code subscription enforces usage through two rolling windows that overlap in slightly maddening ways:

The 5-hour session window

From the moment you send your first message, a 5-hour clock starts. Within that window, you get a fixed quota of tokens (and a separate quota for the higher-cost reasoning models). When the clock expires, the window resets and you get a fresh quota. The Pro plan's 5-hour window is small enough that an enthusiastic feature build will exhaust it; the Max plan's is several times larger. Anthropic doubled the 5-hour limits on May 6, 2026, so if you last checked your headroom before that, you have more than you think.

The weekly window

On top of the 5-hour quota, there's a weekly cap that ratchets up across the day. This is the one that catches people. You can string together a series of "fresh" 5-hour windows on Monday, Tuesday and Wednesday, feel rich, and then on Thursday afternoon hit the weekly limit and discover you've got nothing until Sunday-ish.

Most subscribers don't consciously feel the weekly window until the first time it bites them. Then they feel it every week.

Why the $20 plan can subsidize a $30,000 month

The Indie Hackers post that kicked this off ran something like the following math, paraphrased: the author had consumed roughly 10 billion tokens in a month inside Claude Code, mixed between Sonnet 4.6 and Opus 4.7. Multiply that out at published API rates and you land at ~$30,983 of equivalent API cost, on a plan that billed them $200.

"I burned $30,983 in Claude Code last month. My bill was $200." — paraphrased, Indie Hackers, May 2026

The reflex is to assume Anthropic is losing money on this customer. That is not quite right, and the reason it's not quite right is the unit economics of an AI subscription:

1. The API list price is not the cost of inference. The list price has to cover R&D, sales, support, margin, and the long tail of low-volume customers. The marginal cost of one more token of Sonnet to Anthropic is dramatically below the per-token list rate. (The same dynamic exists on OpenAI's side, where GPT-5.5 launched April 23, 2026 at exactly 2× GPT-5.4 — $5/$30 vs. $2.50/$15 — without the underlying inference cost doubling.)
2. Subscriptions average out across users. For every "I burned $30k" outlier, there are dozens of paying Pro users who don't crack $5 of API-equivalent. The subscription is a bet on the distribution, not the tail.
3. The 5-hour + weekly windows act as a soft cap. They prevent the absolute worst-case user from being unbounded. The $30,983 number sounds wild, but it's still bounded by how many tokens a single human can shove through Claude Code in a month while sleeping occasionally.

Translated: subscribing is rational for Anthropic because the average user is cheap; subscribing is rational for the heavy user because the API list price is built for a different customer. The arbitrage exists, and as long as you don't violate ToS by reselling it, it's the deal on offer.

The break-even, as a rule of thumb

Here is the version I would write on a whiteboard. Treat these as ballpark — actual break-evens shift with model mix and prompt cache hit rate.

If you're a heavy daily user of Claude Code on Sonnet, the $200 Max plan starts to make ridiculous economic sense at fairly modest token volume — the heavier you use it, the more absurd the subsidy gets. That's the secret of the Indie Hackers thread: it isn't a bug, it's the deliberate logic of the plan.

When the subscription is the wrong answer

The subscription stops being the right answer the moment your usage is no longer a human typing at a terminal. Specifically:

• Agents and automations. Subscription quotas are designed around interactive human work. Running a 24/7 agent against your Pro plan will burn the 5-hour window in minutes and the weekly in hours.
• Multi-user workloads. Anthropic's seat economics don't love you running one Max plan that proxies for ten developers. There's a team plan for a reason; ToS apply.
• SDK / programmatic use. You're not on Claude Code at this point — you're a regular API customer and you should be priced like one.
• Bursty, unpredictable spikes. If your usage swings from 0 to 50M tokens in a day, the API gives you the flexibility the subscription doesn't.

For everything else — the "I sit at a keyboard, I type, Claude codes, I commit" loop — subscription is almost always cheaper than going API-direct in 2026.

The hybrid most heavy users actually run

In practice, most experienced Claude Code users I know in 2026 run a hybrid:

• A Max plan for their interactive Claude Code work.
• A separate API key for SDK code, agents, and anything programmatic — billed per token, capped per-key.
• A read-only admin key wired into a spend dashboard (CookedAF, console, whatever) so the API side never silently turns into the Indie Hackers headline in the wrong direction.

How to actually decide (in five questions)

1. Do you use Claude Code > 1 hour a day, most days? If no, Pro. If yes, keep going.
2. Do you hit the Pro 5-hour limit before lunch? If yes, you need Max.
3. Do you hit the weekly limit before Friday on Max 5×? If yes, you need Max 20×.
4. Are you running anything programmatic against Claude? That goes on the API, not your subscription. Mint a separate key for it.
5. Do you have a single glanceable view of (a) your subscription windows and (b) your API spend? If no, fix that before optimizing pricing — you cannot reason about the right plan without visibility into your actual consumption.

Question 5 is the one most people skip. It's also the one that turns "which plan?" from guesswork into arithmetic.

Where CookedAF fits

The bit we built is the answer to question 5 on the API side: an at-a-glance panel that pulls real spend from every provider's billing endpoint, locally on your machine, with keys that never leave your OS keychain. For your subscription window inside Claude Code, the OSS tooling (ccusage, Claude-Code-Usage-Monitor) is excellent — we cover both in the Claude Code spend tracking guide.

The hybrid most heavy users land on:

• Max plan for the chair-time work.
• ccusage for retroactive subscription-side receipts.
• CookedAF on the desktop for the API-key side of the equation, so you see — every morning, in two seconds — whether the previous day looked normal.

The takeaway, in one line

The reason a $200 plan can absorb $30k of equivalent API value is that the subscription is priced for an average user and you happen to be a particularly enthusiastic one — and that's fine, as long as you understand the limits, design around them, and know exactly when your shape stops being "ambitious human at a keyboard" and starts being "programmatic workload pretending not to be." That moment is when the subscription becomes the wrong door, and the visibility on the API side is what tells you you've walked through it.