Claude Fable 5.2 pricing starts at $8 per million input tokens and $40 per million output tokens. Fast mode costs $16 input and $80 output, twice the standard rates. Batch processing costs $4 input and $20 output. These are USD API rates, verified against Anthropic’s official documentation on November 10, 2026.
The useful question is how much faster output is worth for your workload. This guide separates token charges, cache costs, subscriptions, and example budgets. If you’re upgrading from the original model, the older Fable 5 pricing breakdown provides historical context; use the 5.2 rates below for new estimates.
Claude Fable 5.2 API pricing at a glance
| Billing route | Input per million tokens | Output per million tokens | Suitable workload |
|---|---|---|---|
| Standard | $8 | $40 | Interactive work without a speed premium |
| Fast mode | $16 | $80 | Work where faster generation matters |
| Batch API | $4 | $20 | Asynchronous processing |
Anthropic’s pricing documentation lists these rates. For an identical count of ordinary input and output tokens, fast mode costs twice standard, while batch costs half standard. Fast mode and the Batch API cannot be combined.
Fable 5.1’s listed standard rates are $10 input and $50 output. The 5.2 rates are therefore 20% lower for the same token counts. That comparison doesn’t predict your total savings: an agent can change its output length, tool usage, or number of attempts after a model upgrade.
The full context window uses standard per-token pricing. Don’t import an older model’s long-context surcharge into a Fable 5.2 spreadsheet. A larger prompt still costs more because it contains more billable tokens.
How much does a Fable 5.2 request cost?
For an uncached request without separately billed tools, multiply input tokens by the input rate and output tokens by the output rate. Divide each token count by one million before multiplying. Add the two charges. Use observed usage across every request when estimating an agent workflow.
Standard USD = input_tokens / 1,000,000 * 8
+ output_tokens / 1,000,000 * 40
Fast USD = input_tokens / 1,000,000 * 16
+ output_tokens / 1,000,000 * 80
These illustrative calculations assume ordinary uncached input, global routing, no additional tool fees, and no negotiated discounts. They aren’t measured benchmarks or quotes for a production deployment.
| Example workload | Input tokens | Output tokens | Standard | Fast | Batch |
|---|---|---|---|---|---|
| Short response | 2,000 | 500 | $0.036 | $0.072 | $0.018 |
| Code review | 20,000 | 5,000 | $0.36 | $0.72 | $0.18 |
| Agent workflow, summed across calls | 100,000 | 20,000 | $1.60 | $3.20 | $0.80 |
For the last row, standard input costs $0.80 and output costs another $0.80. At 1,000 identical workflows, the token-only estimate becomes $1,600 standard or $3,200 fast. Batch would be $800 if the work fits asynchronous processing.
An agent’s final answer is only one part of its consumption. Replayed context, tool definitions, tool results, and generated tool calls affect the total. Count the full workflow rather than estimating from the visible answer’s length.
Keep a separate column for failed attempts that consumed tokens. A workflow that needs a second complete attempt can exceed the estimate even if its final response looks short.
Is Claude Fable 5.2 fast mode worth the premium?
Fast mode uses the same model with faster inference. Anthropic reports up to 2.5 times higher output tokens per second, with the benefit focused on generation speed rather than time to first token. The price premium is 2x. Decide using measured end-to-end time and cost for your own workload.
The fast-mode documentation makes that distinction explicit. A workflow also spends time reading files, running tests, waiting for tools, and processing inputs. Those stages limit the overall speedup.
Consider a hypothetical $1.60 standard workflow whose fast-mode equivalent costs $3.20. The premium is $1.60. If your timing experiment shows it saves two minutes, the break-even value of that saved time is $48 per hour: $1.60 divided by two sixtieths of an hour. This is a decision example, not a measured Fable result.
Fast mode is a reasonable candidate when a person is waiting for a long generation. Start with standard for unattended jobs. Use batch when completion can be asynchronous. Compare accepted results, because faster output has little value if you still need the same amount of correction.
Prompt caching and other billing conditions
Fable 5.2 standard-mode cache writes cost $10 per million tokens for five minutes or $16 for one hour. Cache reads cost $0.20 per million tokens. Fast-mode pricing uses the same cache multipliers on its higher input rate. Separate cached and uncached tokens before calculating your total.
| Input category | Standard per million | Fast per million |
|---|---|---|
| Ordinary input | $8 | $16 |
| Five-minute cache write | $10 | $20 |
| One-hour cache write | $16 | $32 |
| Cache hit | $0.20 | $0.40 |
The fast cache figures above are calculated from Anthropic’s documented multipliers: 1.25x for five-minute writes, 2x for one-hour writes, and 0.025x for Fable 5.2 reads.
For example, reading a cached 100,000-token prefix costs $0.02 at standard speed. Creating that prefix with a five-minute cache write costs $1.00. Add new uncached input and generated output separately; a cache hit doesn’t discount the whole request.
Standard and fast requests don’t share cached prefixes. Falling back from fast to standard causes a prompt cache miss, according to Anthropic. Keep speed choice in your cost records so a change in cache behavior doesn’t look like an unexplained price increase.
Other documented conditions also affect estimates:
- US-only inference applies a 1.1x multiplier across token categories on supported first-party routes.
- Server-side tools can carry additional charges; include the tools you actually enable.
- Partner-operated cloud platforms have their own pricing. Google sets Google-managed fast-mode prices.
- Fast mode has separate rate limits and isn’t available with a Priority Tier commitment.
A premium speed setting doesn’t reserve unlimited capacity. Check your account limits before planning a burst of parallel agent runs.
API billing versus Claude subscriptions
API token rates describe metered developer usage. A Claude subscription has its own included usage and eligibility rules. Some paid plans also include claimable API credits, which offset API consumption in a linked Console organization. Credits don’t make token rates zero or remove rate limits.
The official API credits guide currently lists monthly credits for eligible Max, Ultra, and Team plans. You must link a Console organization to claim them. Unused credits expire each billing cycle without rollover, and they apply to the Claude API rather than partner cloud platforms.
Those API credits don’t cover Claude Code or extra usage in Claude apps. Keep three budgets separate: your subscription payment, included product usage, and API consumption after credits. Check the linked organization’s balance rather than assuming your subscription pays every API invoice.
The launch announcement also describes temporary extra usage for eligible paid subscribers. That’s a launch promotion, so don’t build a recurring production budget around it.
Where is Fable 5.2 fast mode available?
Anthropic lists Fable 5.2 fast mode on Claude Code, the Claude Platform, Google Cloud through Anthropic-managed and Google-managed routes, and Microsoft Foundry with Anthropic hosting. Standard Fable 5.2 has broader platform availability. Verify the specific deployment and its billing owner before assuming that model availability includes fast mode.
On the first-party Messages API, the model ID is claude-fable-5-2; fast mode is selected with speed: "fast". Inspect usage.speed in the response. Microsoft Foundry uses a separate fast deployment model, claude-fable-5-2-fast, instead of the same request parameter.
The fast-mode docs list default fast limits for Start, Build, and Scale tiers. Evaluation-tier organizations need to move to an eligible tier. Check the Console’s current limits for your organization before promising throughput to a customer.
Let your agent validate usage with Apidog CLI
Use Apidog CLI to have your coding agent create a repeatable usage-checking case around your Fable integration. Give it a small response cap and one paid test call. Store credentials in your environment, and ask it to inspect usage fields before calculating costs.
Install the CLI, then authenticate with your Apidog personal access token:
npm install -g apidog-cli@latest
apidog login --with-token <YOUR_APIDOG_TOKEN>
Follow the Claude Code integration guide for agent setup. Give your agent this prompt:
In my Apidog project, create one test case for my Fable 5.2 Messages
endpoint. Use the existing credential environment and a small output cap.
Assert success and numeric input/output usage. For a fast request,
check usage.speed is fast. Run once, report usage and latency, and
calculate token cost with today's official rates. Do not loop or retry
paid tests without my approval. Keep secrets out of reports.
The agent checks the resource schema and available category before writing its payload. These command forms were verified with Apidog CLI 2.2.12 help:
apidog test-case category --project <projectId>
apidog cli-schema get test-case-create
apidog cli-schema validate test-case-create --file case.json
apidog test-case create --project <projectId> --file case.json
apidog run --test-case <caseId> --project <projectId> -e <envId> -r cli,json
Ask the agent to set a valid category ID from the category response. For option details, use the run command reference. This is a reproducible test template, not a claim that we ran paid Fable benchmarks for this article.
FAQ
What is Claude Fable 5.2 pricing per million tokens?
Standard API usage costs $8 input and $40 output. Fast mode costs $16 input and $80 output. Add cache operations, tools, and applicable routing modifiers separately.
Is fast mode a different model?
No. Anthropic describes the same model running with faster inference. Its up-to-2.5x claim concerns output tokens per second, not guaranteed whole-task speed.
Can I combine fast mode with batch discounts?
No. Anthropic says fast mode isn’t available through the Batch API. Choose asynchronous batch processing or interactive fast mode according to your workload.
Does a Claude subscription cover all API usage?
No. Eligible plans offer claimable API credits under specific conditions. Track their balance and expiry in the linked Console organization, separately from Claude app and Claude Code usage.
How should I budget an agent workflow?
Sum usage across calls, separate cache categories, record the speed used, and include repeated attempts. Use a small agent-driven Apidog test to validate your integration before scaling traffic.
