Prompt caching pricing comparison (2026): the column every provider buries

Table of contents

• What prompt caching actually costs you
• Prompt caching prices at a glance
• The comparison, provider by provider
• The one-minute self-audit
• What caching saves on a real workload shape
• Which provider fits your access pattern?
• FAQ · Glossary · Sources and freshness · Changelog

Prompt caching pricing comparison: what prompt caching actually costs you

Most LLM API cached input pricing pages show you two numbers — input and output — and hide the third in a docs page you have to go find. But for any workload that re-sends context (which is every agent, every chatbot with a system prompt, every coding tool), the cached-read price is the number that decides your bill. Cached token pricing is not a rounding error: on the workload we model at the bottom of this post, the same 30-turn session costs anywhere from $0.009 to $0.31 depending on the lane — a 32x spread driven almost entirely by the cache columns.

There are three numbers, and you need all of them:

1. Fresh input price — what a provider charges per million tokens of prompt it has never processed. This is the headline number every comparison post quotes.
2. Cached read price — what they charge per million tokens whose prefix they have already processed and can reuse. This is the buried column. It ranges from 2% of the fresh price (DeepSeek) to 100% of it (some aggregator listings — we found one, quoted below).
3. Cache write fee — what they charge to store your prompt in the cache in the first place. This is the hidden one. Anthropic charges 1.25x the input price for a 5-minute cache entry and 2x for an hour; Kimi K3 charges $3.00/1M to write; OpenAI added a 1.25x write fee to its newest model generation; Google bills by the hour for as long as you hold an explicit cache. A provider can advertise a spectacular read discount and still cost you more on the first turn.

Why the write fee is the trap: on Anthropic's Sonnet 5.5, writing a 50,000-token context block costs $0.125 — more than processing those same tokens fresh ($0.10). The write only pays if you re-read the block, and their own pricing page states the break-even: one cache read recovers the 5-minute write fee, two reads recover the 1-hour fee. If your traffic re-sends context, that math is in your favor. If it doesn't, you paid extra for nothing.

This post is a prompt cache discount comparison built the way we wanted to read one: every rate verified from public pages in the session that wrote it (dated below), every unverifiable cell left as an em dash instead of a guess, and the ratios — cached price as a percent of fresh — computed so you can compare cache structures, not just absolute prices.

Prompt caching prices at a glance

The table below is the point of this post. Prices are per 1M tokens in USD, pulled 2026-10-14 from each provider's own public pricing page or API (sources and pull dates at the bottom). "Cached as %" is our arithmetic: cached-read price divided by fresh-input price on the same lane. An em dash means the number is not published publicly — check their current page.

Provider · model	Fresh input $/1M	Cached read $/1M	Cached as %	Cache write fee	TTL	Notes
OpenAI · gpt-6-astra	$10.00	$1.00	10%	$12.50 (1.25x)	managed by provider	long-context rates double
OpenAI · gpt-6.1-sol	$2.00	$0.10	5%	$2.50 (1.25x)	managed by provider	deepest OpenAI read discount
OpenAI · gpt-6-luna	$0.10	$0.01	10%	$0.125 (1.25x)	managed by provider	budget lane of the 6 family
OpenAI · gpt-5.6-terra	$2.00	$0.20	10%	$2.50 (1.25x)	managed by provider
OpenAI · gpt-5.6-luna	$0.20	$0.02	10%	$0.25 (1.25x)	managed by provider
OpenAI · gpt-5.2	$1.75	$0.175	10%	none listed	managed by provider	no write fee this generation
OpenAI · gpt-5.1 / gpt-5	$1.25	$0.125	10%	none listed	managed by provider
OpenAI · gpt-5-mini	$0.25	$0.025	10%	none listed	managed by provider
OpenAI · gpt-5-nano	$0.05	$0.005	10%	none listed	managed by provider
OpenAI · gpt-4.1	$2.00	$0.50	25%	none listed	managed by provider	shallow by current standards
OpenAI · gpt-4o	$2.50	$1.25	50%	none listed	managed by provider	the caution row
Anthropic · Claude Fable 5.1	$10.00	$0.25	2.5%	$12.50 / $20.00	5 min / 1 hr	deepest Anthropic read cut
Anthropic · Claude Opus 5.5	$4.00	$0.20	5%	$5.00 / $8.00	5 min / 1 hr
Anthropic · Claude Sonnet 5.5	$2.00	$0.10	5%	$2.50 / $4.00	5 min / 1 hr
Anthropic · Claude Haiku 5.5	$0.10	$0.01	10%	$0.125 / $0.20	5 min / 1 hr	prompts over 100K pay 5x input
Anthropic · Claude Opus 5	$5.00	$0.50	10%	$6.25 / $10.00	5 min / 1 hr	older generation
Anthropic · Claude Sonnet 4.6	$3.00	$0.30	10%	$3.75 / $6.00	5 min / 1 hr	older generation
Google · Gemini 4 Argon	$2.00	$0.10	5%	none (implicit only)	managed by provider	promo rates through Nov 30, 2026
Google · Gemini 3.8 Flash	$0.75	$0.075	10%	storage $0.50/1M per hour	you hold it, billed hourly	rates double Jan 1, 2027
Google · Gemini 3.6 Flash	$0.75	$0.075	10%	storage $0.50/1M per hour	you hold it, billed hourly	same structure as 3.8
DeepSeek · deepseek-flash, peak	$0.30	$0.006	2%	none listed	managed by provider	= DeepSeek V4.1-Flash
DeepSeek · deepseek-flash, off-peak	$0.15	$0.003	2%	none listed	managed by provider	cheapest verified cache read
DeepSeek · deepseek-v4-pro, peak	$1.32	$0.044	3.3%	none listed	managed by provider	halves off-peak
Kimi · kimi-k3	$3.00	$0.30	10%	$3.00 / $6.00	5 min / 1 hr	1M context; hits refresh TTL
Kimi · kimi-k2.7-code	$0.95	$0.19	20%	none listed	managed by provider	hit/miss split pricing
Kimi · kimi-k2.6	$0.95	$0.16	17%	none listed	managed by provider	hit/miss split pricing
OpenRouter · z-ai/glm-5.3-flash	$0.036	$0.0108	30%	none listed	provider pool	fresh price repriced since 10-13
OpenRouter · z-ai/glm-5.3	$0.079	$0.059	75%	none listed	provider pool	nearly flat cache structure
OpenRouter · deepseek/deepseek-v4.1-flash	$0.02016	$0.0054	27%	none listed	provider pool	aggregator discount
OpenRouter · moonshotai/kimi-k3	$0.70	$0.32	46%	none listed	provider pool	differs from Kimi direct
OpenRouter · deepseek/deepseek-v4-flash-0731	$0.016	$0.016	100%	none listed	provider pool	no cache discount at all
runaii.cloud · glm-5.3	$1.40	$0.26	19%	none published	not published	202,752-token context
runaii.cloud · glm-5.3-flash	$0.15	$0.03	20%	none published	not published	65,536-token context
runaii.cloud · qwen3.8-max	$2.00	$0.20	10%	none published	not published	10-14 pull; our pricing page shows "—" here
runaii.cloud · qwen3.8-flash	$0.40	$0.04	10%	none published	not published	our pricing page shows "—" here

Pulled 2026-10-14 from developers.openai.com/api/docs/pricing, platform.claude.com/docs/en/docs/about-claude/pricing, ai.google.dev/gemini-api/docs/pricing, api-docs.deepseek.com/quick_start/pricing, platform.kimi.ai/docs/pricing, openrouter.ai/api/v1/models, and runaii.cloud/api/v1/models.

Three things jump out of the ratio column. First, the deepest discounts (2–5%) now come from the premium and specialist lanes, not the budget ones — Anthropic's newest generation and DeepSeek cut reads harder than anyone. Second, the shallow structures are the older or resold lanes: gpt-4o at 50%, OpenRouter's glm-5.3 listing at 75%, and one aggregator listing at a flat 100% — a cached read that bills like a fresh one. Third, our own card sits at 10–20% with no write fee, which is a real structure but not the deepest; we'd rather you see the whole table than our best row.

The prompt caching pricing comparison, provider by provider

If you came here asking about the cache read price OpenAI and Anthropic charge, the short answer is that it flipped with the newest generation: both now cut reads to 5% on their fresh flagships (gpt-6.1-sol, Claude Opus 5.5 and Sonnet 5.5) — and both now charge for writes on those same new models. The details per provider, each verified 2026-10-14.

1. OpenAI — clean 10% reads on the 5 family, 5% on one new model, and a new write fee

Verdict: predictable cache discounts across the catalog — 10% of input on nearly everything, 5% on gpt-6.1-sol — but the newest generation quietly added a 1.25x cache-write fee that most comparisons haven't noticed.

The rates (standard tier, short-context, per 1M): gpt-6-astra $10.00 input / $1.00 cached / $12.50 write / $50.00 output. gpt-6.1-sol $2.00 / $0.10 / $2.50 / $10.00. gpt-6-luna $0.10 / $0.01 / $0.125 / $0.50. gpt-5.6-terra $2.00 / $0.20 / $2.50 / $12.00. gpt-5.6-luna $0.20 / $0.02 / $0.25 / $1.20. The gpt-5.5 generation and older list no write fee: gpt-5.2 $1.75 / $0.175 / $14.00; gpt-5.1 and gpt-5 $1.25 / $0.125 / $10.00; gpt-5-mini $0.25 / $0.025; gpt-5-nano $0.05 / $0.005; gpt-4.1 $2.00 / $0.50; gpt-4o $2.50 / $1.25. Long-context rates step up on the newer models (gpt-6-astra doubles to $20.00 input / $2.00 cached at the long tier), Batch halves everything, and data-residency endpoints carry a 10% uplift on models released March 2026 or later.

Why pick it: you want one catalog where the cached read is a flat 10% of input on almost every model, machine-checkable in the usage response, with no TTL tuning — caching is automatic on prefix match.

Decision notes: the write fee changes first-turn economics on the 6/5.6 models — a lane that charges 1.25x to fill the cache needs at least one re-read before the discount pays, same shape as Anthropic. And if you are still on gpt-4o, the cached column alone is a reason to move: 50% of input on cached reads is the shallowest structure in this table from a first-party provider.

2. Anthropic — the most transparent cache economics anywhere, and the newest reads at 2.5–5%

Verdict: the only provider that publishes read and write rates with two TTL choices for every model — and the 5.5 generation cut reads to 5% of input, with Fable 5.1 at 2.5%.

The rates (per 1M): Claude Fable 5.1 $10.00 input / $0.25 cached read (2.5%) / $12.50 write for 5 minutes or $20.00 for 1 hour / $50.00 output. Claude Opus 5.5 $4.00 / $0.20 (5%) / $5.00 / $8.00 / $20.00. Claude Sonnet 5.5 $2.00 / $0.10 (5%) / $2.50 / $4.00 / $10.00. Claude Haiku 5.5 $0.10 input for prompts up to 100K tokens / $0.01 read (10%) / $0.125 / $0.20 / $0.50 output — prompts over 100K jump to $0.50 input and $0.05 read. The older generation reads at 10%: Opus 5 $5.00/$0.50, Sonnet 4.6 $3.00/$0.30, Haiku 4.5 $1.00/$0.10. The published multipliers: write 1.25x base input for 5 minutes, 2x for 1 hour; read 0.1x standard, 0.05x on Opus 5.5 and Sonnet 5.5, 0.025x on Fable 5.1. Their stated break-even: one cache read recovers the 5-minute write, two reads recover the 1-hour write.

Why pick it: agents that re-read a large context within minutes — the exact shape the write fee is priced for. Enabling it is one field (cache_control on the request, with automatic caching managing breakpoints as conversations grow), and 1M-token context comes at standard pricing on Claude 4.6 and later (except Claude Haiku 5.5).

Decision notes: the write fee is real money on first turns — the 50K-block-on-Sonnet example above ($0.125 to write versus $0.10 to process fresh) is their arithmetic, not ours. The 4.7-and-later tokenizer produces roughly 30% more tokens for the same text, which inflates every column including cached ones. Multipliers stack with the 50% Batch discount and the 1.1x US-only inference option. For sparse re-reads, the 5-minute TTL expires and you pay to write again — the 1-hour tier at 2x is the better buy only when you will read at least twice within the hour.

3. Google Gemini — cheap reads with an hourly storage meter and scheduled step-ups

Verdict: 5–10% reads with a twist — explicit caches bill storage by the hour whether you read them or not, and today's rates are promos with published step-up dates.

The rates (per 1M, paid tier): Gemini 4 Argon $2.00 input / $0.10 cached (5%) / $10.00 output through November 30, 2026 — stepping to $4.00 / $0.20 / $20.00 on December 1, with implicit caching only (explicit caches are not supported on this model). Gemini 3.8 Flash $0.75 input / $0.075 cached (10%) / $3.75 output through December 31, 2026, doubling January 1, 2027; explicit caches on the 3.x Flash models add a storage price of $0.50 per 1M tokens per hour (also set to double). Gemini 3.6 Flash carries the same structure and numbers as 3.8. Batch halves input, output, and caching prices.

Why pick it: long-lived caches you re-read many times — the storage meter amortizes beautifully when reads are frequent, and 10% reads on a $0.75-input model is $0.075/1M, genuinely cheap.

Decision notes: storage accrues while the cache sits idle — holding 50K tokens for a quiet day costs about $0.025 per hour on 3.8 Flash, which can exceed what a write-fee provider would have charged once. A cache nobody reads is pure cost. And the step-up dates are published: anything you budget against today's Argon or 3.8 Flash rates should use the doubled December/January numbers. Caching is a paid-tier feature — the free tier does not include it.

4. DeepSeek — the deepest published cache discount, on a clock

Verdict: cache hits at 2% of fresh input with no write fee — the best cache structure in this comparison — gated by peak/off-peak hours that move everything.

The rates (per 1M, deepseek-flash = DeepSeek-V4.1-Flash): peak input $0.30 / cache hit $0.006 / output $1.20; off-peak $0.15 / $0.003 / $0.60. Peak hours are 01:00–04:00 and 06:00–10:00 UTC, Monday through Friday, excluding Chinese public holidays; everything else — including full weekends — is off-peak at half price. The bigger deepseek-v4-pro reads the same way: $1.32 input / $0.044 hit (3.3%) / $3.96 output peak, halved off-peak. No cache-write fee is listed on their pricing page.

Why pick it: rerun-heavy workloads, batch sweeps, eval suites, and anything schedulable. At $0.003/1M for cache hits, the input side of a re-run-heavy pipeline approaches zero, and off-peak output ($0.60/1M) undercuts most lanes' fresh-input price alone.

Decision notes: the discount is on their clock. Interactive traffic that must answer during their peak pays double every column, and the off-peak windows are defined in UTC — map them against your users' hours before you commit. One more wrinkle: the aggregator listing of the same model (below) prices fresh input at $0.02016 with cached reads at $0.0054 — cheaper fresh, shallower ratio (27% versus 2%). Which one wins depends entirely on your hit pattern, which is the thesis of this post.

5. Kimi (Moonshot) — the clearest object lesson in write-fee economics

Verdict: kimi-k3's cached read looks cheap at $0.30/1M until the $3.00–$6.00/1M write shows up — while the K2 code lanes quietly carry 17–20% reads with no listed write fee.

The rates (per 1M): kimi-k3 $3.00 input / $0.30 cached read (10%) / $15.00 output, with a 1,048,576-token context; writing the cache costs $3.00 for a 5-minute entry or $6.00 for 1 hour, the 5-minute TTL applies by default, and a cache hit refreshes the entry's lifetime with no new write charge. kimi-k2.7-code $0.95 input on a miss / $0.19 on a hit (20%) / $4.00 output; kimi-k2.6 $0.95 / $0.16 (17%) / $4.00. The K2 series lists no cache-write fee.

Why pick it: kimi-k2.7-code for coding-agent budgets — a fifth of fresh price on hits, no write fee listed, output at $4.00/1M.

Decision notes: on k3, the write costs a full fresh pass (1x input) for five minutes of cache life; since each hit saves 90% of a fresh pass, the 5-minute write pays for itself after two reads and the 1-hour write ($6.00, 2x) after three. Sparse reruns lose money on the write. Also note that the same kimi-k3 model on OpenRouter reads very differently — that's next.

6. OpenRouter — the only public API that puts cache prices in machine-readable fields

Verdict: one key, 460+ models, and cache-read and cache-write prices per model in a public models API — plus a live demonstration that aggregator prices reprice overnight.

The rates (per 1M, from their models API, 2026-10-14): z-ai/glm-5.3-flash $0.036 input / $0.0108 cached (30%) / $0.90 output — and a receipt for why date-stamps matter: our pull yesterday, published in GLM-5.3-Flash alternatives, priced, read $0.0261 input on this same listing; the fresh price moved overnight while the cached rate held at $0.0108, swinging the ratio from 41% to 30%. z-ai/glm-5.3 $0.079 / $0.059 (75%) / $4.80. deepseek/deepseek-v4.1-flash $0.02016 / $0.0054 (27%) / $0.891. moonshotai/kimi-k3 $0.70 / $0.32 (46%) / $15.00 — cheaper fresh than Kimi's own API ($3.00), a higher cached rate, and no write fee listed, a completely different cache structure for the same model. google/gemini-3.8-flash mirrors Google's own numbers ($0.75 / $0.075) with a write field at about $0.042/1M; the anthropic/claude rows mirror Anthropic's, write fees included.

Why pick it: multi-model routing with per-route cache accounting — because input_cache_read and input_cache_write are fields in their API, your billing code can price cache hits per model automatically instead of scraping docs pages the way we just did.

Decision notes: aggregator prices reflect the current provider pool and move without notice — see the glm-5.3-flash reprice above. Batch variants carry different cache rates again (glm-5.3-flash:batch reads $0.06 input / $0.012 cached). And check the ratio, not the price: one listing in their catalog, deepseek/deepseek-v4-flash-0731, charges the same $0.016/1M for cached reads as for fresh input — a 100% ratio, meaning no cache discount at all. A cheap input price with a flat cache column is how a rerun-heavy workload quietly pays full freight.

7. runaii.cloud — a published cached rate on every model, no write fee, and the honesty notes

Verdict: our card publishes a cached-read rate on every model — 10–20% of fresh input — with no cache-write price; the caveats you should weigh are printed right here because this is a verification-first post.

The rates (per 1M, from our public models API, 2026-10-14): glm-5.3 $1.40 input / $0.26 cached read (19%) / $4.40 output, 202,752-token context. glm-5.3-flash $0.15 / $0.03 (20%) / $0.50, 65,536-token context. qwen3.8-max $2.00 / $0.20 (10%) / $6.00, 32,768. qwen3.8-flash $0.40 / $0.04 (10%) / $1.60, 32,768. Cached reads bill at the published input_cache_read rate and show up in the response's usage fields — prompt_tokens_details.cached_tokens, the same shape OpenAI uses — and the API publishes a per-minute capacity for cached prompts equal to the fresh rate (600,000 prompt tokens per minute on glm-5.3-flash, for example). Full details on the full rate card.

Why pick it: a simple structure — one cached rate per model, no write fees, no TTL tiers to reason about, and the cache split visible in every response so your own accounting can verify what we bill.

Decision notes, the honesty part: two of them. First, at authoring time all four lanes read is_ready: false in the public models API — that flag is the gate, so check the endpoint before pointing production here; yesterday the Qwen lanes read true, which is exactly why we date-stamp everything. Second, a discrepancy on our own site that we are flagging rather than hiding: our pricing page currently renders an em dash in the cached column for both Qwen lanes while the models API lists $0.20 and $0.04, and the page also lists a DeepSeek V4.1 Flash row ($0.22 / $0.022 / $0.66) that the models API does not return. This table follows the models API as the source of truth; the page is being corrected. If we will footnote our own pricing page, you can trust the footnotes on everyone else's.

The one-minute self-audit

Every number above came from a public page or API, and every page can lie, lag, or reprice the day after we pulled it. The signature move — the one we recommend before trusting any cached-pricing claim, including ours — is to measure the lane yourself with one duplicated prompt:

from openai import OpenAI

client = OpenAI(
    base_url="https://<your-lane>/v1",   # from the lane's docs
    api_key="YOUR_API_KEY",
)

big = "..."  # a few thousand tokens: your real system prompt + a document

# send once — this populates the cache
r1 = client.chat.completions.create(
    model="<model-id>",
    messages=[{"role": "user", "content": big}],
    max_tokens=16,
)

# send the exact same prompt again, immediately — this should hit the cache
r2 = client.chat.completions.create(
    model="<model-id>",
    messages=[{"role": "user", "content": big}],
    max_tokens=16,
)

print(r2.usage.prompt_tokens_details.cached_tokens)

Read the second response's usage, not the first. On OpenAI-compatible lanes the field is usage.prompt_tokens_details.cached_tokens; Anthropic reports cache_read_input_tokens and cache_creation_input_tokens in its usage block; DeepSeek reports prompt_cache_hit_tokens and prompt_cache_miss_tokens; Google reports cachedContentTokenCount in usageMetadata. All are public API fields — no scraping required.

How to interpret it:

• cached_tokens is large on send two — the cache works. Now multiply: cached tokens times the lane's cached rate, fresh tokens times the input rate, and check the billed total matches. If the bill and the usage disagree, you have found something worth a support ticket.
• cached_tokens is zero on send two — the discount you read about is not reaching your traffic. Common causes: the lane does not cache that model at all, the prompt prefix changed between sends, the cache expired between your two requests, or the block is under the provider's minimum cacheable size (several providers set one — check their docs). Any of these means the cached-read column is theoretical for you.
• cached_tokens is nonzero but the ratio looks wrong — divide the cached price by the fresh price yourself and compare against this table. A 75% or 100% "discount" lane bills nearly like a no-cache lane.

One minute, two requests, and you know more about your actual unit costs than any comparison post can tell you. This is the same test we describe in the coding-agent cost comparison, and it is the only way to turn a table like this one from marketing into measurement.

What caching saves on a real workload shape

This section is labeled arithmetic, not measurement: we take published rates pulled 2026-10-14 and push a fixed token shape through them. Nothing here was run against a live system, and your own fresh/cached/output ratio from real logs is the most predictive number you can bring to this decision.

The modeled session: a 30-turn coding-agent conversation. Stateless chat APIs require re-sending the full context every turn, so the agent's prompt grows and re-sends. Simplified to fixed totals for comparability: 50,000 fresh input tokens (new material processed once at the fresh rate), 200,000 cached-read tokens (the re-sent prefix read from cache, summed across turns), and 6,000 output tokens (200 per turn). On lanes that charge a write fee, the 50K context block is additionally written once — assuming turns land inside the 5-minute TTL, which each hit refreshes. On DeepSeek's off-peak row, the whole session is assumed to land in an off-peak window.

Lane (published rates per 1M)	Fresh 50K	Cached 200K	Write 50K	Output 6K	Session total
OpenRouter · glm-5.3-flash ($0.036 / $0.0108 / $0.90)	$0.0018	$0.0022	—	$0.0054	$0.0094
DeepSeek · flash, off-peak ($0.15 / $0.003 / $0.60)	$0.0075	$0.0006	—	$0.0036	$0.0117
runaii.cloud · glm-5.3-flash ($0.15 / $0.03 / $0.50)	$0.0075	$0.0060	—	$0.0030	$0.0165
OpenAI · gpt-6-luna ($0.10 / $0.01 / $0.50; write $0.125)	$0.0050	$0.0020	$0.0063	$0.0030	$0.0163
DeepSeek · flash, peak ($0.30 / $0.006 / $1.20)	$0.0150	$0.0012	—	$0.0072	$0.0234
runaii.cloud · qwen3.8-flash ($0.40 / $0.04 / $1.60)	$0.0200	$0.0080	—	$0.0096	$0.0376
OpenAI · gpt-5.2 ($1.75 / $0.175 / $14.00)	$0.0875	$0.0350	—	$0.0840	$0.2065
Anthropic · Claude Sonnet 5.5 ($2 / $0.10 / $10; write $2.50)	$0.1000	$0.0200	$0.1250	$0.0600	$0.3050

Modeled arithmetic only: fresh x price + cached x price + (write x price where charged) + output x price, at rates pulled 2026-10-14 from the sources above.

Now the same session with the cache doing nothing — all 250K prompt tokens billed fresh — to show what the cache columns are worth:

Lane	No-cache total	Cached total	Cache cut
runaii.cloud · qwen3.8-flash	$0.1096	$0.0376	66%
OpenAI · gpt-5.2	$0.5215	$0.2065	60%
Anthropic · Claude Sonnet 5.5	$0.5600	$0.3050	46%
DeepSeek · flash, peak	$0.0822	$0.0234	72%

Three lessons from the arithmetic. The spread across lanes for the identical token shape is 32x ($0.0094 to $0.3050) — the cached column, not the headline input price, is the unit economics of agents. The write fee on Sonnet 5.5 ($0.125) is larger than the fresh-processing bill for the same block ($0.10), yet the session still saves 46% overall — write fees punish first turns, not well-read caches. And Anthropic's real bill would come in below our modeled $0.3050, because a cache-written token bills at the write rate instead of the input rate rather than both — we modeled the conservative way and stated it. Swap in your own fresh/cached/output ratio and this table becomes your shortlist.

Which provider fits your access pattern?

• Long system prompt, many quick turns (support bots, routing, classification): a no-write-fee lane with deep reads — DeepSeek at 2%, or our Qwen lanes at 10% once you have checked the readiness flag. Your fixed prompt is written once for free and read at a discount all day.
• Coding agents with a growing context, turns within minutes: Anthropic's 5.5 generation — 5% reads, and the 5-minute write amortizes on the first re-read; OpenAI's gpt-6.1-sol at 5% with the same write-fee shape, or gpt-5.2 at 10% with none.
• Overnight evals, batch reruns, CI sweeps: DeepSeek off-peak — $0.003/1M reads and $0.60/1M output is the cheapest verified combination in this table, and nothing in a batch job cares about their peak hours if you schedule around them. OpenRouter's batch listings are the second look.
• Long-lived caches re-read across hours: Gemini's explicit caches with hourly storage — cheaper than re-paying write fees, as long as the cache is actually being read. Compare against the write-fee lanes with the arithmetic above.
• Multi-model routing with per-route accounting: OpenRouter — the cache-read and write fields in their models API make the billing code trivial, at the cost of pool-driven repricing.
• Budget agentic work on one card: our glm-5.3-flash at 20% reads with no write fee and the cheapest output rate in our card — pending the readiness flag — or qwen3.8-flash at 10% reads today's-checklist permitting. Start from the full rate card and run the self-audit before committing.
• Per-token anxiety, none of the above: flat-rate coding plans trade the cached/fresh/write triangle for a visible quota — sometimes the right answer is no meter at all.

Sources and freshness

Every price was verified on 2026-10-14, in the session that wrote this post:

• runaii.cloud models API — our four rows (glm-5.3 $1.40/$0.26/$4.40; glm-5.3-flash $0.15/$0.03/$0.50; qwen3.8-max $2.00/$0.20/$6.00; qwen3.8-flash $0.40/$0.04/$1.60), context lengths, per-minute cached-prompt capacities, and is_ready flags (all false at authoring) as quoted. Note: the API's lineup changes over time — the 10-14 pull included qwen3.8-max; a later pull may not. Check the endpoint for the live card.
• runaii.cloud pricing page — checked for the footnote: the Qwen lanes' cached cells render as em dashes there while the models API lists numbers, and the page carries a DeepSeek V4.1 Flash row the API does not.
• developers.openai.com/api/docs/pricing — every OpenAI row: the gpt-6/5.6 write fees, 5% read on gpt-6.1-sol, 10% across the 5 family, 25%/50% on the 4.1/4o era, long-context steps, batch halves, the 10% data-residency uplift, the Sol promo note.
• platform.claude.com/docs/en/docs/about-claude/pricing — every Anthropic row: per-model input/output/write/read rates, the 1.25x/2x/0.1x (and 0.05x/0.025x) multipliers, the one-read/two-read break-even, automatic caching, the 30% tokenizer note, 1M context at standard pricing on 4.6+, Haiku's 100K prompt threshold.
• ai.google.dev/gemini-api/docs/pricing — Gemini 4 Argon and 3.8/3.6 Flash rates, implicit-only caching on Argon, the $0.50/1M-per-hour storage price, and the published step-up dates (Dec 1 2026 for Argon, Jan 1 2027 for the Flash models).
• api-docs.deepseek.com/quick_start/pricing — deepseek-flash (V4.1-Flash) and v4-pro peak/off-peak rates, cache-hit prices, the 01:00–04:00 and 06:00–10:00 UTC peak windows, weekends off-peak.
• platform.kimi.ai/docs/pricing — kimi-k3 and the K2 lanes, the $3/$6 write TTLs, the default 5-minute TTL, hit-refresh behavior.
• openrouter.ai/api/v1/models — all aggregator rows, the input_cache_read/input_cache_write fields, the overnight glm-5.3-flash reprice, the 100%-ratio caution listing.

The comparison context for the GLM lanes — Z.ai's coding plan, yesterday's OpenRouter pull, the sibling-model rates — is in GLM-5.3-Flash alternatives, priced, verified 2026-10-13. Z.ai's per-token console rates were not publicly fetchable this session; check their current page.

Prices in this market move weekly at best and overnight at worst — the glm-5.3-flash reprice in the OpenRouter section happened between two consecutive daily pulls. Every table here carries its pull date; treat any number older than a week as a question, not a quote.

Changelog

• 2026-10-14: initial draft. All prices verified this date from the sources above (live runaii.cloud models API and pricing page; OpenAI, Anthropic, Google, DeepSeek, Kimi public pricing pages; OpenRouter models API). Notable receipts this session: OpenAI's newest generation (gpt-6, gpt-5.6) carries cache-write fees at 1.25x input; Anthropic's 5.5-generation reads at 5% of input and Fable 5.1 at 2.5%; Gemini publishes step-up dates for its promo rates; OpenRouter's glm-5.3-flash fresh input repriced from $0.0261 to $0.036 since the 2026-10-13 pull in our GLM alternatives post. runaii readiness state at authoring: all four lanes is_ready: false; our pricing page's cached-column dashes on the Qwen lanes flagged for correction. Re-verify every price before publication, then weekly, and immediately if any listed lane reprices.