All writing

·6 min read

The rate card you built is already wrong

Between July and September 2026, the major labs made at least 28 changes to the price of their text models. If you built an internal cost dashboard this spring, it is wrong today — and the way it is wrong is quiet.

Most teams track AI spend the same way: multiply token counts by a rate card, group by model, put it on a chart. It works on the day you build it. The problem is that the rate card is a snapshot of a market that no longer holds still.

28

Price changes to text-model APIs across Anthropic, OpenAI, Google, DeepSeek and xAI between 1 July and 30 September 2026 — counting new models and their launch prices.

That is roughly one every three days. Nobody updates a hard-coded price map every three days. So the map drifts, and because the chart still renders a confident number, nothing tells you it has drifted.

Three ways a rate card goes wrong

We maintain a price catalog for every model our customers use, because the product does not work without one. Keeping it correct has taught us that “prices change” is three separate problems wearing one coat.

1. A new version is a new price, not the old one

Claude Opus 5.5 shipped in September at $4 per million input tokens. Opus 5 was $5. If your lookup does prefix matching — and most do, because model strings arrive with dates and suffixes attached — then claude-opus-5-5 quietly matches claude-opus-5 and every Opus 5.5 token gets billed on your dashboard at 25% above what you actually paid.

The fix is a rule, not a row: never match across a version bump. If what remains after the matched prefix begins with a digit, it is a different model, and the honest answer is “I don’t know this one” rather than a number that looks right.

2. Named variants are worse, because the guard does not apply

OpenAI’s GPT-6 family is not numbered, it is named. Astra, Sol, Luna. A version-bump guard does nothing here, and the spread is not 25%.

ModelInput / 1MOutput / 1M
GPT-6 Astra$10.00$50.00
GPT-6.1 Sol$2.00$10.00
GPT-6 Luna$0.10$0.50
Prices as published on 7 October 2026. Astra costs one hundred times Luna per input token — same family, same prefix.

A single gpt-6 row in a lookup table, written to be helpful, turns a Luna workload into an Astra bill on your own chart. One hundred times. The only defence is to refuse to have a family row at all, and to price each variant explicitly or not at all.

3. The price is no longer a single number per model

This is the one that breaks the model entirely. GPT-6.1 Sol bills Batch and Flex at half the standard rate, Fast at double it, and charges 2× input and 1.5× output on any request over 272K input tokens.

4×

The spread between the cheapest and most expensive way to send an identical request to one model — decided per request, not per model.

A rate card maps a model to a price. It has nowhere to put “this request, but not that one.” Prompt caching is the same shape: cache reads run at a fraction of base input, so two teams using the same model with different caching discipline have genuinely different unit costs, and a per-model average hides both.

And now prices expire on dates

A newer wrinkle, and the one we find hardest to defend against. Three prices in our catalog right now are not stable values — they are introductory rates with an end date attached.

ModelNowThen
Gemini 3.6 / 3.7 / 3.8 Flash$0.75 / $3.75$1.50 / $7.50 on 1 Jan 2027
GPT-5.6 Sol$5.00 / $30.00promotional to at least 21 Nov 2026
Gemini 4 Argon$2.00 / $10.00$4.00 / $20.00, no published date
Per million input / output tokens, as published on 7 October 2026.

On 1 January, Gemini Flash doubles. No model changes. No deploy happens. No error fires. Every dashboard built on a static price map simply starts reporting half the real cost of that model, indefinitely, and the only signal is that the invoice stops matching — which is a thing most teams check quarterly, if at all.

Argon is worse: Google has published no end date for its introductory price, so it cannot even be put in a calendar.

What actually works

Stop rebuilding the invoice and start reading it. Both OpenAI and Anthropic expose a cost API that returns what you were actually billed per day. That number has caching, batch discounts, tier pricing and contract rates already baked in, because it is the number on the invoice.

Use the rate card for the part the cost API cannot do — splitting a day’s real total across the models, teams and customers that spent it — and calibrate that split so it sums to the billed figure. Then a stale price in your catalog distorts the attribution a little, instead of making the headline number silently wrong.

  • Reconcile daily against the provider’s cost API rather than estimating from token counts.
  • Never let an unknown model borrow a price. Report it as unpriced and say what share of spend is unpriced.
  • Diarise the dated prices. Until catalogs carry effective dates, 21 November and 31 December are calendar entries, not code.
  • Watch for new model strings. A model nobody told finance about appears on the bill the day an engineer changes a string.

None of this is exotic. It is the ordinary consequence of buying a commodity whose price changes weekly from three vendors who each announce differently. The teams that get burned are not careless — they built something correct and then the ground moved underneath it, and nothing in the system was designed to notice.

This is the problem Lisran exists to solve

Connect a read-only provider key and we reconcile your last thirty days against what you were actually billed, split by model, team and customer. Read-only throughout — no SDK, no routing changes, nothing to redeploy.