Claude Fable 5.1 API Pricing: Calculate Tokens, Caching, and Batch Costs

Claude Fable 5.1's standard API rates are $10 per million uncached input tokens and $50 per million output tokens. A cached input token has a different price: $12.50 per million to write a five-minute cache, $20 to write a one-hour cache, and $0.25 to read either. Message Batches cut these token rates in half. These are direct Claude API prices in USD, checked September 19, 2026; a consumer Claude subscription does not pay your API bill. Official pricing

For a quick budget, 10 million uncached input tokens plus 2 million output tokens costs $200 at standard global rates, or $100 through Batch. For an accurate bill, split input into uncached tokens, cache writes, and cache reads before applying discounts. A single blended “input price” will hide the very savings you are trying to measure.

The Fable 5.1 rate card

The following rates apply to model ID claude-fable-5-1 on the direct Claude API with standard global inference. All prices are USD per million tokens, not per request. The Batch column includes the 50% token discount; do not halve it again. Token and Batch pricing

Two details matter when comparing these prices with earlier models. First, the 75% reduction from Fable 5 concerns cache reads, which fell from $1 to $0.25 per million tokens. It is not a 75% reduction in every application's bill. Second, Fable 5.1 uses the same token rates throughout its one-million-token context window. There is no long-context rate premium, but sending more tokens still increases the charge. Fable 5.1 model overview

If you are choosing a model or migrating an existing integration, use our Fable 5.1 migration and model-selection guide. The calculations here concern the cost of the Fable 5.1 requests you actually send.

Reconstruct the bill from the usage fields

Start with the response's usage object. In a cached request, input_tokens counts only uncached input. Cache writes and reads have their own fields. Adding all input tokens together and multiplying by $10 will therefore produce the wrong answer. Cache usage accounting

Use five non-overlapping totals:

The aggregate cache_creation_input_tokens equals W5 plus W60. It is useful for checking totals, but it is not an additional billable category. Do not add the aggregate on top of its two subcategories. Total input for a request is U + W5 + W60 + R; keep those categories separate when calculating its price.

For raw token counts, standard global token cost in dollars is:

text
token_cost = (10 × U + 12.50 × W5 + 20 × W60 + 0.25 × R + 50 × O)
             / 1,000,000

Consider this hypothetical month's usage. It includes both cache lifetimes to show how each charge contributes; it is a worked example, not a measured customer invoice.

If exactly the same usage categories were billed through Batch, the token total would be $50. That arithmetic does not predict whether Batch will achieve the same cache-read volume; asynchronous execution changes the chance of a hit.

Count billed output, including thinking tokens, once. Visible answer length alone understates output usage when the model also performs reasoning, while adding an already-included thinking breakdown to output_tokens overstates it. Fable 5.1 uses adaptive thinking; use the reported usage rather than estimating the bill from the displayed prose. Thinking-token billing

When prompt caching pays for itself

Caching trades a more expensive first write for much cheaper reuse of an identical prompt prefix. For Fable 5.1, the cacheable prefix must contain at least 512 tokens. A shorter prefix is processed uncached without a cache error. Automatic caching can be enabled with top-level cache_control: {"type":"ephemeral"}; the default lifetime is five minutes, with ttl:"1h" available for one hour. Prompt-caching requirements and configuration

For an unchanged prefix written once and then read H times before expiration, the prefix-only costs are:

text
No cache:       prefix_tokens × 10 × (1 + H) / 1,000,000
5-minute cache: prefix_tokens × (12.50 + 0.25 × H) / 1,000,000
1-hour cache:   prefix_tokens × (20 + 0.25 × H) / 1,000,000

The five-minute cache saves money on the first successful reuse. The one-hour cache needs two successful reuses, or three uses in total, to cost less than sending that prefix uncached. These thresholds concern the prefix alone, with one write and actual cache hits; changing output length or repeatedly rebuilding the cache changes the application's overall result.

For a 100,000-token prefix, the difference is easy to see:

Choose the lifetime around the gaps between requests. A hit refreshes the cache lifetime without another write fee, although the read itself remains billable. That means requests spaced less than five minutes apart can keep a five-minute cache useful across a much longer session. The clock starts when a request writes or reads the cache, not when its response finishes. Cache lifetime and refresh behavior

A one-hour cache can make sense when useful reuses are too far apart for the five-minute lifetime. It does not help merely because a job runs for an hour. If every request changes an early part of the prefix, the longer lifetime cannot create a match.

Place stable content before changing content, and watch the usage fields after deployment. Changes to earlier system instructions, tools, messages, or the top-level effort setting can invalidate the relevant cache. If the expected reads appear as writes or uncached input instead, investigate that mismatch before extrapolating savings. Our cache-miss troubleshooting guide covers related symptoms in Claude Code; the direct API's response usage remains the source for the calculations on this page.

Batch cuts token rates, but cache hits still need to happen

Message Batches suit work that can wait for asynchronous results: offline evaluations, document processing, or scheduled extraction, for example. There is no response streaming. Most batches finish within an hour, but processing can take up to 24 hours, with unfinished requests expiring. If your application must answer an interactive request immediately, those completion times do not meet the same requirement. Message Batches documentation

The Batch discount stacks with prompt-caching rates. A cache read therefore costs $0.125 per million tokens through Batch, while a five-minute cache write costs $6.25. The discount applies to both categories; it does not turn writes into reads. Batch and cache pricing

Cache hits inside a batch are best effort because requests run asynchronously and concurrently. Submitting many requests with the same prefix does not guarantee one write followed by hits for everything else. A one-hour lifetime can help preserve a cache across processing gaps, but it also raises the write price. Budget from the observed split between writes, reads, and uncached input in a representative batch.

For reliable cost tracking, match returned results by custom_id; their order is not guaranteed. Count successful results and inspect unsuccessful ones separately. Requests with errored, canceled, or expired results are not billed under the documented Batch rules. A request that succeeds technically but fails your own quality checks still incurs usage, and a successful retry adds another charge. Batch results and billing

This makes cost per accepted result more useful than cost per submitted request when comparing production runs:

text
cost_per_accepted_result = total_billed_cost / number_of_accepted_results

Keep retries in the numerator. Otherwise a workflow that produces cheap but unusable responses can appear less expensive than it really is.

Apply geography and tool charges after the token calculation

On the direct Claude API, setting inference_geo:"us" adds 10% to all token categories, including cache writes, cache reads, and output. Standard global inference is the default. This geography multiplier stacks with Batch: start with the standard token calculation, multiply by 0.5 for Batch if applicable, then by 1.1 for US-only inference if selected. Data-residency pricing

For the uncached example of 10 million input and 2 million output tokens:

These figures exclude separate service charges and taxes. Amazon Bedrock and Google Cloud have their own regional pricing; do not carry the direct API's 1.1 multiplier into a different provider's invoice without checking that provider's terms.

Tools can affect both parts of the bill. Tool definitions, results, and conversation history contribute input tokens. Some server tools also have separate fees: web search is listed at $10 per 1,000 searches, in addition to token costs. Do not automatically apply Batch's 50% token discount to a per-tool service charge. Tool-use pricing

For a practical monthly estimate, first measure representative requests, keeping the five token categories separate. Then group them by standard versus Batch processing and by inference geography, apply the appropriate rates, and add tool charges. Record how many results your application accepted as well as how many requests it sent. That gives you a budget you can reconcile with usage, and a way to tell whether a cheaper rate actually reduced the cost of completing the work.