All writing

·8 min read

The storage hiding in your token bill

AI has made storage expensive, and most of the coverage is about datacenters. There is a quieter version of the story inside your own API bill — where a cache read costs a tenth of what you are paying now, and a cache nobody reads back costs more than not caching at all.

The hardware story is real. NAND fabs shifted capacity toward high-bandwidth memory for accelerators, enterprise SSDs now take something like 60% of what remains, and each AI server rack wants ten to fifty times the storage of a conventional one. The prices followed.

16x

Enterprise SSD cost relative to hard drives in Q1 2026, up from about 6x in Q2 2025. Over the same period a 30TB enterprise SSD went from roughly $3,000 to roughly $11,000.

Seagate and Western Digital have both told investors their nearline drive output is effectively sold out into 2027, with lead times around twelve months. Micron has said it can meet 55–60% of its major customers’ demand. Kioxia expects the shortage to run through next year.

Here is the thing, though: unless you are buying drives, none of that is your bill. If you build on model APIs, your storage costs are set by a published per-unit price that has not moved. The interesting question is not whether that price is about to rise. It is that you are almost certainly not measuring it.

There is storage in a token bill

Three line items, none of which look like storage at a glance.

  • Context cache. Keeping a prompt warm so you do not have to send it again. Metered per token, in both directions.
  • Vector stores. Billed per gigabyte per day, the only thing here not priced per token at all.
  • The embeddings that fill them. Priced per token, input only, at rates low enough that the volume becomes invisible.

The first is where the money is, and it behaves in a way that catches people out.

Caching is the biggest discount on the bill, and it can lose money

Anthropic prices a cache read at a tenth of the base input rate — 0.025x on Fable 5.1 and Mythos 5.1. That is the largest standing discount available on a token bill, and most teams never take it.

The catch is the other direction. Writing to the cache costs more than sending the same text uncached: 1.25x the base input rate for the five-minute cache, 2x for the one-hour. So caching is not free to attempt. A cache that gets written and never read is a pure loss, and you have to use it to come out ahead.

The break-even is lower than you would guess

For a prefix of n tokens used across k requests, sending it uncached costs kn. Caching it costs one write plus k - 1 reads: 1.25n + 0.1n(k - 1). Those are equal at k of about 1.28, which means the five-minute cache pays from the second use onward. The one-hour cache, at double the write cost, needs about three.

That sounds like it should be hard to get wrong, and the arithmetic is. What is easy to get wrong is the assumption underneath it — that the second use arrives before the cache expires.

Same setup, same volume, three different bills

Take a 40,000-token system prompt on Claude Opus 5, called a thousand times a day. At $5 per million input tokens, each uncached call puts twenty cents of prefix on the bill, each cache read costs two cents, and each write costs twenty-five cents.

BehaviourWritesReadsPer day
No caching at all——$200.00
Cache stays warm1999$20.23
Cache expires between calls1,0000$250.00
Same prompt, same thousand calls. The only variable is whether the next request arrives inside the five-minute window.

Ninety percent saved, or twenty-five percent wasted, and nothing in the configuration distinguishes the two. The difference is traffic shape. An endpoint serving a steady stream keeps itself warm for free, because a read refreshes the clock. One serving fifty requests a day scattered across business hours pays the write penalty almost every time.

The other common way to land in the third row is a prefix that is not actually constant. A timestamp near the top of a system prompt, a per-user line above the shared instructions, a tool list that reorders — any of it invalidates the cache while looking, in the code, exactly like caching.

Vector stores are small until they are not

OpenAI charges $0.10 per gigabyte per day for vector store storage, with the first gigabyte free. Fifty gigabytes is about $147 a month — unremarkable next to an inference bill, which is exactly why nobody looks at it while it grows.

Two details are worth knowing. The billable figure is the processed size: parsed, chunked and embedded, which runs well above the size of the files you uploaded, so you cannot estimate it from your corpus. And the free gigabyte appears to apply across the account rather than per store, which means ten small stores are over the line together even though none of them is individually worth thinking about.

The part that makes your other numbers wrong

This is the bit we got wrong ourselves, and it is the reason the post exists.

Our sync read OpenAI’s /usage/completionsendpoint and then reconciled the day’s estimate against /organization/costs, which bills the whole organization. Embeddings and vector stores are separate endpoints. So for any workspace doing retrieval, that spend landed in the billed total with nothing in the estimate to meet it, and the scale factor stretched to cover the gap.

The daily total stayed correct. Everything underneath it drifted. A workspace that was 20% embeddings had every chat model, team, customer and task inflated by about 25% — and with them every “you could save this much” figure on the page.

+25%

How much every completion figure was overstated for a workspace 20% of whose spend was embeddings — invisible, because the one number anybody checks against the invoice was right.

That is the failure mode worth generalising. Any cost line that is billed but not estimated does not merely go missing. If you reconcile against a real invoice — and you should — the missing line is redistributed across everything you did estimate. The number you verify is the number that stays right, and it hides the ones that do not.

What to actually check

  • Whether your cost tooling reads every usage endpoint its provider publishes, or only the obvious one. If it reconciles against a billed total, the gap does not show up as a gap.
  • Whether cache reads, cache writes and uncached input are held apart. Summed into one figure, a cache read is priced at ten times what it cost.
  • Your reads-per-write ratio. Below roughly one, caching is costing you money and a hit rate will not say so.
  • Whether your cached prefix is genuinely constant. Put the variable parts below it, not above.
  • What your vector stores hold now against ninety days ago. It is a line that only ever grows, and the per-day price means growth compounds quietly.

None of this is affected by what a 30TB drive costs. That is a real story and it is someone else’s bill. The storage on yours is measured in tokens kept warm and gigabytes held, and the reason it is worth an afternoon is not that the price is rising — it is that the biggest discount on your bill is sitting unclaimed next to a trap that looks identical to it.

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.