Originally published at API Cost Lab.
Last updated: October 2026
"What's the cheapest LLM API?" is the wrong question — or rather, it's a question with a trap in it. The model with the lowest per-token price is rarely the cheapest one on your invoice. Your real bill is decided by three things the headline price doesn't show: cache rates, output ratios, and pricing thresholds.
Here's the honest comparison, using only verified current prices.
The Verified Price Table
These are the models with confirmed pricing as of October 2026. No rumors, no "reportedly" — just published rate cards:
| Model | Input / 1M | Cached input / 1M | Output / 1M |
|---|---|---|---|
| GPT-5.6 Sol (promo) | $4.00 | $0.40 | $20.00 |
| GPT-6.1 Sol | $2.00 | $0.10 | $10.00 |
| Claude Opus 5.5 | $4.00 | $0.20 | $20.00 |
| Claude Sonnet 5 | $2.00 | — | $10.00 |
| Gemini 4 Argon (intro) | $2.00 | — | $10.00 |
| Gemini 4 Argon (from Dec 1) | $4.00 | — | $20.00 |
| Muse Wonder | $4.00 | — | $20.00 |
Two deadlines matter here. GPT-5.6 Sol's promo is "available at least through November 21, 2026" — after that, pricing is unpublished, but the pre-promo list price was $5/$30. Gemini 4 Argon's intro rate runs through November 30, 2026, then doubles to $4/$20 on December 1.
If you stopped at the table, you'd conclude GPT-6.1 Sol and Sonnet 5 and Argon (today) tie at $2/$10. But the table isn't the bill. Here's why.
Why Headline Price Doesn't Decide Your Bill
Cache rates change everything
Look at the cached-input column. GPT-5.6 Sol charges $0.40 for cached reads — 10% of its input rate. GPT-6.1 Sol charges $0.10 — just 5%. Claude Opus 5.5 charges $0.20.
On a cache-heavy workload, these differences dominate. Take the reference workload: 1,100 tasks/month, each with 12K fresh input, 48K cached input, and 6K output tokens:
- GPT-5.6 Sol (promo): $205.92/month
- GPT-6.1 Sol: $97.68/month
- Claude Opus 5.5: $195.36/month — 5.1% cheaper than the Sol promo, despite identical $4/$20 headline rates, purely because its cache reads cost half as much
Two models with the same sticker price can differ 5% or more on real workloads. And a model with a higher sticker price but better caching can beat a cheaper-looking one. Always model with your actual cache ratio, not the headline rate.
Output ratios punish verbosity
Output tokens cost roughly 5x input tokens across the board. That means the model that generates concise answers is cheaper than the model that rambles — at identical per-token prices.
This is where per-task cost beats per-token cost as a metric. A $2/$10 model that writes 12K output tokens per task costs more than a $4/$20 model that writes 4K. You can't know this from the price table; you learn it from measuring your actual usage per model. When evaluating, benchmark cost per completed task, not cost per million tokens.
Thresholds and deadlines are hidden price hikes
GPT-5.6 Sol reprices the entire request at 2x input / 1.5x output past 272K input tokens. A workload that regularly crosses that line isn't paying $4/$20 — it's paying $8/$30. Meanwhile, Argon's price doubles on December 1 and Sol's promo has an expiry date with no published follow-on price. The "cheapest" model today can be the most expensive one next quarter if you're not watching the dates.
Quality-Per-Dollar Verdicts by Use Case
Price without capability context is meaningless. Here's how the verified options stack up by workload — with the honest caveat that you should benchmark on your own tasks:
Bulk processing and evals (cost-first): GPT-6.1 Sol at $2/$10 with $0.10 cached reads is the value pick among verified options. For high-volume, low-complexity work — classification, extraction, bulk summarization — it's less than half the cost of the flagship tier. Pair it with batch APIs (50% off) and the economics get hard to beat.
Coding agents (balanced): This is where cache economics matter most, because agentic loops re-send context constantly. Claude Opus 5.5 at $4/$20 with $0.20 cache reads is 5% cheaper than GPT-5.6 Sol's promo on the reference workload — and on the AA Intelligence Index it scores 58 versus Wonder Full's 56 and Argon 53. GPT-5.6 Sol's promo is competitive until November 21; after that, re-model. The right answer here is genuinely workload-dependent: measure your cache ratio, then pick.
Chat and interactive products (latency-sensitive): Batch discounts don't apply, so you're paying full rate-card prices. Here the decision is mostly about the $2/$10 tier versus the $4/$20 tier — Sonnet 5 (whose $2/$10 intro rate was made permanent), GPT-6.1 Sol, or Argon before December 1. All three are half the flagship price; pick on capability fit and ecosystem, not on fractions of a cent.
One more consideration: don't ignore switching costs. Different providers mean different API shapes, tool-calling conventions, and prompt quirks. Chasing the cheapest rate every quarter only pays if your stack is provider-agnostic. Otherwise the migration engineering costs more than the inference savings.
A practical way to stay portable without over-engineering: wrap model calls behind a thin internal interface from day one — one function that takes a prompt and returns a completion, with the provider details behind it. You don't need a full abstraction framework; you need the freedom to change a config value instead of rewriting call sites. Teams that do this capture pricing windows as they open. Teams that hard-code the provider into every module read about the discounts instead.
The Re-Check Calendar: Prices Move
One more thing the table doesn't show: every price on it has a shelf life. In 2026, LLM pricing moves constantly — providers reprice quarterly, run promos with expiry dates, and reverse direction without much warning. Two dates are already on the calendar: November 21, when GPT-5.6 Sol's promo period reaches its published "at least through" date with no follow-on pricing announced, and December 1, when Gemini 4 Argon's intro rate doubles.
Build a habit around this: re-verify any price table older than 30 days before budgeting against it, and put the known deadlines in your calendar now. Better yet, don't hard-code rates into your cost models — parameterize them, so a price change is a config edit rather than a rewrite. The developers who get burned are the ones who picked the cheapest model in October and never looked again.
There's a second-order effect to the deadlines too. When a popular model's price jumps, a lot of teams migrate workloads at once — which means the weeks around November 21 and December 1 are exactly when you don't want to be scrambling. Do your fallback benchmarking now, while the current prices still hold, so the deadline is a non-event instead of a fire drill.
The Bottom Line
The cheapest LLM API in 2026 isn't a model — it's a method. Model your actual token mix (fresh vs. cached vs. output), watch the pricing deadlines (November 21 for Sol's promo, December 1 for Argon's doubling), benchmark cost per task instead of cost per token, and re-check quarterly. Prices in this market move constantly; the developers with the lowest bills are the ones who measure instead of assuming.
Top comments (0)