OpenAI cut a model's price 80% and told nobody. It took me 23 days to notice — and I run a price tracker.

Roman Shumyatsky — Mon, 03 Aug 2026 13:30:02 +0000

Sometime after July 9th, OpenAI changed the price of GPT-5.6 Luna from $1.00/$6.00 per million tokens to $0.20/$1.20.

That's an 80% cut on a current frontier-tier model. There was no announcement. No changelog entry. No email. The pricing page just quietly said something different one day.

I run a site that tracks LLM API pricing across every major provider. I didn't notice for 23 days. My own tracker kept publishing the old, higher numbers that entire time.

I want to talk about why, because the reason is more interesting than the mistake.

What actually moved

Two models in the same family, caught in the same sweep:

Model	Input (was → now)	Output (was → now)	Blended	Change
GPT-5.6 Luna	$1.00 → $0.20	$6.00 → $1.20	$2.25 → $0.45	−80%
GPT-5.6 Terra	$2.50 → $2.00	$15.00 → $12.00	$5.63 → $4.50	−20%
GPT-5.6 Sol	$5.00 (unchanged)	$30.00 (unchanged)	$11.25	—

Blended figures are 3 parts input to 1 part output, which is roughly what a real chat or RAG workload looks like. Straight input/output averages make cheap-input models look worse than they are.

Three things convinced me this was a genuine vendor change rather than me misreading a page:

Batch and Flex tiers moved in exact lockstep — both landed at precisely half the standard rate, the same relationship they had before. A scraping error doesn't preserve internal ratios.
Sol didn't move at all. A parsing failure would have mangled all three rows in the family, not two.
The old numbers were themselves two-source verified on July 9th. The before-state wasn't a guess.

So: a real cut, silently shipped.

Why nothing caught it

This is the part worth your attention if you're building anything that depends on someone else's pricing.

There is no changelog for API pricing. Not at OpenAI, not at Anthropic, not at Google. There's a pricing page, it renders a number, and the number is whatever it is today. No version history, no RSS feed, no webhook, no deprecation notice. If you want to know what changed, you have to have written down what it was before.

In my case three separate safety nets all failed at once, and they failed in an instructive way:

The community datasets didn't have it. LiteLLM — which a huge amount of tooling quietly depends on for pricing — has never carried gpt-5.6-* entries at all. If your cost estimates come from a community price map, understand that absence looks exactly like nothing changed.
My weekly verification sweep never selected it. The sweep re-checks a rotating basket of models against first-party pricing pages. Luna wasn't in the basket. Nothing was wrong with the sweep; it just wasn't looking there.
The one system that knew, told me uselessly. I had a coverage tripwire that correctly emitted "a wrong price here would be invisible" for exactly this model. It printed that inside a 375-line wall of warnings, and then suggested I fix it by mapping the model in a LiteLLM ID file — for a model LiteLLM does not carry. A warning whose suggested remedy is impossible is not a warning. It's noise with a guilty conscience.

The lesson I actually took from this: a signal that already exists and gets ignored is an enforcement problem, not a detection problem. I didn't need a better detector. I needed the existing one to fail loudly instead of logging politely. That fix — a tripwire that breaks the build rather than adding a line to a log nobody reads — is what shipped alongside the corrected prices.

What six weeks of tracking actually shows

Since I've been recording every price across every provider daily, I can say some things about the market that aren't obvious from any single pricing page.

Frontier intelligence currently costs $4.66 per million tokens.

That's an equal-weighted, chain-linked index across nine frontier models from nine different labs — OpenAI, Anthropic, Google, xAI, DeepSeek, Alibaba, Mistral, Z.AI, and Moonshot. It's down 3.7% since late February, and it has been completely flat for the last 7 days.

Three findings from that basket surprised me:

1. The cheap end is absurdly cheap, and it isn't bad. DeepSeek V4 Pro sits at $0.544 blended — roughly one twentieth of GPT-5.6 Sol at $11.25 — while scoring 71.5 on the Vellum leaderboard against Sol's 83.8. Normalize that to cost per benchmark point and DeepSeek costs $0.0076 per point versus an index average of $0.0637. It is about eight times more cost-efficient than the average frontier model. Whether the last 12 benchmark points are worth a 20× price premium is a real engineering decision, and most teams never explicitly make it.

2. Open weights are cheaper, but not by much. Open-weight models in the basket average $4.08 blended; closed models average $4.83. That's a spread of 75 cents per million tokens — far narrower than the open-source-is-basically-free intuition suggests. If you're choosing open weights, do it for the portability and the fine-tuning, not the token price.

3. The frontier turns over shockingly fast. In two weeks the basket had five model successions: GPT-5.5 → GPT-5.6 Sol, Grok 4 → Grok 4.5, Claude Opus 4.8 → Opus 5, Qwen3-Max → Qwen3.7-Max, plus Kimi K3 entering as a new constituent. Five of nine slots changed in fourteen days. Any cost model you built a month ago is describing models that are no longer the current ones.

Prices move in both directions too, which people forget. Over the same window Mistral raised Mixtral 8x7B Instruct 29.6% ($0.54 → $0.70) and Mistral Small 3.2 24B 36.4% ($0.08/$0.20 → $0.10/$0.30). Nobody announced those either.

What to actually do about it

Concrete, in rough order of effort:

Pin the price in your cost model, with a date. Not "GPT-5.6 Luna costs $1" but "GPT-5.6 Luna cost $1.00/$6.00 as of 2026-07-09." A cost estimate without an as-of date is a number pretending to be a fact. This is the single highest-value habit here and it costs you nothing.

Re-verify before anything that depends on the number. Budget approvals, model-selection decisions, customer-facing pricing. Five minutes on the vendor's own pricing page beats a three-week-old cached figure — as I demonstrated the hard way.

Don't trust a community price map as a source of truth. They're genuinely useful and they're maintained by good people, but coverage gaps are silent. A model that isn't listed doesn't look like a gap, it looks like nothing to report.

Compute blended cost with your real ratio. A summarizer that reads 50k tokens and writes 500 has completely different economics from an agent loop that generates constantly. The advertised "cheap" model flips depending on which one you are.

Check whether prompt caching changes the answer. For anything re-reading the same context — agents, RAG, long chats — cached input rates can move the ranking more than the headline price does. It's the most commonly ignored variable in these comparisons.

The uncomfortable conclusion

I built a tool specifically to catch this class of problem, and it still took me 23 days to spot an 80% price cut on a current model from the largest provider in the space.

That's not a story about my tool being bad. It's a story about how much of this ecosystem runs on numbers nobody is actually watching. If a dedicated tracker with daily snapshots and a verification sweep can carry a wrong price for three weeks, the spreadsheet where you modeled your unit economics in June is not in better shape.

Write down the date next to the price. That's the whole takeaway.

The index numbers above are live at modelpricewatch.com/price-index, with the full methodology and a monthly State of LLM Pricing report. Every price links to the vendor page it came from, with a capture timestamp.

Disclosure: I maintain ModelPriceWatch.

What's the oldest price still sitting in your cost model? Go check it — I'd genuinely like to know how many of you find a stale one.

Sonnet 5 vs GLM-5.2 vs everyone: how to pick the cheapest LLM API in 2026

Roman Shumyatsky — Sat, 04 Jul 2026 05:10:24 +0000

Two frontier-class models just launched weeks apart — Anthropic's Claude Sonnet 5
(closed, $2/$10 per 1M launch pricing) and Z.AI's GLM-5.2 (open-weight, MIT, ~$1.40/
$4.40 across hosts) — and the first question everyone asks is "which is cheaper?"
The honest answer: it depends on your token mix, your tier, and whether cached
input matters. Here's a repeatable way to answer it for your case, using live,
verified pricing.

1. Normalize everything to $/1M tokens

Providers quote prices in incompatible units — per-1K, per-1M, sometimes per-image
or per-character — and split input, output, and cached-input. Before you can
compare anything, convert all of it to dollars per 1 million input tokens and
per 1 million output tokens. (This is the single biggest source of "wait, that's
cheaper than I thought" errors.)

2. Separate the question by tier

Comparing a frontier flagship to a budget model on price alone is meaningless.
Bucket first, then compare within a bucket:

Flagship / frontier: the spread is real. The cheapest flagship-class model right now is about $1 / $2 per 1M (in/out); the priciest frontier tier runs up to $30 / $180. Same nominal tier, a 30-90x spread — which is exactly why you bucket first. Sonnet 5 lands mid-tier on price despite frontier capability; GLM-5.2 is the cheapest open option at that level.
Budget / fast: the floor is far lower than most people assume — ~$0.017-$0.05 / 1M input for capable small models.
Embeddings: a near-commodity at ~$0.02 / 1M across several providers.
Open-weight, multi-host: the same open model (GLM-5.2, DeepSeek, Qwen) is often served by several providers at different prices — compare hosts, not just models.

3. Weight by your actual token ratio

A summarizer is input-heavy; a code generator is output-heavy. Output usually
costs 3-5x input, so a model that looks cheap on input can lose on a
generation-heavy workload. Multiply each rate by your real volume — don't eyeball
the sticker price.

4. Don't forget cached input

For RAG and agent loops you re-send the same context constantly. Cached-input
pricing is often a huge discount — Sonnet 5's cache hits are 90% cheaper than
fresh input ($0.20 vs $2.00 /1M) — and it can flip the ranking entirely. If your
workload is cache-heavy, rank by cached-input price, not raw input. (There's a
live ranking of caching-capable APIs
if you want the current order.)

5. Use live data, not a blog post's snapshot

Prices move — Sonnet 5's own launch pricing reverts from $2/$10 to $3/$15 on Sep 1,

A table you screenshot today is wrong next month. I maintain Model Price Watch, which tracks 159 models across 24 providers and re-verifies prices against each provider's official pricing page 3x a day. If you'd rather script it, there's a free no-key JSON API: https://modelpricewatch.com/api/v1/models.json.

Worked example: for a chat product doing ~2M input / 0.5M output tokens a day, run
those numbers through a cost calculator across your shortlist — and if you re-send
a big system prompt each call, add the cached-input rate. The difference between
Sonnet 5 with caching and a naive flagship default can be the majority of your bill.

Disclosure: I build and maintain Model Price Watch. The method above works with
any pricing source — I just happen to keep one current.

DEV Community: Roman Shumyatsky