The per-token rates are the easy part. The part that surprises people is that a multi-turn conversation re-sends its entire history on every call, so the bill grows quadratically with length. Here are the current prices, what a real conversation costs, and the honest ways to bring it down.
All prices are per million tokens, billed separately for input (what you send) and output (what the model generates). Your total Claude API cost is the sum of both, multiplied by however many tokens a real conversation sends, which is almost always more than the raw per-token rate suggests.
| Model | Input ($/1M tokens) | Output ($/1M tokens) | Notes |
|---|---|---|---|
| Claude Fable 5 | $10.00 | $50.00 | Flagship |
| Claude Opus 4.8 | $5.00 | $25.00 | |
| Claude Opus 4.7 | $5.00 | $25.00 | |
| Claude Opus 4.6 | $5.00 | $25.00 | |
| Claude Opus 4.5 | $5.00 | $25.00 | |
| Claude Opus 4.1 | $15.00 | $75.00 | Legacy pricing |
| Claude Sonnet 5 | $3.00 | $15.00 | Intro: $2.00 / $10.00 through Aug 31, 2026 |
| Claude Sonnet 4.6 | $3.00 | $15.00 | |
| Claude Haiku 4.5 | $1.00 | $5.00 | Cheapest |
Prices checked July 2026. Anthropic changes prices and adds models; always confirm on the official Anthropic pricing page before budgeting. Prompt caching modifies these rates: cache reads cost roughly 0.1x the input price, cache writes cost 1.25x (5-minute TTL) or 2x (1-hour TTL). More on that below.
The per-token price tells you almost nothing about your bill. The API is stateless, so every request re-sends the full history, and you pay input rates on all of it, every time.
Take a realistic support conversation on Claude Sonnet 5 at standard rates ($3 input / $15 output per million tokens). Assume an 800-token system prompt, 250-token user messages, and 650-token assistant replies. Each turn adds about 900 tokens of history that every later request re-sends.
| Turn | Input tokens sent | Input cost this call | Cumulative input cost |
|---|---|---|---|
| 1 | 1,050 | $0.003 | $0.003 |
| 5 | 4,650 | $0.014 | $0.043 |
| 10 | 9,150 | $0.027 | $0.153 |
| 15 | 13,650 | $0.041 | $0.331 |
| 20 | 18,150 | $0.054 | $0.576 |
Totals for the 20-turn conversation:
Input: ~192,000 tokens sent cumulatively, $0.58
Output: ~13,000 tokens generated, $0.20
Total: about $0.77 per conversation
Only ~5,800 of those 192,000 input tokens were new content. About 97% of the input spend was re-sent history.
By turn 20 you are sending an ~18,000-token history to ask a 250-token question. Scale that: at 1,000 such conversations per day, you are looking at roughly $770/day, or about $23,000/month, most of it spent re-processing text the model has already seen.
That quadratic growth, not the headline per-token rate, is what determines your bill for any conversational product. The rest of this page is about attacking it.
Anthropic's answer to the re-sent-history problem is prompt caching, and for many workloads it is the right one.
The billing works like this:
Two break-even facts fall straight out of those multipliers. A 5-minute cache write pays for itself on the first cache hit (you spend an extra 0.25x once, and each hit saves 0.9x). A 1-hour write needs at least two hits to break even (extra 1.0x up front, 0.9x saved per hit). If your traffic pattern will not reliably re-read a prefix within the TTL, the write premium is pure overhead.
Applied to the 20-turn conversation above: if every turn lands inside the 5-minute window and the prefix never changes, each call reads the prior history at ~0.1x and writes only the new ~900 tokens at 1.25x. The input side drops from about $0.58 to roughly $0.13, a cut of nearly 80%. That is a best case, and it is a genuinely good one.
The catch is the qualifier: the prefix never changes. Caching is an exact prefix match. Editing an earlier message, branching the conversation, or changing the system prompt invalidates everything after the change, and turns that arrive after the TTL expires pay the write premium again. Linear conversations with steady traffic cache beautifully; sparse or branching ones often do not. We wrote up a fuller comparison in PromptCrunch vs prompt caching.
Three levers, in the order we would honestly recommend trying them.
1. Prompt caching. Often the best tool, and it is built into the API. Use it when you have a large stable system prompt, an agent loop that replays the same tool definitions, or a linear conversation with turns arriving within the TTL. It costs nothing to adopt beyond setting cache_control breakpoints, and the best-case math above is real. Its limits: exact prefix matching, TTL expiry, and the fact that the history still grows, so you keep paying (cached rates) for an ever-longer prompt.
2. A smaller model. The same 20-turn conversation on Claude Haiku 4.5 ($1 / $5) costs about $0.26 instead of $0.77. That is a 66% cut for a one-line model change, if Haiku's quality holds for your task. Test it on your real traffic before assuming it will not; plenty of support and triage workloads run fine on Haiku.
3. Compress the history before sending it. This is what PromptCrunch does, so read this part with that in mind.
PromptCrunch is a proxy that shrinks old conversation history before forwarding to Anthropic. On long prose conversations (support, tutoring, coaching, companion chat) past roughly 20 turns, our own benchmarks show 60-75% fewer input tokens. Recent turns and structured content pass through verbatim.
The caveats matter. Coding-agent traffic saves almost nothing (0-7% measured), because code and tool output are preserved verbatim. And requests that already use prompt caching pass through completely untouched: we never break a cache to force savings, which also means we cannot add savings on top of a well-cached workload. If caching already covers you, skip us.
If your workload is long prose conversations, run your own numbers in the savings estimator, or read how compression compares to caching before deciding.
Claude API cost is usage-based: you pay per token, billed separately for input and output, at the rates in the pricing table above. There's no flat Anthropic API cost or monthly minimum. What a real conversation costs you depends less on the sticker price than on how much history gets re-sent on every call, which is what the conversation math below walks through.
No permanent free tier. API usage is pay per token. Anthropic has at times issued small trial credits to new console accounts, but do not budget around that; check the console signup flow for current offers. The free tier on claude.ai is a separate chat product and does not include API access.
Yes. The API is stateless: every request re-sends the full message history, and you pay the input rate on all of it every time. In the worked example above, turn 20 sends about 17x the tokens turn 1 does. This is the single most important thing to understand about conversational API costs.
Cache writes cost extra: 1.25x the input price for the 5-minute TTL or 2x for the 1-hour TTL. Cache reads then cost roughly 0.1x the input price. A 5-minute write pays for itself on the first cache hit; a 1-hour write needs at least two hits to break even.
With an 800-token system prompt, 250-token user messages, and 650-token replies, about $0.77 at Sonnet 5 standard rates: $0.58 of input and $0.20 of output. About 97% of the input spend is re-sent history. Your numbers will differ with message sizes; the shape of the math will not.
Across the current Claude lineup, output is priced at exactly 5x input ($10/$50, $5/$25, $3/$15, $1/$5). Generating tokens one at a time is more compute-intensive per token than ingesting a prompt. In practice, multi-turn bills are usually still dominated by input, because the growing history is re-billed as input on every call while each output token is only paid for once.
Prices checked July 2026; always confirm on the provider's official pricing page:
platform.claude.com/docs/en/pricing.
Comparing providers? See LLM API pricing across providers or
OpenAI API pricing.