Anthropic gave you credits. The shortage and the cache TTL drop turned them into funny money.
The dollars on claude.ai/settings/usage are real. The spending power is not. The same response that lists your extra-usage credit ships an out_of_credits flag and a disabled_until timestamp the server can flip without UI warning. None of the local-log trackers walking your JSONL transcript can see either field.
Why are Anthropic's apology credits unusable during the shortage? Because the same /api/organizations/{org_uuid}/overage_spend_limit response that ships the dollar balance also ships an out_of_credits: bool plus a disabled_until timestamp the server can flip silently. Verified against src/models.rs lines 30-40. Local-log trackers (ccusage, Claude-Code-Usage-Monitor) read JSONL token logs on disk and cannot reach this endpoint at all.
The four-line story
Anthropic underinvested in compute. New GPUs take 18 to 24 months to land, so they tightened consumer-plan rolling windows in late March 2026 to keep production lit. Around the same time they quietly cut the Claude Code prompt cache TTL from 1 hour to 5 minutes, which meant identical work suddenly cost 2x to 3x more in tokens. Users hit walls twice as fast. Anthropic offered make-good credits, denominated in dollars, on top of every paid plan.
And then the second-order problem started: the credits sit behind a server-side switch that nobody told users about. When peak-hour capacity gets tight, the boolean flips. When it does, your $200 extra-usage promo balance reads as a dollar number on the settings page and zero spending power in Claude Code. Local trackers do not poll the field that controls it. The dollars are real; the access is conditional; the difference is invisible unless you read the right server response.
The four mechanics, in order
Capacity throttle clamps the spending hours.
Late March 2026, weekday peak hours (8am-2pm Eastern) tightened. The product lead said users were hitting limits 'way faster than expected' on March 31. When the 5-hour or 7-day window trips, the client falls through to extra-usage billing, which spends down the make-good credit instead of returning a 429. Outside peak hours your credit is plentiful; inside peak hours you cannot reach it because the upstream window already tripped.
The cache TTL drop inflates the per-prompt burn.
Around April 2-3, 2026, Claude Code's default prompt cache TTL went from 1 hour to 5 minutes. One Reddit user documented going from 39 cache busts per day at $6.28 to 199 per day at $15.54, a $277.80 monthly delta on the same work. Cache rebuilds bill at the write rate against the credit balance, so the dollar number on the settings page drains 2-3x faster than the productivity you got out of it.
The server can flip out_of_credits silently.
OverageResponse has an out_of_credits boolean and a disabled_until timestamp. When out_of_credits is true, extra-usage requests fail at the gateway. Nothing in the Claude Code error message tells you which of the four possible causes (5h window tripped, weekly window tripped, monthly cap hit, out_of_credits true) actually fired. The disabled_reason string is your only diagnostic, and it lives only on this endpoint.
Local-log trackers cannot see any of the above.
ccusage and Claude-Code-Usage-Monitor walk the local JSONL transcript and sum tokens. /overage_spend_limit is a different endpoint on a different host. There is no overage block in the transcript. A tool that walks JSONL has zero visibility into BLOCKED, into disabled_until, or into the cents-precision spend that determines whether your apology credit has any spending power left.
Anchor fact: the OverageResponse struct is seven fields, three of which ccusage cannot see
This is the open-source struct ClaudeMeter decodes the credit line from. The first four fields (is_enabled, monthly_credit_limit, currency, used_credits) are roughly inferable. The last three are not. They are disabled_reason, disabled_until, and out_of_credits. Their default state is null/false. When they flip, your credit line is gone.
The 17 lines that turn the boolean into the word BLOCKED
ClaudeMeter does almost nothing clever with this. It reads the struct, divides the cents by 100 to get dollars, and appends the literal string BLOCKED when out_of_credits is true, plus the unlock date if disabled_until is set. The whole thing fits on a screen. The point is that everything you actually need to know about the credit line lives in the response; all you have to do is print it.
Reproduce the contract in one curl
You do not have to install anything to verify this. Pull your claude.ai session cookie out of DevTools, find your org UUID at /api/account, and hit /overage_spend_limit. The shape is the seven fields above. The cents-to-dollars conversion is on you.
Visibility into the credit line: server-truth vs. local-log
The Reddit thesis 'Anthropic gave us funny money' lands because the spending power is gated by fields no local tool can read. This table is the field-by-field gap.
| Feature | ccusage / Claude-Code-Usage-Monitor (reads local JSONL) | ClaudeMeter (reads /overage_spend_limit) |
|---|---|---|
| Sees the dollar balance | No. JSONL has tokens, not dollars. | Yes. used_credits / monthly_credit_limit, in cents from /overage_spend_limit. |
| Sees out_of_credits true | No. The boolean is not in any local file. | Yes. Renders as the literal string BLOCKED in the menu bar and CLI. |
| Sees disabled_until timestamp | No. | Yes. Appended as 'until Sat May 10' next to BLOCKED. |
| Sees disabled_reason string | No. | Yes. Surfaced in the snapshot JSON the bridge writes to localhost. |
| Counts cache rebuilds against credits | Indirect. JSONL shows raw tokens, not whether they were cache-write or cache-hit. | Indirect on the client; the dollar drain is what you actually need. |
| Sees throttling fall-through to extra-usage | No. JSONL records a request was sent; not what the server billed it against. | Yes. used_credits ticks up while five_hour utilization is at 100 percent. |
| Distinguishes 'window tripped' from 'credits blocked' | No. Same client error for both. | Yes. Different fields on different endpoints; different recovery strategies. |
Counterargument: the credits are real dollars, you are being dramatic
Fair. The dollars are real. If your usage is under the rolling-window ceilings and you are not in a peak-hour throttle, the credit spends like cash. Plenty of users will burn through a one-month subscription credit and never see out_of_credits flip in their entire billing cycle. The funny-money framing is most true for the population it is loudest from: heavy Claude Code users running agentic loops between 8am and 2pm Eastern, where the probability of upstream throttling is highest, where the cache TTL drop hits hardest, and where capacity-protection flag flips are most likely to land. For everyone else it is a real $20 to $200 of value.
That is also the reason this page exists rather than a refund-request template. The fix is not to argue with billing; the fix is to know what the server actually thinks of your credit, in real time, so that when the boolean does flip you see it before your next refactor stalls.
Honest caveats
- The endpoint is undocumented. If Anthropic renames a field, the serde parse fails loudly and the menu bar shows
!; the fix is one struct edit and a release. disabled_reasonis opaque. We have observed values likecapacity_protectionand have no public documentation of the full enum. Treat the string as a clue, not a contract.- The cache TTL drop and the capacity throttle hit at different points in the request path. ClaudeMeter shows you the dollar consequence on
used_credits, not the per-request cause. Causality has to be inferred from the timing. - Make-good credits are subject to the same enforcement as paid metered usage. Once they are spent or disabled, the only path forward is the same as before the apology: wait for the rolling windows to age out.
See your credit line before it flips
ClaudeMeter is free, MIT-licensed, and reads /overage_spend_limit every 60 seconds. The menu bar shows the dollar balance and surfaces BLOCKED the moment out_of_credits flips. No cookie paste on the extension route.
Need help wiring your own caller to /overage_spend_limit?
Send us your decoded response and we will help you handle the BLOCKED states the same way ClaudeMeter does.
Frequently asked questions
What does 'funny money' mean in this context?
It is shorthand for a balance that looks real on a settings page but cannot reliably be spent in the moment a user wants to spend it. In the Anthropic 2026 case, the make-good credits (a one-month subscription refund, a $200 extra-usage promo, monthly metered allowances) are denominated in real dollars. They sit in /api/organizations/{org_uuid}/overage_spend_limit. But three things conspire against you actually using them: the rolling-window throttle stops you before you can spend down the credit, the prompt cache change inflates the per-prompt burn so the credit drains faster than the work you got out of it, and the server can flip an out_of_credits flag that disables the line entirely. The dollars are technically yours; the spending behaviour is not.
Where does the out_of_credits flag actually live?
In the OverageResponse JSON returned by GET https://claude.ai/api/organizations/{org_uuid}/overage_spend_limit. The full struct is seven fields: is_enabled, monthly_credit_limit, currency, used_credits, disabled_reason, disabled_until, out_of_credits. ClaudeMeter decodes that struct in src/models.rs lines 30-40 and renders the boolean as the string BLOCKED in src/format.rs line 26. Three of those fields, out_of_credits, disabled_reason, and disabled_until, are not visible anywhere a local-log tool reaches.
When did Anthropic shorten the cache TTL?
The default Claude Code prompt cache TTL dropped from 1 hour to 5 minutes around April 2-3, 2026. The rollout was staggered, so different users saw the change on different days; some retained 1-hour caching well past the cutover. One Reddit user documented the impact precisely: 39 cache busts per day at $6.28 before April 2, and 199 cache busts per day at $15.54 after, a $277.80 monthly delta on identical work. xda-developers and The Register covered the change after the fact. The reason it matters here is that those extra cache rebuilds get charged at the cache-write rate against the same credit balance Anthropic gave you to make up for the shortage.
What does the capacity shortage have to do with credits I already paid for?
Anthropic tightened consumer-plan rolling windows on weekday peak hours (8am to 2pm Eastern) starting late March 2026. The product lead acknowledged users were 'hitting usage limits in Claude Code way faster than expected' on March 31. When the 5-hour or 7-day window trips, the Claude Code client falls through to extra-usage billing, which spends down your make-good credit instead of returning a 429. So 'I bought you a month' becomes 'I bought you a few peak-hour blocks of throttled inference', and you have no way to see the substitution happening unless you read the right server field.
Why can't ccusage or Claude-Code-Usage-Monitor see this?
Because they read the local JSONL transcript on disk and sum input/output tokens. /overage_spend_limit is a different endpoint on a different host (claude.ai, not platform.claude.com). It returns dollar amounts in cents, plus the three diagnostic fields above. There is no token field on that endpoint, and there is no overage field in the local transcript. The two data sources do not overlap; a tool that walks JSONL has no way to find out the credit line is BLOCKED until you fail a request and read the error body.
How does ClaudeMeter render the BLOCKED state?
src/format.rs lines 24-40. The CLI prints a line like '$12.40 / $200.00 (6%) BLOCKED until Sat May 10' when out_of_credits is true and disabled_until is set. The menu bar reads the same struct and surfaces the BLOCKED string under the extra-usage row. If disabled_reason is present, the binary appends it. The point is that a single field flip on the server changes one boolean in OverageResponse and the UI reflects it on the next 60-second poll.
Is this endpoint documented anywhere?
No. It is the same endpoint the claude.ai/settings/usage page renders from, and Anthropic does not publish its shape. ClaudeMeter is open source under MIT and the struct is at /Users/matthewdi/claude-meter/src/models.rs (or github.com/m13v/claude-meter/blob/main/src/models.rs). The JSON parse uses serde with strict typing, so if Anthropic renames a field, the next poll fails loudly with the parse error rather than silently misreporting.
Will Anthropic credit me back if my credits get blocked?
There is no automatic refund mechanism. The official help center page on requesting a refund covers paid plan refunds, not extra-usage credit reversals. Reading the disabled_reason field on the day it flips is the closest thing to evidence; ClaudeMeter logs the snapshot to a localhost bridge, so you can grep your own historic snapshots if you ever need to argue the case with support. We are not a billing claim service; we just expose the field.
Does any of this apply to API customers on platform.claude.com?
No. The Console API on platform.claude.com has its own Usage and Cost endpoint, its own anthropic-ratelimit-* response headers, and its own credit ledger. The credits you buy on the API console are separate from the make-good credits Anthropic dropped on consumer plans. The shortage and the cache TTL change have hit Claude Code (which runs on consumer auth in many flows) and claude.ai chat. If you only consume via the public API, you are seeing a different surface and this page is not for you.
What can I do today to stop this from being a black box?
Three things. One: install ClaudeMeter and the browser extension; the menu bar shows your extra-usage dollars and any BLOCKED suffix without you opening the settings page. Two: keep the snapshots the bridge writes to localhost; they are JSON timestamps you can grep later. Three: when you hit a hard wall, check whether the wall is a 5-hour rolling window (the bucket on /usage), a weekly window (the seven_day bucket), or extra-usage being disabled (out_of_credits true on /overage_spend_limit). They look the same in Claude Code's error message; they have different recoveries.
Keep reading
Claude extra-usage balance: the dollar line in plain English
Two endpoints, three fields, one BLOCKED state. Where the $X.XX figure on /settings/usage actually comes from.
Server quota is a fraction with a private denominator
Why local token counters cannot equal the percent the settings page shows, and what claude-meter reads instead.
The seven reset clocks on your plan, not just one
Every Window field in /usage ships its own resets_at. The bucket at 100 percent is your real countdown.