Account and dataBeginnersUpdated

Claude Code cache billing and savings: how to resume after a long pause

If an old conversation has grown very long and you are about to take a break, its cache may have expired by the time you return. In that situation, a cheaper approach is often to ask AI for a short handoff summary, then start a new conversation with only that summary and the files needed for the next task. If you are actively working on the same task and the cache keeps hitting, do not start new conversations repeatedly just to save money.

The goal is not simply to create more or fewer conversations. It is to avoid repeatedly rebuilding a very large old context after its cache expires.

Why can a short message still produce a large charge?

Claude Code usually sends more than the message you just typed. It may also include project files, earlier conversation, tool results, and records of code changes. Together, these form the request context.

Tokens are the units a model uses to process text and code; they are not the same as words or characters. Charges are based on actual token usage and the current RMB unit prices. See pricing, balance, and usage for the relevant pages.

How are input, cache, and output charged?

ComponentWhen it appliesWhat it means
Regular inputNew content is not served from cacheProcessing new input
Cache writeA cache is first created, rebuilt after expiry, or extended with new contentPlacing context in temporary cache
Cache readValid cached content can be reused for the requestReusing existing context, usually cheaper than writing it again
OutputThe model generates an answer, code, or reasoningGenerating new content

A request can contain both cache reads and cache writes during normal incremental updates. The model reads the old context and writes the newly added portion; this does not mean the entire old conversation was charged again. If a request has zero cache reads but a very large cache write, it usually did not reuse the old cache and deserves attention in the usage details.

Why might the cache need to be recreated after a pause?

Cache is temporary storage that accelerates later requests, not a permanent archive. Common lifetimes are 5 minutes or 1 hour. After the cache expires, or when the beginning of the context changes, the next request may no longer be able to read it. If the task still needs that content, the system must process and cache it again.

This is not an automatic charge when the timer expires. A new cache-write charge occurs only when you later make a request that needs to rebuild the cache. A “1-hour cache” is not an hour of prepaid usage. Write prices can differ by cache lifetime; check the current pricing page. A longer lifetime does not guarantee a lower total cost.

When a conversation is large and you are ready to pause or move to the next stage:

  1. Finish the current unit of work: confirm that code changes are saved and necessary tests or checks have run.
  2. Ask AI for a handoff summary: retain only the goal, progress, key files, and next steps instead of copying the entire chat.
  3. Start a new conversation: paste the summary and add only the files or requirements needed for the next task.
  4. Check actual usage: compare cache-write tokens and charges in usage details, rather than judging cost only by the length of your latest message.

You can send this prompt before closing the old conversation:

text
We are about to close this conversation and start a new one. Create a handoff summary of no more than 500 words containing only:
1. The task goal;
2. Work completed;
3. Files changed and the key changes;
4. Important decisions and constraints;
5. Verification commands run and their results;
6. The next steps.
Do not repeat casual discussion or paste complete code.

Starting a new conversation does not undo saved project-file changes, but it does not automatically remember the old discussion. The handoff summary must contain enough information to continue.

A simple example

Suppose an old conversation contains 600,000 tokens of context. Continuing after the cache expires may require writing those 600,000 tokens again. If the handoff summary and necessary context contain only 30,000 tokens, the new conversation's initial cache write processes only those 30,000 tokens.

Both approaches can still incur cache-write, regular-input, and output charges. The saving comes from not processing a large old context again, not from making the new conversation free. Actual token counts depend on the client, project, and task; use the usage details as the source of truth.

When should you keep the old conversation?

  • You are actively working on the same task and its cache is still hitting: continuing is usually cheaper.
  • You are considering a new conversation every few messages: each one may need to establish its initial context again, increasing costs.
  • The old discussion contains critical details that cannot safely be compressed: make sure the summary is sufficient before switching.

A practical habit is to finish one task at a time and switch conversations at clear task boundaries after writing a summary, rather than returning intermittently to one very large conversation over a long period. For simple tasks, also consider a more suitable model on the pricing page.