LLM API Pricing 2026: What Changes on September 1

LLM API pricing in 2026 spans roughly three orders of magnitude, from $0.14 per million input tokens at the value end to $10 or more at the frontier — and one of the most widely used models gets 50% more expensive on September 1. Claude Sonnet 5's introductory rate of $2/$10 per million tokens ends August 31, stepping up to $3/$15, and a tokenizer change means the same text can consume up to 35% more tokens than it did on Sonnet 4.6. If you have a production workload on Sonnet 5, your bill changes in under a month.

The broader picture is stranger than "prices go up." Input pricing across the market fell roughly 80% between early 2025 and early 2026, then began diverging sharply: value-tier models kept falling while frontier models held or rose. Cost per token stopped being a single number and became a strategic choice.

This is a working reference — current list prices, the September 1 change explained precisely, and the five optimization levers that actually move a bill, in order of return per hour of engineering.

Key Takeaways

• Claude Sonnet 5's intro pricing of $2/$10 per million tokens ends August 31, 2026; from September 1 it is $3/$15 — a 50% increase.
• The Sonnet 5 tokenizer can consume up to 35% more tokens for the same text, so the effective increase exceeds the sticker change.
• Frontier list prices in August 2026: Claude Opus 5 at $5/$25, GPT-5.6 Sol at $5/$30, Claude Fable 5 at $10/$50.
• DeepSeek V4 Flash 0731 sits at $0.14/$0.28 with cached input at $0.0028/M — roughly 35x cheaper on input than the frontier.
• Prompt caching cuts input cost on repeated prefixes by up to 90%; batch APIs typically add a further 50% discount.

LLM API pricing comparison, August 2026

Prices below are list rates per million tokens. Caching, batching and volume agreements all reduce these materially.

Two observations that matter more than the individual numbers.

First, output pricing is where the spread lives. Sol and Opus 5 are identical on input at $5.00 and differ by $5.00 on output. For generation-heavy workloads that difference dominates everything else in your bill, and most cost comparisons underweight it because input tokens are easier to count.

Second, the value tier is no longer a downgrade. DeepSeek V4 Flash 0731 scores 82.7 on Terminal-Bench 2.1 while charging a rounding error of frontier pricing — we broke down that release in DeepSeek V4 Flash 0731. The gap you pay 35x for is now measured in a few benchmark points on many tasks, not in whether the model can do the job at all.

What exactly changes with Claude Sonnet 5 on September 1?

Two things change simultaneously, and only one of them is on the pricing page.

The sticker price. Sonnet 5 launched at $2 input / $10 output per million tokens as an introductory rate. That rate ends August 31, 2026. From September 1 the standard rate is $3/$15 — a 50% increase on both sides.

The tokenizer. Sonnet 5 uses a new tokenizer, and as Finout's analysis documents, the same text can produce up to 35% more tokens than it did on Sonnet 4.6. Because $3/$15 is the identical sticker to Sonnet 4.6, this is easy to read as a cost-neutral migration. It is not: same sticker, more tokens per request, higher bill.

The practical implication is that you cannot estimate your September cost by multiplying August's token count by 1.5. Measure your actual token consumption on Sonnet 5 with the current tokenizer, then apply the new rate. Teams that skip that step will be surprised twice.

Worth noting the counter-consideration: a tokenizer that splits text differently is not purely a tax. Different tokenization can improve quality on code and non-English text. Whether that trade is worth it for your workload is an evaluation question, not a pricing one.

The five levers that actually cut LLM API costs

In descending order of return per hour of engineering effort. Applied together, these routinely cut spend by 70–85% without changing what the system produces.

1. Prompt caching (up to 90% off cached input). Every major provider now prices cached input at roughly 10% of fresh input, and DeepSeek goes further at 2% of list. Latency also drops 30–80% on a cache hit, because prefill is usually the slowest part of a request. The only requirement is that your stable content comes first in the message sequence:

messages = [
    # Invariant prefix — cacheable. System rules, schemas, few-shot examples.
    {"role": "system", "content": SYSTEM_RULES + JSON_SCHEMA + FEW_SHOT},
    # Variable suffix — changes per request. Always last.
    {"role": "user", "content": user_input},
]

Putting a timestamp or a request ID at the top of your system prompt invalidates the cache on every call. This single mistake is the most common reason caching "does not work" for a team.

2. Model routing. Send easy requests to a cheap model and hard ones to the frontier. A classifier or even a heuristic on input length and task type captures most of the gain. If 80% of your traffic is classification and formatting, paying $30/M output for it is pure waste.

3. Batch APIs (50% off). If a workload tolerates latency measured in hours rather than seconds — evaluation runs, bulk enrichment, offline summarization — batch endpoints halve the price for identical output.

4. Output length control. Output tokens cost 2–5x input across every provider. Capping max_tokens, requesting structured output instead of prose, and explicitly instructing brevity all attack the expensive side of the bill directly.

5. Prompt compression. Trim redundant few-shot examples and verbose instructions. Lowest return of the five, and the one most teams try first because it feels productive.

A concrete published example: a pipeline with roughly 3,500 tokens of system instructions repeating on nearly every call ran about $180/month on redundant input alone, and fell to about $70/month after enabling prompt caching — a 61% cut from one configuration change.

How do you estimate a workload before committing?

Measure, then multiply. Most teams discover their real spend is 3–5x their budget once they move past prototyping, and the reason is almost always retries, failed agent branches and context re-reads that never appear in a napkin estimate.

PRICES = {                      # $ per million tokens, list, Aug 2026
    "fable-5":      (10.00, 50.00),
    "gpt-5.6-sol":  ( 5.00, 30.00),
    "opus-5":       ( 5.00, 25.00),
    "sonnet-5-sep": ( 3.00, 15.00),
    "v4-flash":     ( 0.14,  0.28),
}

def monthly(model, in_tok_day, out_tok_day, cache_hit_rate=0.0, days=30):
    pin, pout = PRICES[model]
    effective_in = pin * (1 - cache_hit_rate) + pin * 0.1 * cache_hit_rate
    return days * (in_tok_day / 1e6 * effective_in + out_tok_day / 1e6 * pout)

for m in PRICES:
    print(f"{m:14s} ${monthly(m, 20e6, 4e6, cache_hit_rate=0.7):>10,.2f}/mo")

Run it with your own numbers and a realistic cache hit rate. The result usually reorders your shortlist, because a high cache hit rate compresses the gap between tiers far more than most people expect — and a low one widens it.

The framing most pricing guides get wrong

Nearly every LLM pricing article ranks models by cost per token and calls the cheapest one the winner. That is the wrong unit.

The unit that matters is cost per completed task. A model that costs 35x less per token but needs three attempts, longer prompts and a verification pass is not 35x cheaper — and a frontier model that one-shots a task you would otherwise retry four times can genuinely be the cheaper option. We have watched teams migrate to a value-tier model, cut their token price by an order of magnitude, and see total spend fall by only half, because the retry rate went up and they had to add a checking step.

Three consequences follow:

• Instrument task success, not token count. If your dashboard shows tokens and not completion rate, you cannot make this decision.
• Price the verification you will need. Cheap models fail differently, not less. Budget for the test run or second-model check that catches it.
• Route rather than replace. Nearly every workload is a mixture of easy and hard requests. The optimum is almost never one model.

The other structural shift worth planning around: inference pricing is not the only cost curve any more. Thinking Machines released Inkling under Apache 2.0 with no metered API at all, betting that customization rather than tokens is where value settles. If that model spreads, "what does the API cost" becomes a question about your own infrastructure rather than a vendor's price list.

Frequently Asked Questions

How much does the Claude Sonnet 5 price increase on September 1, 2026? Sonnet 5's introductory rate of $2 input / $10 output per million tokens ends August 31, 2026. From September 1 the standard rate is $3/$15, a 50% increase. A new tokenizer can also consume up to 35% more tokens for the same text.

What is the cheapest LLM API in 2026? Among capable models, DeepSeek V4 Flash 0731 at $0.14 input / $0.28 output per million tokens is the cost leader, dropping to $0.0028 per million on cached input. It scores 82.7 on Terminal-Bench 2.1, so it is not a capability trade-off at the level the price suggests.

How much can prompt caching save? Up to 90% on the cached portion of input, since providers typically price cache hits at around 10% of fresh input. It also cuts latency by 30–80% on a hit. The requirement is that your invariant content appears first in the message sequence.

Why is output more expensive than input? Output tokens are generated one at a time, each requiring a full forward pass through the model, while input tokens are processed in parallel during prefill. The 2–5x price difference reflects that computational asymmetry.

Is GPT-5.6 Sol or Claude Opus 5 cheaper? They are identical on input at $5.00 per million tokens. Opus 5 is cheaper on output at $25.00 versus Sol's $30.00, so for generation-heavy workloads Opus 5 has the lower effective cost.

How do I estimate my LLM costs before building? Prototype the real workload, measure actual token consumption including retries and failed branches, then apply list prices adjusted for your cache hit rate. Teams that estimate from a single ideal request typically underestimate by 3–5x.

The verdict

The single most actionable fact in this article has a deadline: Claude Sonnet 5 costs 50% more from September 1, 2026, and the tokenizer change means your effective increase is larger than that. If you have production traffic on Sonnet 5, measure your real token consumption this week and decide deliberately whether to absorb it, route part of the load elsewhere, or migrate.

Our broader recommendation: stop optimizing cost per token and start measuring cost per completed task. Turn on prompt caching today — it is the highest return per hour of work available and most teams have it misconfigured or off. Then route by difficulty rather than picking a single model, because no single price point is right for a mixed workload.

For the two ends of the spectrum this article compares, read our breakdowns of Claude Opus 5 at the frontier and DeepSeek V4 Flash 0731 at the value end — and Grok 4.5 for the middle.

Token prices fell 80% in a year and most teams' bills went up anyway. The models got cheaper; the workloads got hungrier. Only one of those is under your control.