Why Claude Cache Hits Still Cost Money: A Four-Component Bill Check

First, identify which usage fields you are reading

In the Anthropic Messages usage structure, a bill splits into four components:

Under the official native semantics, total input equals the three components combined (non-cached input + cache read + cache write) — that is a token count, not a statement that all three are charged at the ordinary input price. Other compatible protocols (for example an OpenAI-style prompt_tokens) may already include cached input and report it in a subfield; similar field names do not imply identical semantics. For streaming responses, confirm you captured the final usage event instead of only the first frame.

Why you cannot apply a flat 0.1x to cached tokens

Per the official Anthropic prompt caching table (read via browser on 2026-10-23): 5-minute cache writes cost 1.25x the base input price, 1-hour writes 2x; cache hits and refreshes are not all 0.1x.

These are official API rules, not quotes any third-party platform must adopt. When auditing a relay bill, use the read/write prices actually in effect on that node at that time; do not estimate with a flat "one tenth of input price", and do not present an official discount multiplier as a promise your platform already honours.

A hand-computable two-request example

All numbers below are constructed examples, not current prices, and do not correspond to any specific model. Assume the same node, model, currency USD, and no long-context surcharges, taxes, discounts or retries; assumed prices: non-cached input 3, output 15, cache read 0.30, 5-minute write 3.75, 1-hour write 6 (USD / 1M tokens).

A = 2,000×3/1M + 1,000×15/1M + 10,000×3.75/1M = 0.006 + 0.015 + 0.0375 = USD 0.0585
B = 2,000×3/1M + 1,000×15/1M + 10,000×0.30/1M = 0.006 + 0.015 + 0.003  = USD 0.024
Two calls total USD 0.0825 (no-cache baseline USD 0.102, about 19.12% saved)

B hit the cache and was still charged USD 0.024 — the read itself has a price, plus new input and output. The first write A costs USD 0.0075 more than a single uncached call: one hit does not guarantee the whole task is cheaper; request count, reused prefix, output size and write price all change the outcome. If A's write used the 1-hour tier (6/1M), the two calls total USD 0.105, above the no-cache baseline.

Why cache writes split by TTL

Per the official docs, the TTL clock starts when the request that writes or reads the cache begins (not when the response ends), and response generation time consumes the TTL. The official default is 5 minutes, and each read refreshes the retention window instead of recharging a write fee. cache_creation_input_tokens equals the sum of the 5-minute and 1-hour sub-items; price each TTL sub-item separately and never bill the aggregate field twice. Whether a third-party node follows the same refresh rules, minimum cacheable length and prefix requirements must be checked against that node's current docs; asking the same question twice does not guarantee a hit.

Missing, null and zero are three different things

A missing or null usage field means the record provides no value — it must not be filled with zero; an explicit zero only means the record reported zero. A cache-read field that is always zero does not by itself prove "the platform swallows the field" — the prefix, length or TTL may not qualify, the model or node may not support caching, the request may not enable the mechanism, or the protocol mapping may differ. Conversely, cache_read_input_tokens greater than zero does not prove the model comes from a direct official connection. Usage is billing evidence, not supply-chain authentication.

Audit an existing bill without sending any request

1. Record the time, timezone, request ID, actual model and node/group, plus client version, protocol and whether streaming was used; never copy keys or private code.
2. Copy the four usage components from the raw response and the console; write "unknown" for missing values with the source noted, and confirm whether non-cached input must exclude the cached amounts to avoid double deduction.
3. Save the unit prices actually in effect for that call, with units, currency, TTL, context tier, discounts and surcharges, and multiply component by component; do not substitute today's market floor price for a historical node price.
4. Compare the unrounded calculation with the bill, then check minimum billing precision, currency conversion and the final charge; for any discrepancy, query by the same request ID instead of guessing per-call cost from balance deltas.
5. List retries and timeouts as separate requests; a timeout does not guarantee the task did not complete or was not billed — check existing records before retrying.

Current listed prices and multipliers per node are on the live pricing page and the public evidence snapshot; for Claude Code endpoint and model configuration see the Claude Code setup guide.

Sources and disclosure

This article is written by the TokenDos operator and is a related-party disclosure, not an independent review. Official rules come from the Anthropic prompt caching docs (read via browser on 2026-10-23) and the official pricing entry; the worked examples are constructed and were not validated against a real bill. Cite the source when republishing.