TL;DR

On kimi-k3, a cache hit costs $0.30 per million tokens against $3.00 for a miss, so every hit saves $2.70 per million. Writing the cache with a 1h TTL costs $6.00 per million instead of the $3.00 that 5m costs, and Kimi's own worked example says two hits inside the hour already pay that premium back. Three rules decide the rest of the bill: the TTL locks at first write, the 5m and 1h caches never share entries, and any edit to a prefix invalidates everything stored after the edited position.

An agent loop resends almost the same request every turn: system prompt, tool definitions, then a conversation history that only grows. Kimi caches that repeated prefix automatically and bills reused tokens at one tenth of the input price. The general mechanics of prefix caching are the same across vendors, and our prompt caching guide covers them. This article sticks to the Kimi-specific numbers: the published unit prices, the exact TTL semantics from the platform docs, and the console metric that tells you whether the cache earns its write fees.

What does Kimi charge for cached tokens?

The docs price four line items for kimi-k3, in USD per million tokens:

Billing item (kimi-k3, per 1M tokens)Price
Input, cache miss$3.00
Cache write, 5m TTL$3.00
Cache write, 1h TTL$6.00
Cached input, cache hit$0.30
The four cache line items for kimi-k3. The hit price does the work; the 1h write price is the one you have to justify.
Bar chart of kimi-k3 context caching prices per million tokens: input cache miss 3 dollars, cache write with 5 minute TTL 3 dollars, cache write with 1 hour TTL 6 dollars, cached input on a hit 30 cents

A hit costs exactly one tenth of a miss and saves $2.70 per million tokens every time it lands. Both kimi-k3 and kimi-k3.1-pro support cache writes. Entries are isolated by organization: everyone inside one org reads the same cache, and nobody outside it does. These prices exclude taxes and are what the docs listed on November 21, 2026.

One detail in that table is easy to miss. A 5m cache write costs the same $3.00 as an ordinary miss, so with the default TTL, caching never makes your first request more expensive. The 1h write is the one that charges a premium, and whether that premium is worth paying is arithmetic.

Is the 1h TTL worth double the write price?

Kimi's docs answer with their own example. Writing a 1M-token prefix with the 1h TTL costs $3.00 more than writing it with 5m. Each hit that the longer TTL rescues from expiry saves $2.70 against re-reading at the miss price. Two rescued hits save $5.40, minus the $3.00 premium, for a net gain of $2.40. In the docs' phrasing, two more hits within the hour and 1h already costs less than 5m.

The same arithmetic as a cost curve, for a 1M-token prefix where calls arrive more than five minutes apart:

Requests in the hour5m TTL1h TTL
1 (the write)$3.00$6.00
2$6.00$6.30
3$9.00$6.60
5$15.00$7.20
The docs' worked example as a cost curve. Two hits after the write and the 1h premium is already repaid.
Line chart of cumulative input cost for a one million token prefix over five requests within an hour. The 5 minute TTL line climbs 3 dollars per request to 15 dollars because every gap expires the entry. The 1 hour TTL line starts at 6 dollars and adds 30 cents per hit, crossing under the 5 minute line at the third request

The 5m column is the worst case for 5m: every gap exceeds the TTL, so every request misses and rewrites at $3.00. A job that runs every ten minutes misses a 5m cache forever and pays full price on every call. If your gaps reliably stay under five minutes, 5m is strictly better, since its write is free and its hits cost the same $0.30.

That gives a simple decision rule. Estimate how many times the same prefix gets reused within an hour. Zero or one reuse, and 5m loses nothing. Two or more, and 1h wins. Gaps longer than five minutes with reuse you care about, and 1h is not a nice-to-have; it is the difference between a 90% input discount and no discount at all.

If you run agents across more than one model family, our Multi-Model Coding Plan covers eight text models behind one API key with shared points, so one balance carries the whole fleet.

How do you set the TTL, and can you change it later?

You set it per request, and no, you cannot change it later. On the Chat Completions and Responses APIs, pass prompt_cache_options:

{
  "model": "kimi-k3",
  "messages": [ ... ],
  "prompt_cache_options": { "mode": "implicit", "ttl": "1h" }
}

Omit the field and you get 5m. The Anthropic Messages API integration works differently: ttl goes in the top-level cache_control field, and a cache_control marker inside the message body is ignored.

The lifecycle rules are where Kimi differs from what people assume coming from other providers:

  • The TTL locks at first write. An entry written with 5m cannot be promoted to 1h. To switch, wait for the entry to expire completely, then write again with the new TTL.
  • 5m and 1h are two separate caches. They do not share entries, so a prefix cached under 5m will not produce a hit for a request that asks for 1h.
  • Every hit renews the entry under its original TTL, at no extra charge. Hit tokens bill at the cached-input rate, never the write rate. A prefix that stays in use never expires.
  • There is no manual eviction. No API clears a cache entry; a wrong-TTL write is stuck until it expires on its own.
  • The cache stores whole blocks. A tail smaller than one full block cannot be written to cache and bills at the miss rate.

What silently kills a cache hit?

Three behaviors break reuse, and none of them raises an error. The request succeeds, the answer looks right, and the bill quietly returns to the miss price.

Editing the prefix invalidates everything after the edited position. Rewrite one line of a system prompt and every cached token stored below that line is gone, even if the rest of the request is identical.

A dynamic field near the top of the request does the same damage on every call. A timestamp, a random ID, or a session UUID inside the cached region guarantees a miss for the whole body underneath it. Keep volatile values out of the prefix and put them in the newest user message instead.

Inactivity expires entries on a timer. Five minutes of silence retires a 5m entry, and an hour retires a 1h entry. Hits reset the clock, and nothing else does.

Prefix edits, dynamic fields, and TTL expiry all fail the same way: the response looks normal and the bill does not.
Three panel diagram of the behaviors that break a Kimi cache hit. Panel one: editing the tool definitions block invalidates every cached block after it. Panel two: a timestamp at the top of the prefix makes the whole body uncacheable. Panel three: a gap longer than the TTL expires the entry and the next request pays the miss price plus a new write

How do you audit your own cache bill?

The Kimi console has a Caching Overview page that breaks tokens down per model into hits, misses, and cache writes, and shows the hit rate next to one derived metric worth pasting into your own dashboards: the cache-write amortization multiple, cached tokens divided by cache write tokens. The higher it climbs, the more each written token gets reused. If it sits near 1, you write about as much as you read back, and the cache barely pays for itself.

Per request, the usage object carries the same split:

APICache read fieldCache write field
Chat Completionsusage.prompt_tokens_details.cached_tokensusage.prompt_tokens_details.cache_write_tokens
Responsesusage.input_tokens_details.cached_tokensusage.input_tokens_details.cache_write_tokens
Messagesusage.cache_read_input_tokensusage.cache_creation_input_tokens

Response headers also expose Msh-Usage-Cache-Write-Tokens-5m and Msh-Usage-Cache-Write-Tokens-1h, which is the quickest way to check which cache your traffic is actually writing to.

A short self-check list, in the order the problems usually show up:

  1. Amortization multiple under 2: your entries are expiring between calls. Check the gap against the TTL and consider writing with 1h.
  2. High write tokens with a low hit rate: something churns the prefix. Diff two consecutive request bodies and find the first byte that differs. It is usually a timestamp or an ID.
  3. Hit rate fine but the bill barely moved: you may be caching a small slice of a large prompt, and the sub-block tail bills as a miss. Compare cached_tokens against total prompt tokens.
  4. No cache activity at all: confirm the model is kimi-k3 or kimi-k3.1-pro, the two ids the docs list for cache write support.

For a sense of the ceiling, a well-shaped agent loop hits the cache on nearly everything. When we compared Step 5 Preview with DeepSeek V4.1 Flash, the launch coverage reported that 96% of Step 5 Preview input tokens were cache hits. Kimi's tenth-price hits reward exactly the same traffic shape: stable tools and system prompt, append-only history, volatile strings at the end.

FAQ

Can I switch a live cache entry from 5m to 1h?

No. The TTL locks at the first write and cannot change while the entry lives. Wait for it to expire completely, then send the next request with ttl set to 1h. Because the two TTLs are separate caches, the new entry starts empty and the first request pays the 1h write price.

Does a cache hit extend the TTL?

Yes. Every hit renews the entry under its original TTL at no extra cost, so an actively reused prefix never expires. Only unbroken inactivity, longer than the TTL, retires an entry.

My hit rate looks good, so why is the bill still high?

Look at the amortization multiple in the console. A high hit rate with heavy write volume means the cache keeps getting rebuilt, and every rebuild bills at the write price. Prefix churn from dynamic fields, or gaps that expire entries between runs, are the usual causes.

Do I pay the cache write price on every request?

Only when new content gets written. The 5m write costs the same as a miss ($3.00 per million on kimi-k3), the 1h write costs double that, and tokens served from cache always bill at $0.30 per million with no write fee on top.