The sticker rate is the cheap part. Because the Claude API is stateless, every turn re-sends the whole conversation, so your bill grows quadratically with length - by turn 20 you are paying to re-read one chat 17 times over. Below: current prices for every model, the math on what a real conversation costs, and how PromptCrunch trims that growing history to cut your input bill up to 75%.
Every price is per million tokens, billed separately for input (what you send) and output (what the model writes back). Your real Claude API cost is both rates times every token a live conversation sends - and that token count climbs fast once the history piles up.
| 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 |
Anthropic adds models and shifts prices often - confirm the current numbers on the official Anthropic pricing page before you budget. Prompt caching changes these rates too; the full breakdown is in the caching section 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 sets your bill for any chat, support, or tutoring product. Here is how to kill it.
Prompt caching is Anthropic's built-in discount on re-sent tokens. When it fits your traffic it genuinely helps - here is exactly how the billing works, and where it stops.
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.
Apply that 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. Input drops from about $0.58 to roughly $0.13 - nearly 80% off, in the best case.
The whole best case rides on three words: the prefix never changes. Caching is an exact prefix match. Edit an earlier message, branch the thread, or tweak the system prompt, and everything after the change re-bills at full rate; turns that land after the TTL expires pay the write premium again. Steady, linear conversations cache beautifully. The branching, edited, human ones - the ones your users actually have - often do not. That gap is exactly where PromptCrunch earns its keep, and the two stack. See PromptCrunch vs prompt caching.
Three ways to attack it. One was built for exactly this problem: a conversation that gets longer, and more expensive, every single turn.
1. Compress the history before it ships. This is what PromptCrunch does, aimed straight at the part of the bill that grows. It is a proxy: point your SDK's base URL at it, and it shrinks the older turns of a conversation before forwarding to Anthropic. On long, prose-heavy conversations - support, tutoring, coaching, companion chat - that is up to 75% fewer input tokens, with the same responses coming back. Recent turns, code, JSON, and IDs pass through verbatim. Two lines of setup.
2. Prompt caching. Built into the API and worth switching on. It is strongest when you resend the same prefix - a big stable system prompt, an agent loop replaying the same tool definitions. Caching discounts the part that repeats; PromptCrunch shrinks the part that grows; run both. Its limits are the exact-prefix match and TTL expiry covered above.
3. A smaller model. The same 20-turn conversation on Claude Haiku 4.5 ($1 / $5) runs about $0.26 instead of $0.77 - a 66% cut for a one-line change, if Haiku holds quality on your task. Worth testing on real traffic, and it stacks with compression too.
On a 40-prompt Claude Sonnet benchmark, PromptCrunch dropped the input bill from $2.56 to $0.64 - a 75% cut, with identical responses. The longer and more prose-heavy your conversations run, the more it takes off.
It is safe by design. Requests already using prompt caching pass through untouched - we never break a cache to manufacture savings, so you are never worse off than going direct. Everything else, we crunch. Structured content - code, schemas, IDs, numbers - comes back byte-for-byte, no quality loss.
Start free: $5 in credit and 100 requests a day, no card. Run your own traffic through the savings estimator to see your number, or read how compression compares to caching. Flat pricing: Pro $29/mo, Agency $199/mo.
It is usage-based: you pay per token, input and output billed separately, at the rates in the table above. No flat fee, no monthly minimum. But the sticker rate barely predicts your bill - what drives it is how much conversation history gets re-sent on every call. PromptCrunch trims that history to cut input up to 75%.
Not for the API - Anthropic usage is pay-per-token, and the free tier on claude.ai is a separate chat product with no API access. Anthropic has at times issued small trial credits to new console accounts, but do not budget around them. PromptCrunch does have a free tier: $5 in credit and 100 requests a day, no card.
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. By turn 20 you are sending about 17x the tokens of turn 1. That re-sent history is exactly what PromptCrunch compresses.
Cache writes cost extra - 1.25x the input price for the 5-minute TTL, 2x for the 1-hour TTL - and cache reads then run about 0.1x. A 5-minute write pays for itself on the first hit; a 1-hour write needs two. Caching wins when you resend the same prefix; it does nothing for the part of the history that keeps growing, which is where PromptCrunch comes in.
About $0.77 at Sonnet 5 standard rates - $0.58 input, $0.20 output - for an 800-token system prompt, 250-token questions, and 650-token replies. Roughly 97% of that input spend is re-sent history. At 1,000 conversations a day it is about $23,000 a month, most of it re-processing text the model already read.
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 costs more than reading a prompt. Even so, multi-turn bills are usually input-dominated, because the growing history is re-billed as input on every call while each output token is paid for once.
Rates on this page were checked July 2026; the live source of truth is
platform.claude.com/docs/en/pricing.
Comparing providers? See LLM API pricing across providers or
OpenAI API pricing.