Claude won't bill you for a refusal. A fallback credit stops you paying twice.

Fable 5 is still off, twelve days on

Quick status check, because it frames everything below. Anthropic disabled Claude Fable 5 and Mythos 5 on June 12 after a US export-control directive, three days after launch. As of June 24 they are still down, with no restore date. A few outlets reported a mid-June comeback under nationality-based access controls; we could not confirm any of that against Anthropic's own statement, and at least one of those reports has since been corrected. So we are not repeating it. The model is dark.

What does carry forward is the billing machinery Anthropic shipped to handle Fable 5's refusals. Fable 5 was the priciest model the company ever listed, at $10 input and $50 output per million tokens, and it ran heavier safety classifiers than the rest of the lineup. That combination - expensive tokens plus a real refusal rate - is exactly the case where being charged for a blocked request would sting. So the docs spell out that you are not, and they add a credit to soften the retry. The rules read like Fable 5 housekeeping, but the no-charge-on-refusal half applies across the Claude API today, and the rest is a preview of how Anthropic prices premium-model refusals whenever Fable 5 comes back.

A refusal is a 200, not an error, and it is free

Here is the line that matters, straight from the model docs: you are not billed for a request that is refused before any output is generated. The request does not come back as a 4xx or 5xx either. It is a clean HTTP 200 carrying stop_reason: "refusal". That design choice has a billing consequence people get wrong: if your client treats any non-200 as a failure and retries on a loop, a refusal will not trigger that loop, which is good, but it also means a naive wrapper that re-sends on an empty body can quietly fan one refusal into several billed calls elsewhere.

The phrase to read carefully is "before any output is generated." If the model starts streaming and then stops itself partway, you have generated output tokens, and those are billable like any other. The free case is the hard pre-generation block, where the classifier rejects the request up front. So the cost of a refusal is not zero in every scenario - it is zero when the model never wrote a token, and a partial output bill when it began and bailed.

The fallback credit, and the cache trap it solves

A free refusal is the easy half. The expensive half is what you do next. Say you sent a long cached prompt - a big system block, a retrieved corpus, a code repository - and the model refused. You want to retry on a different model. Normally that retry has to warm its own prompt cache from scratch, and a cache write costs more than a cache read: on Opus 4.8 a five-minute cache write runs $6.25 per million tokens against a $0.50 cache read. Pay that twice on a 150K-token context and the rerouting itself, not the answer, is most of your bill.

The fallback credit closes that gap. You opt in with the beta header fallback-credit-2026-06-01. A refusal then returns a fallback_credit_token inside stop_details. Pass that token back as a top-level fallback_credit_token parameter on the retry and the retry bills the cached portion as a read rather than a write. You can verify it landed in the response usage: the cache_creation_input_tokens count drops and cache_read_input_tokens rises by the same amount. Here is what that does to a single refused-then-retried call with a 150K cached prompt and a 2K answer on Opus 4.8.

That is about 87% off the retry, and the entire saving is in the cache line - the output tokens cost the same either way. The bigger your cached context, the more the credit is worth, which is the point: it is built for exactly the large-prompt, premium-model workloads where a refusal would otherwise be doubly expensive. On a tiny prompt with no cache, the credit does close to nothing, because there was no cache write to refund.

Three places the credit quietly does nothing

The mechanism is narrow on purpose, and the limits are where teams will trip. The token expires five minutes after the refusal, so a retry queued behind a slow human review or a backed-off job will miss the window and pay the full cache write. The credit is one-time and stateless - one refusal buys one discounted retry, not a standing discount. And at launch the only sanctioned retry target is Opus 4.8, so a fallback chain that jumps to GPT-5.5 or Gemini gets no help from it.

The sharpest edge is server-side tools. The credit reprices cached input tokens, not tool execution, so if the refused request had already run tools on Anthropic's side, a tokenless retry will re-run and re-bill them. Batch is the other gap: tokens that came back through the Batch API cannot be redeemed for the credit at all. So the feature pays off most for synchronous, large-context, tool-light calls, and least for the batch and agentic paths where you might have assumed the savings would be biggest.

Two changes worth making

If you run anything refusal-prone on a premium model, two changes are cheap insurance. Stop treating a refusal as an error in your retry logic - branch on stop_reason so a refusal routes deliberately instead of tripping a generic retry loop and billing you for the detour. Then send the beta header and carry the fallback_credit_token straight into an Opus 4.8 retry while it is fresh, rather than dropping it through a queue that blows the five-minute clock.

The broader read: Anthropic is pricing refusals as a normal, expected event on its top tier, not an exception, which tells you to expect them and design for them. None of this brings Fable 5 back, and the credit only points at Opus 4.8 today. But if you want to know what a single refused call actually costs once cache writes and tool re-runs are in the picture, the numbers move a lot - so price your own before you assume a refusal is free. Drop your token counts into the cost calculator and the cache lines do the talking.

FAQ

Sources

• Anthropic docs - refusals and fallback (stop_reason, refusal billing)
• Anthropic docs - fallback credit (beta header, token, redemption rules)
• Anthropic docs - introducing Claude Fable 5 and Mythos 5 (refusal billing, pricing)
• Anthropic pricing - Opus 4.8 cache read and write rates
• Anthropic statement on Fable 5 and Mythos 5 access