A Five-Character String Made Claude Code Charge 20x. Users Found It Themselves.

In March 2026, Claude Code users started burning through quotas 10 to 20 times faster than normal. Max 5x subscribers who previously got eight hours from a session were hitting limits in one. The cause was two overlapping problems. A bug in Anthropic’s custom runtime broke prompt caching, so every request paid cache creation rates instead of cache read rates, roughly ten times more. Separately, Anthropic silently cut the default cache lifetime from one hour to five minutes with no announcement, no deprecation notice, no API version bump. Users diagnosed both themselves by reading their own session logs, then reverse-engineering the binary. Anthropic confirmed the bug on March 31 in a post that drew 432,500 views. Sonnet 5 pricing rises 50% on September 1. Best for anyone who wants to verify their own bill. Not ideal for anyone who assumed the number was checked.

On Monday, Claude Sonnet 5 goes from $2 and $10 per million tokens to $3 and $15.

Before paying that, though, it is worth knowing what happened in March, because almost nobody outside the affected users heard about it properly.

For roughly a month, Claude Code charged some subscribers ten to twenty times more than it should have. Max 5x users on the $100 plan who used to get eight hours of work from a session were hitting the wall in one. Max 20x users watched usage jump from 21% to 100% on a single prompt. Pro users hit their limit after three prompts.

There was no blog post, however. No email. No status page entry.

The people who worked out why were the customers, reading their own log files and picking apart a binary.

What Actually Broke

Two separate things, incidentally, which is why untangling it took weeks.

Only the last one was announced. That announcement came from an engineer’s personal account rather than any official channel.

The bug reports pile up across issue #40524, #24147, #41930, plus #28899 which dates back to February. Anthropic classified #40524 as a regression, then assigned it.

The Cause Is One Line of String Handling

Certainly this is the part worth understanding, since it explains why nobody could see it.

So Claude Code uses prompt caching to avoid resending your whole conversation every turn. The first message writes the cache, which is expensive. Every message after reads from it, costing roughly ten times less.

Meanwhile, inside the request, there is a billing attribution header containing a sentinel string, cch=00000. On every API call, Anthropic’s code replaces that sentinel with a hash of the request body.

The replacement uses memmem to find the first occurrence of that string.

Here, then, is the problem. In the serialized JSON, your conversation messages come before the system prompt. So if cch=00000 appears anywhere in your conversation, which it does once your history is long enough, the code patches the wrong one. The billing header keeps its zeros. Your conversation gets a hash injected into it instead.

Which changes the cache prefix. The cache then never matches. So every single turn pays full creation price, forever, until you start a new session.

Notably, all of that happens inside Anthropic’s custom Bun fork, at the native Zig layer, invisible to the JavaScript above it.

That is why no amount of reading the Claude Code source in JavaScript would have found it. The people who did find it went into the compiled binary.

The Second Thing Was Not a Bug

Running underneath the cache bug, meanwhile, was a deliberate change nobody mentioned.

Around March 6 to 7, Anthropic cut the default prompt cache time-to-live from one hour to five minutes. No blog post, no deprecation notice, no API version bump. The documentation was quietly updated afterward to say five minutes is now the default.

The arbitrage that disappears

The economics matter here. A cache write costs 1.25 times the base input rate at five-minute lifetime, or 2 times at one hour. A cache read costs 0.1 times regardless. So the entire value of caching is the gap between writes and reads. It only pays off if a cached prefix gets read several times before expiring.

Ultimately, cut the lifetime from sixty minutes to five and any workflow with gaps between turns stops hitting the cache at all. You pay to write it, then it evaporates before you read it.

One analysis put the resulting API bill increase at 17 to 26%.

Anthropic’s only public response came through an engineer quoted by The Register, reframing the change as beneficial for one-shot calls where cached context is used once and not revisited. That did not address the quota exhaustion. The GitHub issue about it closed as not planned.

How Users Proved It

This is the part that should change how you think about your own usage. It is also the reason this story is worth reading five months later.

Fortunately, Claude Code writes session logs to ~/.claude/projects/ as JSONL files. Every API response includes a usage.cache_creation object with two fields: ephemeral_5m_input_tokens and ephemeral_1h_input_tokens.

Only one of those is ever non-zero on a given turn, though.

Which means the tier your session actually hit is recorded on your own disk, in a field that is part of the public API specification. Nobody can hide it, change it retroactively, or spin it.

One user on r/ClaudeAI ran the numbers across 1,140 sessions in their local conversation database, plotted the tier distribution by date, then produced a chart showing the exact day their sessions switched from one-hour caching to five-minute caching. From March 1 to April 1 their logs showed 100% use of the one-hour cache type. From April 2, between roughly 06:23 and 06:55 UTC, the mix broke.

They did not need Anthropic to confirm anything, obviously. The evidence was in their own files.

Yesterday we covered the tools that read those same logs and total up your spending. This is the other thing those files are good for: checking whether the bill is right.

The Source Leak Confirmed It

There is a detail here that connects to something we covered earlier this year.

On March 31, Claude Code’s source code leaked. We wrote about the leak itself when it happened. What has been less widely reported is that the leaked source confirmed the technical root cause of the cache bug, including the attestation system plus the anti-distillation mechanism sitting underneath it.

So the sequence runs: users notice their quota vanishing, users reverse-engineer a compiled binary to find out why, then a source leak independently confirms what they found.

At no point in that chain does the vendor explain the problem first.

Anthropic did respond publicly on March 31, saying they were aware people were hitting usage limits far faster than expected, with an investigation underway. That post drew 432,500 views, 766 replies plus 6,200 likes, which is a reasonable measure of how many people were affected.

They also called it the team’s highest priority, which it plainly was.

Why This Was So Hard to Prove

Worth spending a moment on, since the difficulty is structural rather than accidental.

Firstly, a subscription hides the number. What you see is a percentage bar draining, not a dollar figure attached to specific work. So when it drained faster, the honest first thought for most people was that they had simply worked harder that day.

That is exactly what happened at first. Threads filled with people wondering whether the model had got worse, whether their prompts had got sloppier, whether they were imagining it. The doubt was reasonable, since independent benchmarks showed the models performing normally.

Secondly, there was the overlap. Three separate things were happening at once: the cache attribution bug, the TTL reduction, plus deliberate peak-hour throttling. Each produced the same symptom from the user’s side. Anyone testing a theory would find partial confirmation for whichever cause they suspected, because all three were real.

Finally, the actual defect lived somewhere unreachable. Claude Code ships as JavaScript running on a custom Bun fork, with the relevant string handling down at the native Zig level. Somebody reading the JavaScript source, even carefully, would find nothing wrong, because nothing in the JavaScript was wrong.

Which is why the diagnosis required someone willing to open the compiled binary. That is a rare skill applied to a billing complaint. The only reason it happened is that enough people stayed angry for long enough.

What Changed Afterward

Not much publicly, which is the part worth sitting with.

Anthropic acknowledged the usage problem and assigned the bug. The TTL issue was closed as not planned, with the company’s only public comment reframing five-minute caching as a benefit for one-shot calls.

There was no post-mortem either. No timeline of what went wrong, no explanation of why the first report in February went unaddressed until March, no accounting of who was overcharged or whether anything was refunded.

Compare that, however, to the incident reporting we covered this month from the same industry. METR published a 91-page independent investigation into an agent incident, with raw transcripts. Anthropic itself published a review of 141,006 evaluation runs after finding three models had breached outside systems. Britain’s AI Security Institute produced a detailed technical timeline of an agent that faked identities.

Those are all safety incidents. The disclosure norms around them are developing fast.

Billing incidents have no such norms. When a model does something alarming, a report follows. When the meter runs 20x fast for a month, the record is a GitHub thread and a few blog posts by the customers who worked it out.

Both cost people something. Only one of them gets a document.

Which is not a conspiracy, just an absence of expectation. Nobody has established that a metered AI service owes its customers an explanation when the meter misfires, so nobody produces one. The safety reporting norms exist because regulators, researchers plus the press all demanded them loudly for two years. Nobody has done the equivalent for billing.

What This Means for Monday

Nothing here says Anthropic acted in bad faith, incidentally. A string replacement finding the wrong occurrence is an ordinary bug of a kind every codebase has. Cutting a cache TTL is a normal infrastructure decision.

What it says is narrower and more useful: the meter can be wrong. When it is, you find out before the vendor tells you.

Sonnet 5 rises 50% on September 1. The tokenizer reportedly adds up to 35% more tokens per equivalent text, which compounds it. Anyone on a subscription will feel that through quota policy rather than a bill, which is exactly the mechanism that made March so hard to diagnose. Our Claude Pro review covers what that tier includes today.

So the practical position is this. You are about to pay more, through a system that has previously been wrong by a factor of twenty, measured by a meter you cannot inspect, on a plan expressing cost as a percentage bar rather than a number.

The only thing you control is the logs on your own disk.

How to Check Your Own Usage

Concrete, taking about ten minutes.

Look at your cache tier. In ~/.claude/projects/, each JSONL turn carries a usage.cache_creation object. If ephemeral_5m_input_tokens is non-zero you are on five-minute caching. If ephemeral_1h_input_tokens is non-zero you are on the hour. This is the single most checkable fact about your account.

Watch your cache read ratio. Healthy caching means most turns after the first show large cache reads and small cache writes. If you see cache creation on every turn of a long session, the cache is not being reused. You are paying roughly ten times more than you should for that context.

Run a tracker. The tools from yesterday’s piece total this up automatically, broken down by model, project plus day. Do it before Monday, since every one of them prices from a hand-maintained table that Monday makes wrong.

Know the March workaround, in case it recurs. Running through npx @anthropic-ai/claude-code bypasses the custom Bun runtime that caused the first bug. Multiple users confirmed improvement. It did not fix the session resume issue.

Start fresh sessions more often. Once a cache prefix breaks, it stays broken for that session. A new session rebuilds it correctly.

Save a baseline this weekend. Whatever your tracker reports today is measured against pre-September prices. Write it down somewhere outside the tool, because after Monday no tracker reproduces it correctly until somebody updates a price table by hand.

None of this requires trusting anyone. That is the point.

The Pattern Across This Month

Step back and this fits a shape we have written about repeatedly in August.

OpenAI restored the five-hour Codex limit after six weeks without it, having watched developers switch to Codex specifically because it was gone. DeepSeek scrapped flat API pricing for peak and off-peak rates. Grok added a clause doubling the rate on requests over 200K tokens. Anthropic is ending an introductory price.

Every one of those is a vendor adjusting the terms of a metered product where the customer cannot independently verify the meter.

The March incident is the extreme version of that. For roughly a month, the meter was wrong by an order of magnitude. The correction came from customers reading files the vendor was obliged to write.

Which is a decent argument for the thing we keep coming back to. Running models on your own hardware costs money up front plus setup time. What it buys is a bill nobody can silently change. We covered an engine from Berkeley running a 35B model at 39.3 tokens per second on an 8GB laptop GPU. There is no meter on that at all.

The Part Worth Keeping

Ultimately a sentinel string got replaced in the wrong place because a search function found the first match instead of the right one.

That one detail, buried in a compiled runtime nobody outside Anthropic could read, cost thousands of paying customers ten to twenty times their expected usage for about a month.

Nobody found it through official channels. Customers noticed their quota evaporating, went into the binary, worked out what was happening, then published it. A source leak confirmed them afterward.

On Monday the price of the same product goes up by half.

The logs are still on your machine. They still contain the fields the API spec requires. Whatever happens next, that is the only part of this you can check yourself.

Ten minutes tonight beats a surprise in October.

Charts and Blocks

What broke, in order

Cache pricing, plus why five minutes matters