The Vibe Father
As of July 24, 2026 the Anthropic price sheet runs from $1/$5 per million tokens for Haiku 4.5 up to $10/$50 for Fable 5 and Mythos 5, with the new Claude Opus 5 sitting at $5/$25 — the same rate as Opus 4.8 and half of Fable 5.
This is the complete reference, every current model, the two discounts that matter more than model choice, and the traps that make a cheap model expensive. If you want the effort-level dimension specifically, read the Opus 5 pricing and effort guide.
The full price sheet
| Model | Input per 1M | Output per 1M | Position |
|---|---|---|---|
| Claude Haiku 4.5 | $1 | $5 | Fast and cheap |
| Claude Sonnet 5 | $2 (intro) | $10 (intro) | Introductory through Aug 31, 2026 |
| Claude Sonnet 5 | $3 | $15 | Standard from Sept 1, 2026 |
| Claude Opus 5 | $5 | $25 | Current flagship |
| Claude Opus 5 fast mode | ~$10 | ~$50 | 2x rate, ~2.5x speed |
| Claude Opus 4.8 | $5 | $25 | Previous Opus |
| Claude Fable 5 | $10 | $50 | Frontier tier |
| Claude Mythos 5 | $10 | $50 | Trusted access |
Two patterns worth internalising. First, output costs 5x input across every current-generation model. That ratio is stable enough to plan around, and it means verbosity is expensive in a way that context length often is not. Second, Opus 5 shipping at Opus 4.8's exact rate means the upgrade is free at list price — there is no budget conversation, only an evaluation.
The two discounts that beat model choice
Before you optimise which model you use, optimise how you call it. Both of these apply across the range.
| Lever | Saving | Quality cost | Effort |
|---|---|---|---|
| Prompt caching | Up to 90% off cached input | None | Low |
| Batch API | 50% off everything | None — but async | Low |
| Drop to a cheaper model | Up to 80% | Real — measure it | Medium |
| Lower the effort level | Varies, often large | Real on hard tasks | Low |
Prompt caching is the one teams skip and then wonder why their bill is large. If your agent sends the same system prompt, coding standards and repository map on every turn, you are paying full input price for identical tokens over and over. Caching that content cuts the cached portion by up to 90% with no change to output quality.
The Batch API halves everything across all models, with the trade being asynchronous delivery. For anything that does not need an answer this second — nightly analysis, bulk classification, backfilling summaries, evaluation runs — the batch route is simply the same work at half price.
Stack both and a workload can land under half of what the naive per-call path costs before you have changed a single model ID.
A caching detail that silently destroys the saving
Caches only hit when the beginning of the prompt is byte-identical between calls. Put anything volatile at the top — a timestamp, a request ID, a shuffled list of tools, a "current date" line — and you invalidate the cache on every single request.
There is no error for this. The call succeeds, the answer is fine, and the bill is quietly four times what you expected. If you have caching enabled and are not seeing the saving, check prefix stability before anything else.
| Put at the top (stable) | Put at the bottom (volatile) |
|---|---|
| System prompt and instructions | Current timestamp |
| Coding standards, review rubric | Request or trace IDs |
| Repository structure map | The user's current message |
| Stable reference documents | Fresh tool output |
Picking a model by lane, not by rank
The most expensive mistake in this category is routing everything to the best model. A large share of agent tasks — renames, formatting, mechanical migrations, classification, test scaffolding — complete identically on a model that costs a fifth as much.
| Task | Model | Why |
|---|---|---|
| Classification, extraction, formatting | Haiku 4.5 | $1/$5 and fast |
| Routine features with clear tests | Sonnet 5 | Strong at a fraction of Opus cost |
| Interactive chat surfaces | Sonnet 5 or Haiku 4.5 | Latency matters more than peak capability |
| Hard debugging, long-horizon agents | Opus 5 | Where the capability gap is real |
| Planning docs, specs, analysis | Opus 5 | Leads knowledge-work benchmarks |
| Health-adjacent work | Fable 5 | Reported to lead on health tasks |
The pattern that beats picking a single winner is escalation, send each task to the cheapest model that reliably completes it, and escalate on failure. Teams that do this usually spend less than teams running a cheap model alone, because cheap-model-only teams pay in retries and human repair instead.
The Sonnet 5 tokenizer trap
Sonnet 5's introductory rate of $2/$10 runs through August 31, 2026, moving to $3/$15 on September 1. Two things to plan for.
First, that is a 50% increase arriving on a known date. If you are building a business case on Sonnet 5 economics this summer, model the September number, not the July one.
Second, and less obvious. Sonnet 5 uses a newer tokenizer that counts roughly 30% more tokens for the same text. Per-token parity with an older model is therefore not per-request parity. A migration that looks cost-neutral on the rate card can arrive 30% higher on the invoice. Measure on your own prompts before you commit.
What actually drives your bill
In most agent stacks the token spend breaks down roughly like this, and only one line is about which model you picked.
| Source | Typical share | Fix |
|---|---|---|
| Context re-sent every turn | Large | Prompt caching, tighter retrieval |
| Reasoning tokens at high effort | Large | Right-size effort per task type |
| Retries after failure | Sneaky | Better tests, capped retries |
| Raw tool output in context | Underestimated | Summarise before it enters context |
| The actual answer | Small | Nothing — this is what you wanted |
A 1M token context window is a ceiling, not a target. Filling it is almost always wrong, you pay for every token, retrieval quality degrades as irrelevant material dilutes the signal, and you lose any ability to reason about what the model actually saw.
Using the Batch API properly
Halving your rate for accepting asynchronous delivery is the best unconditional discount on the sheet, and most teams under-use it because they classify work as real-time by default.
| Workload | Batch it? | Reason |
|---|---|---|
| Nightly repo analysis | Yes | Nobody is waiting |
| Bulk classification or tagging | Yes | Throughput, not latency |
| Evaluation suite runs | Yes | Results read the next morning |
| Backfilling summaries or embeddings | Yes | One-off migration work |
| PR review bot | Usually not | Reviewers expect same-session feedback |
| Interactive chat | No | Latency is the product |
One caveat that interacts with compliance, batch jobs are stored for 29 days by design, because asynchronous delivery requires it. That means the Batch API is not eligible for Zero Data Retention. If you run under a ZDR arrangement, batching is a decision to step outside it for that data — see the retention guide before you route sensitive work through it.
Plans versus API keys
Everything above is API list pricing. If your team works through the Claude apps instead, the economics are different and the comparison confuses people.
| API key | Consumer or team plan | |
|---|---|---|
| Billing | Per token consumed | Per seat, per month |
| Cost of a heavy day | Scales with usage | Capped by plan limits |
| Model access | Everything you are approved for | Tiered — Opus 5 is default on Max |
| Predictability | Variable | Fixed, until you hit limits |
| Best for | Products, automation, agents | Individual and small-team usage |
The trap for seat holders is assuming "included in my plan" means "free to use however I like." A reasoning model consumes more of whatever budget your plan meters per turn, so moving a team to a higher-effort default can quietly exhaust limits mid-sprint. Watch the first week after any model or effort change before you rewrite team defaults.
The metric to report upward
Price per million tokens is a vendor number. The number that describes your business is cost per accepted change, all tokens spent on a task including retries, times the rate, divided by changes that merged and survived a week.
This is what makes an expensive model look cheap. A model that lands the change first time at $25 output beats a model at $10 that needs four attempts plus a human repair. It also exposes the reverse, a high effort setting burning four times the tokens to produce a diff that was already correct at medium.
| Metric | Report it? | Why |
|---|---|---|
| Total monthly spend | Yes | Budget reality |
| Cost per accepted change | Yes | The efficiency number |
| Repair rate within 7 days | Yes | Catches fluent-but-wrong output |
| Price per million tokens | No | Vendor list price, not your cost |
Estimating a monthly bill before you commit
A rough model beats no model. The arithmetic is simple enough to do on a napkin, and getting within 30% is enough to make a decision.
- Count tasks per month. Tickets, reviews, classifications — whatever the agent handles.
- Estimate tokens per task. Instrument ten real runs rather than guessing, the answer is usually larger than people expect because of re-sent context.
- Split input and output. Output is 5x the price, so a verbose model costs more than its rate suggests.
- Apply the caching discount to the stable portion of input, not all of it.
- Add a retry multiplier. If one task in five needs a second attempt, that is 1.2x, not a rounding error.
- Halve anything you can batch.
The step that most changes the answer is the retry multiplier, because it is the one benchmarks never show. A weaker model with a 40% retry rate can cost more per completed task than a frontier model that lands it first time, even at five times the token rate. That is the entire argument for evaluating on cost per accepted change rather than on the price sheet.
Budgeting when the price sheet moves every six weeks
Opus 4.8 shipped in May at $5/$25. Fable 5 and Mythos 5 arrived in June at $10/$50. Sonnet 5 landed June 30 with introductory pricing. Opus 5 shipped July 24 at $5/$25, matching Opus 4.8 and undercutting Fable 5 by half.
Four releases in three months, and frontier capability roughly halved in price across the window. Any budget built on "we chose a model and its rate" has a shelf life measured in weeks.
The version that survives is built on unit economics. If you know your cost per accepted change and your monthly volume, a new model is a substitution, does the unit cost go up or down? You do not re-plan, you re-measure one number. Set a ceiling, alert at 60% and 85%, and review monthly. That is enough process — anything heavier gets abandoned by the third launch.
Common questions
How much does the Claude API cost?
From $1/$5 per million tokens for Haiku 4.5 to $10/$50 for Fable 5 and Mythos 5. Claude Opus 5, the current flagship, is $5/$25.
What is the cheapest way to use Claude?
Prompt caching on repeated context (up to 90% off the cached portion) plus the Batch API for anything asynchronous (50% off everything), before you change models at all.
Is Claude Sonnet 5 cheaper than Opus 5?
Yes — $2/$10 introductory, $3/$15 from September 1, against Opus 5's $5/$25. Factor in the ~30% higher token counts from Sonnet 5's newer tokenizer when you model the saving.
Does the 1M context window cost extra?
Only if you fill it. You pay per token sent, so the window is a ceiling rather than a price tier, and sending less context is the cheapest optimisation available to you.
Which Claude model is cheapest?
Claude Haiku 4.5 at $1 in and $5 out per million tokens. For mechanical work — classification, extraction, formatting, test scaffolding — it frequently completes the task identically to a model costing five times more.
Why is Opus 5 cheaper than Fable 5 if it scores higher?
Fable 5 launched earlier at frontier pricing. Anthropic priced Opus 5 at parity with Opus 4.8 rather than at Fable 5's tier.
How much does prompt caching actually save?
Up to 90% on the cached portion of input. The saving is only as large as the share of your prompt that is stable and byte-identical between calls, so measure your cache hit rate rather than assuming the headline number.
Is the Batch API worth using?
For anything asynchronous, yes — it halves the rate on every model with no quality change. The trade is delivery time, plus 29-day job storage that puts it outside Zero Data Retention.
Sources and further reading
- Claude Platform docs, pricing
- Anthropic. Introducing Claude Opus 5
- BenchLM. Claude API pricing, July 2026
- Opus 5 data retention and enterprise controls
- Price against capability on the live board
One closing note for anyone presenting this to finance. The instinct is to report the cheapest rate you can find and promise savings. The stronger position is to report your unit cost and its trend. "We spend a known amount per accepted change, it fell when we moved mechanical work to a cheaper tier, and a new model would change it by roughly this much" is a sentence that survives contact with a CFO. "The new model is half price" does not, because it is not what the invoice will say.
