Claude Fable 5 pricing starts at $10 per million input tokens and $50 per million output tokens on the Anthropic API. That is the whole story for most people who just want a number, but the full picture has a few moving parts worth knowing before you wire the model into production. Fable 5 launched on June 9, 2026, and Anthropic positions it as costing “less than half the price of Claude Mythos Preview.” This guide walks through every cost lever: the API rates, what you pay on Pro and Max plans, three worked examples with real arithmetic, and how Fable 5 lines up against cheaper models like Claude Opus 4.8. If you only need a fast cost check, the next section has it.
TL;DR
Claude Fable 5 costs $10 per million input tokens and $50 per million output tokens on the API. From June 9 through June 22, 2026, it is included free on Pro, Max, Team, and seat-based Enterprise plans. Starting June 23, 2026, usage on those plans draws on metered usage credits at the same $10/$50 token rates.
Claude Fable 5 pricing at a glance
Here are the headline numbers in one table. The “per 1K tokens” column is the same price expressed at a smaller unit, which is handy when you are sketching the cost of a single request.
| Token type | Price per 1M tokens | Price per 1K tokens | Notes |
|---|---|---|---|
| Input | $10.00 | $0.01 | Everything you send: prompt, system message, context, tool definitions |
| Output | $50.00 | $0.05 | Everything the model generates, including reasoning and tool calls |
The API model ID is claude-fable-5. Output tokens cost 5x what input tokens cost, which is normal for frontier Anthropic models and shapes most of the optimization advice later in this post. You can confirm the current rates any time on the Anthropic pricing page and in the models and pricing docs.
What you pay on the API
Anthropic bills two things separately, and you pay for both.
Input tokens are everything you send to the model on a request. That includes your prompt text, the system message, any prior conversation turns you replay for context, retrieved documents, and the JSON for any tools you define. These count at $10 per million, or one cent per thousand.
Output tokens are everything the model generates back. That is the visible answer plus any internal reasoning the model produces and any tool-call arguments it writes. These count at $50 per million, or five cents per thousand.
So a single request that sends 2,000 tokens in and gets 600 tokens back costs you 2,000 input tokens plus 600 output tokens, billed at their separate rates. There is no flat per-request fee on top. Your bill is purely the sum of input and output tokens across every call you make.
Anthropic describes Fable 5 as “less than half the price of Claude Mythos Preview,” which is the model’s positioning against the earlier preview frontier tier. The restricted sibling model, Claude Mythos 5, carries the identical $10 input and $50 output rate, so switching between the two does not change your per-token cost. If you want the conceptual background on the model itself before you budget for it, what is Claude Fable 5 covers the capabilities side.
Plan inclusion vs usage credits
Pricing on the API is one thing. What you pay inside a Claude subscription plan follows a different schedule, and the dates matter.
From June 9 through June 22, 2026, Claude Fable 5 is included at no extra cost on Pro, Max, Team, and seat-based Enterprise plans. During this window you can use the model on those plans without it counting against any metered balance. This is a launch-period promotion, not the permanent state.
On June 23, 2026, Fable 5 is removed from the included set on those plans. After that date, using Fable 5 on Pro, Max, Team, or seat-based Enterprise draws on usage credits, which means it is metered at the same $10 input and $50 output per-million-token rates you would pay on the raw API. Anthropic has said it plans to restore some standard plan access when capacity allows, so the post-June-23 state may soften later, but the credit-metered behavior is what to budget for right now.
Consumption-based Enterprise plans are different. Fable 5 is fully available there from launch with no inclusion window to worry about, since those plans bill by usage to begin with. If your access question is broader than billing, how to access Claude Fable 5 maps out every entry point.
The practical takeaway: if you are prototyping on a Pro or Max seat this week, you get free reign through June 22. Plan your heavier experiments accordingly, and if you expect sustained production traffic, model your costs against the $10/$50 API rates rather than the free window, because that is what you settle into.
Worked examples: what a real workload costs
Numbers per million tokens are abstract. Here are three concrete workloads with the arithmetic spelled out, so you can map your own usage onto them.
The formula is the same every time: (input tokens / 1,000,000) * $10 plus (output tokens / 1,000,000) * $50.
Example 1: a support chatbot turn
A typical customer-support turn carries some system instructions and a short conversation history, then returns a focused answer. Say 1,500 input tokens and 500 output tokens.
- Input: 1,500 / 1,000,000 * $10 = $0.015
- Output: 500 / 1,000,000 * $50 = $0.025
- Total: $0.04 per turn
Four cents a turn. If that chatbot handles 1,000 turns a day, you are looking at roughly $40/day, or about $1,200/month, before any of the cost levers in the next section. That is a useful gut check: chat-style workloads on Fable 5 stay cheap per call but add up at volume.
Example 2: a code-generation request
Code generation usually sends more context: the file you are editing, related snippets, and instructions. Say 8,000 input tokens and 3,000 output tokens for a substantial generated function with explanation.
- Input: 8,000 / 1,000,000 * $10 = $0.08
- Output: 3,000 / 1,000,000 * $50 = $0.15
- Total: $0.23 per request
Notice that even though you sent nearly 3x more input than output, output still dominates the bill at $0.15 of the $0.23. That 5:1 output-to-input price ratio is why trimming verbose generations saves real money.
Example 3: a long-horizon agent run
Agentic runs that read large codebases or documents and take many steps push input way up. Say 300,000 input tokens (lots of retrieved context replayed across steps) and 50,000 output tokens.
- Input: 300,000 / 1,000,000 * $10 = $3.00
- Output: 50,000 / 1,000,000 * $50 = $2.50
- Total: $5.50 per run
A single deep agent run lands around five and a half dollars. Run that 200 times a day across a team and you are at $1,100/day. This is exactly the workload where prompt caching pays off, because agents replay the same large context repeatedly. We will quantify that next.
How to cut your Claude Fable 5 bill
Once you have decided Fable 5 is the right model, these are the standard Anthropic API features that bring the cost down. None of them require special access.
- Prompt caching. Cache reads cost about 0.1x the input price, so cached input runs around $1 per million instead of $10. Cache writes cost about 1.25x input (around $12.50 per million for the 5-minute TTL), so caching pays off when you reuse the same context across many requests. Take the agent run from Example 3: if 250,000 of the 300,000 input tokens are stable context served from cache, that input drops from $3.00 to about $0.25 (250K cached reads at $1/M = $0.25, plus 50K fresh input at $10/M = $0.50). The whole run falls from $5.50 to roughly $3.25. For agents and chatbots that replay a large system prompt, caching is the single biggest cost change you can make.
- Batches API. For work that does not need an immediate answer, like overnight document processing or bulk classification, the Batches API runs at about 50% off. That turns the $10/$50 rates into roughly $5/$25, which is Opus-tier pricing for Fable-tier output. If your job tolerates a delay, this is close to free money.
- Right-size the model. Not every request needs Fable 5. Route the hard, novel reasoning to Fable and send routine traffic to Opus 4.8, Sonnet 4.6, or Haiku 4.5. A tiered router that sends 80% of calls to a cheaper model can cut a bill by more than half on its own.
- Trim max_tokens. Output is the expensive side at $50 per million. Set
max_tokensto what the task actually needs instead of leaving it wide open, and ask for concise answers in the prompt. Cutting a 3,000-token generation to 1,500 tokens halves the output cost of that call. - Stream responses. Streaming does not change the price per token, but it lets you stop generation early once you have what you need, and it improves perceived latency so you are less tempted to over-request. Combined with a tight
max_tokens, it keeps output spend honest.
Track Claude Fable 5 spend with Apidog
The cleanest way to keep token costs visible while you build is to watch them on every request, not at the end of the month when the invoice arrives. Apidog is an API client you can use to send requests to the Anthropic API and inspect exactly what comes back.
When you call claude-fable-5 through Apidog, the response body includes a usage object with input_tokens and output_tokens for that request. Reading those two numbers tells you the precise cost of the call: multiply input tokens by $0.00001 and output tokens by $0.00005, add them, and you have the bill for that request down to the fraction of a cent. Doing this while you iterate on prompts shows you immediately when a change blows up your token count, long before it shows up in production.
A practical workflow: set up the Anthropic chat completions request in Apidog, save a few representative prompts as examples, and compare the usage numbers across prompt variations. You will quickly see which system-message edits add hundreds of input tokens and which response-format changes balloon output. That feedback loop is hard to get from the dashboard alone. Download Apidog to set this up, and pair it with the Claude Fable 5 API guide for the request structure. If you are watching budget closely, how to use Claude Fable 5 for free covers the no-cost paths during the inclusion window.
Apidog also keeps a request history, so you can look back at past calls and their token counts when you are estimating the cost of a new feature. Treating Apidog as your cost-inspection layer during development means there are no token surprises when traffic scales.
Claude Fable 5 pricing comes down to a simple pair of numbers, $10 input and $50 output per million tokens, with a free plan window through June 22 and metered credits after June 23. The rest is workload math and a few cost levers: cache your stable context, batch what is not urgent, and drop to Opus 4.8 or Sonnet 4.6 when the task does not need the frontier tier. Your next step is to wire up a single claude-fable-5 request and read the usage object so your estimates rest on real token counts. Download Apidog to send that first request and watch the cost in real time.
