Claude API Pricing Explained: Per-Million-Token Costs Across 12 Models
Breaking down the three-tier token rates of 12 Claude models, with real bills showing how model selection and caching determine cost.
The article maps out the API billing structure of Anthropic's 12 Claude models: three rates (input, cached input, output), no monthly subscription, prepaid credits starting at $10. Comparing actual prices on the aggregation platform UplinkSwitch with official list prices, it finds discounts of about 70% on output and 40%-47% on input are the biggest changes in cost structure. Two hypothetical bills show the gap: the same long-document task costs about $0.0033 on Haiku 5.5 versus $0.117 on Opus 5.5, a gap of over 35x. Cached input can be as low as 10% of the input rate, so long system prompts and RAG scenarios should prioritize cache reuse. The conclusion: model selection matters far more than micro-optimization—use the cheapest model that can complete the task.
Anthropic's Claude lineup has grown to 12 models, spanning from the flagship Fable 5.1 to the lightweight Haiku 4.5, with prices varying by more than two orders of magnitude. Understanding the per-million-token input, cache, and output rates is the first step to controlling the cost of an LLM application. This article breaks down the real cost of each model based on the live catalog of the aggregation platform UplinkSwitch and Anthropic's official list prices, and uses two typical request scenarios to make the bill crystal clear.
The Billing Logic of the Claude API: Three Rates
The Claude API bills by token, with three tiers per million tokens: input, cached input, and output. For every model, the output rate is several times the input rate, while cached input is only a small fraction of input. There are no seat fees or monthly plans—the cost of a request is simply the number of tokens it consumes multiplied by the corresponding rate of the chosen model.
This structure implies two optimization directions: reducing output tokens (e.g., constraining response length) tends to save more money than compressing input; and cache hits can dramatically lower the cost of repeated long contexts. For applications that repeatedly send the same system prompt or long document, how well you leverage cache rates directly determines the unit economics.
What is a token: A token is the smallest unit of text a model processes, and it does not strictly equal a character or a word. In English, one token roughly corresponds to 0.75 words; in Chinese, one character usually takes up 1 to 2 tokens (depending on the tokenizer). So the "per-million-token rate" actually measures the "word throughput cost" of the model reading and writing text.
How cached input works: When the prefix of a request (such as a system prompt or long document) is exactly identical to a previous request, the API reuses the already-computed KV cache, and these tokens are billed at the cache rate, typically only about 10% of the input rate. Caching has a minimum prefix length requirement (varying by model, commonly 1024 tokens), and the cache has a limited lifetime (usually a few minutes to an hour); after expiration, it must be rewritten and billed at the input rate.
Why input and output differ by several times: Generating output tokens requires autoregressive decoding token by token, which is far more compute-intensive than processing input in parallel; output length also directly affects latency. That's why every vendor's output rate is significantly higher than input, and constraining output length (e.g., setting max_tokens, asking for concise answers) is the most direct way to save money.
Overview of Prices for 12 Models
The table below compares UplinkSwitch's actual prices with Anthropic's official list prices, in USD per million tokens.
| Model | Input | Cache | Output | Official Input | Official Cache | Official Output |
|---|---|---|---|---|---|---|
| Claude Fable 5.1 | $6.00 | $0.15 | $30.00 | $10.00 | $0.25 | $50.00 |
| Claude Opus 5.5 | $2.10 | $0.12 | $6.00 | $4.00 | $0.20 | $20.00 |
| Claude Sonnet 5.5 | $1.20 | $0.12 | $3.00 | $2.00 | $0.20 | $10.00 |
| Claude Haiku 5.5 | $0.06 | $0.0125 | $0.15 | $0.10 | $0.01 | $0.50 |
| Claude Fable 5 | $3.00 | $0.30 | $15.00 | $10.00 | $1.00 | $50.00 |
| Claude Opus 5 | $1.50 | $0.15 | $7.50 | $5.00 | $0.50 | $25.00 |
| Claude Sonnet 5 | $1.20 | $0.12 | $3.00 | $2.00 | $0.20 | $10.00 |
| Claude Opus 4.8 | $1.50 | $0.15 | $7.50 | $5.00 | $0.50 | $25.00 |
| Claude Opus 4.7 | $1.50 | $0.15 | $7.50 | $5.00 | $0.50 | $25.00 |
| Claude Opus 4.6 | $1.50 | $0.15 | $7.50 | $5.00 | $0.50 | $25.00 |
| Claude Sonnet 4.6 | $1.80 | Input rate | $9.00 | $3.00 | Input rate | $15.00 |
| Claude Haiku 4.5 | $0.60 | $0.06 | $3.00 | $1.00 | $0.10 | $5.00 |
The lowest price belongs to Claude Haiku 5.5: $0.06 input and $0.15 output. One detail worth noting: Sonnet 4.6 has no separate cache rate—cached tokens are billed at the input rate, meaning this model cannot enjoy the cache discount.
Model naming and generations: Claude model names consist of "family + version number," with families ordered from highest to lowest as Fable, Opus, Sonnet, and Haiku, corresponding to flagship, high-performance, balanced, and lightweight tiers. Within a family, a higher version number usually means newer and more capable, but prices are not necessarily monotonic—for example, Fable 5.1's input price ($6.00 actual) is actually lower than Fable 5's ($3.00 actual)? In fact, Fable 5.1's actual price of $6.00 is higher than Fable 5's $3.00, reflecting the new-flagship premium. When choosing, prioritize the capability your task requires over the version number—older-generation models often offer better value after price cuts.
Differences between aggregation platforms and official list prices: Aggregation platforms like UplinkSwitch resell API credits below official catalog prices through bulk purchasing or routing optimization, with discounts usually concentrated on the output side. But note: aggregation platforms may differ from direct official access in rate limits and feature completeness (such as caching and batch processing), so SLA and compliance should be evaluated for critical production environments. The "official price" in the table refers to Anthropic's publicly listed prices, which serve as the benchmark for comparison.
Two Real Bills: Chat Turns and Long Documents
Abstract rates are less intuitive than concrete bills. Assume one chat turn consumes 2,000 input tokens and 500 output tokens, and one long-document request consumes 50,000 input tokens and 2,000 output tokens (both hypothetical values, without cache hits).
| Model | Chat Turn (Official) | Chat Turn (Actual) | Long Document (Official) | Long Document (Actual) |
|---|---|---|---|---|
| Claude Opus 5.5 | $0.018 | $0.0072 | $0.24 | $0.117 |
| Claude Sonnet 5.5 | $0.009 | $0.0039 | $0.12 | $0.066 |
| Claude Haiku 5.5 | $0.0005 | $0.0002 | $0.006 | $0.0033 |
Breaking it down: Claude Opus 5.5's actual prices on the aggregation platform are $2.10 input and $6.00 output, versus official $4.00 and $20.00—47% lower on input and 70% lower on output. Sonnet 5.5 and Haiku 5.5 show a similar discount structure: 40% lower input and 70% lower output. The 70% discount on the output side is the most significant change in the cost structure—because output is already the dominant billing component.
Take Haiku 5.5: a single long-document request costs only $0.0033, meaning processing 10,000 documents of the same scale costs about $33. The same task on Opus 5.5 would cost $117—a gap of over 35x. Model selection affects the bill far more than any micro-optimization.
Cached Input: The Underestimated Cost Lever
When a request repeats a prefix the API has already seen—such as a long system prompt or document—the response marks those tokens as cached and bills them at the cache rate in the table. Models without a cache rate bill them at the input rate.
Take Sonnet 5.5: its cache rate of $0.12 versus input of $1.20 is 90% cheaper. If an application carries a 20,000-token system prompt with every request, a cache hit drops that portion from $0.024 to $0.00012 (at actual prices). For RAG or document-QA applications, cache design should take priority over model selection.
Cache hit rate: Whether caching saves money depends on the hit rate. If the prefix differs on every request (e.g., placing the user's question first), the cache will almost never hit, rendering the cache rate moot. Best practice is to put stable content (system instructions, knowledge-base documents, few-shot examples) at the very front of the prompt and variables (user input) at the end, maximizing the length and reuse frequency of the cacheable prefix.
Cache write cost: Some APIs charge a "cache write" fee slightly higher than normal input (Anthropic officially charges 1.25x the input price) for the first write of a prefix to cache, and only subsequent hits enjoy the discount. Caching therefore suits scenarios where "the same prefix is requested multiple times"; a one-off request may actually be more expensive due to the write premium. When evaluating cache benefits, include the write cost and expected hit count in the calculation.
How to Call and Selection Advice
The Anthropic SDK accepts two parameters, base URL and key, and every Claude model ID in the table works generically; the OpenAI SDK is also compatible. Here is a Python example:
from anthropic import Anthropic
client = Anthropic(
base_url="https://api.uplinkswitch.com/v1",
api_key="sk-uplink-live-...",
)
message = client.messages.create(
model="claude-opus-5-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Summarize this in one line."}],
)
print(message.content[0].text)
On subscriptions: there is no monthly plan; prepaid credits start at $10, and each top-up locks in the price for 30 days.
As a rule of thumb, use the cheapest model that can complete the task. Haiku suits short text, high concurrency, and sub-agent tasks; Sonnet covers most coding and writing scenarios; Opus is reserved for cases where "a harder answer is worth the premium." The most pragmatic approach is to run the same prompt across models and compare output quality against the bill.
FAQ
Which models does the cache discount apply to? Except for Sonnet 4.6, all models in the table have a separate cache rate. Sonnet 4.6 bills cached tokens at the input rate.
How often are prices updated? Prices on the original page are taken from the live catalog and re-read on each load; official list prices follow Anthropic's pricing page.
How do I estimate my own usage cost? Export your usage records and re-price them to intuitively compare bills across models and providers.
One-line Summary
Breaking down the three-tier token rates of 12 Claude models, with real bills showing the decisive impact of model selection and caching on cost.
Paragraph Summary
The article systematically maps out the API billing structure of Anthropic's 12 Claude models: billed at three rates—input, cached input, and output—with no monthly subscription and prepaid credits starting at $10. By comparing actual prices on the aggregation platform UplinkSwitch with official list prices, it notes that discounts of about 70% on the output side and 40%-47% on the input side are the most significant changes in the cost structure. Two hypothetical bills—a chat turn and a long document—illustrate the price gap: the same long-document task costs about $0.0033 on Haiku 5.5 versus $0.117 on Opus 5.5, a gap of over 35x. Cached input can be as low as 10% of the input rate, so long system prompts and RAG scenarios should prioritize cache reuse design. The conclusion: model selection affects the bill far more than micro-optimization, so use the cheapest model that can complete the task.
Related articles
Python 3.15 New Feature: Is the sentinel Type Better Than None?
Python 3.15 adds the sentinel type, using named unique sentinel objects to replace None and bare object(), resolving confusion among missing values, explicit emptiness, and invalid input while avoiding type hint failures.
Deep Learning's Three Architectures and the Universal Approximation Theorem: A Complete Guide to MLPs, CNNs, and Transformers
Explaining the inductive bias differences among MLP, CNN, and Transformer, the existence meaning of the Universal Approximation Theorem (UAT), and the role of Taylor expansion in approximation analysis, while clearing up common misconceptions.
GitLab Emergency Patch Release: Analysis of Critical Security Fixes
GitLab releases critical patch 19.5.1, sparking 355 points of discussion on Hacker News. This article analyzes the background, upgrade steps for self-hosted instances, and verification points to help DevOps teams respond quickly to security updates.