Claude Code subscriptions have two limits: a 5-hour window and a weekly limit, both shown as a percentage used. Everyone says resuming a cold session is expensive. I wanted to know how expensive in the units that actually lock you out, so I resumed two idle sessions one at a time and logged both meters and the token counts of every request.
Result: each cold resume took 5–7% of my 5-hour limit and 1% of my weekly limit. Both sessions were Opus 5.5 with 170–210k tokens of context. In both, the first two requests after the resume each wrote the whole conversation to the cache, so the second write was about half of the cost.
rate_limits.five_hour.used_percentage and rate_limits.seven_day.used_percentage to the statusline on every refresh. A statusline script appended each change to a log with a timestamp.usage record: tokens written to cache (cache_creation_input_tokens), read from cache (cache_read_input_tokens), new input and output.Last request on November 13. I resumed it at 15:32 and sent one message. When it started a tool call I pressed Esc, and it replied once more.
| Request | Time | Written to cache | Read from cache | Output | 5-hour | Weekly |
|---|---|---|---|---|---|---|
| 1. Reply to my message | 15:32:26 | 209,269 | 0 | 508 | 12% → 16% | 42% → 43% |
| 2. Reply after Esc | 15:35:02 | 190,989 | 24,880 | 70 | 17% → 21% | 43% |
The meter moved 12% → 21%. Leaving out the measuring session, Session A's own requests account for about 7 points of the 5-hour limit, and the weekly limit moved 1 point.
Last request on November 4. My first message was stopped by L2Cache's cold-resume guard ("stopped this message so it doesn't reload 183k tokens"). No request was sent, so that cost nothing. I sent it again at 15:38:12. The model replied and kept working, so requests 2 and 3 came 10 and 16 seconds after the first.
| Request | Time | Written to cache | Read from cache | Output | 5-hour | Weekly |
|---|---|---|---|---|---|---|
| 1 | 15:38:41 | 143,581 | 25,103 | 289 | 21% → 24% | 43% → 44% |
| 2 | 15:38:51 | 146,688 | 24,880 | 161 | 24% → 27% | 44% |
| 3 | 15:38:57 | 1,283 | 171,568 | 284 | 27% → 28% | 44% |
| Next 8 requests | to 15:40:59 | 13,187 total | 1,777,660 total | 3,564 | 28% → 29% | 44% |
The two cache writes took the 5-hour meter from 21% to 27%: about 5 points once the measuring session is left out. The weekly limit moved 1 point. The next eight requests, all reading the warm cache, cost about 2 points together.
In both sessions the second request read only about 25k tokens from cache, which is the system prompt and tool definitions, and wrote the conversation again. In Session B that happened 10 seconds after the first write, with no Esc involved. The transcript doesn't record why. From the third request on, reads covered the full context as normal.
Anthropic doesn't publish how the plan meters weight tokens. If I weight them by Opus API price ratios (input 1×, 1-hour cache write 2×, cache read 0.1×, output 5×), every request in the run comes to about 1.92 million input-token equivalents, and the 5-hour meter moved 17 points:
| Source | Input-token equivalents | Share of 5-hour points |
|---|---|---|
| Session A (2 requests) | 805,898 | ~7 |
| Session B (11 requests) | 830,917 | ~7 (5 from the two writes) |
| Measuring session | 281,974 | ~2.5 |
| Total | 1,918,789 | 17 |
You need a statusline script that logs the meters, and the session transcript. Neither needs L2Cache.
1. Log the meters. Point statusLine in ~/.claude/settings.json at this script (needs jq):
#!/bin/bash
input=$(cat)
line=$(echo "$input" | jq -r '[.rate_limits.five_hour.used_percentage,
.rate_limits.seven_day.used_percentage] | @tsv')
if [ "$line" != "$(cat ~/.claude/usage-last 2>/dev/null)" ]; then
printf '%s\t%s\n' "$(date +%T)" "$line" >> ~/.claude/usage-log.tsv
printf '%s' "$line" > ~/.claude/usage-last
fi
echo "5h ${line%%$'\t'*}%"
2. Read the transcript. Sessions live in ~/.claude/projects/<project>/<session-id>.jsonl. This prints each request after a UTC timestamp:
import json, sys
seen = set()
for line in open(sys.argv[1]):
d = json.loads(line)
m = d.get("message") or {}
u = m.get("usage") if isinstance(m, dict) else None
if not u or m.get("id") in seen or d.get("timestamp", "") < sys.argv[2]:
continue
seen.add(m["id"])
print(d["timestamp"][11:19], "write", u.get("cache_creation_input_tokens"),
"read", u.get("cache_read_input_tokens"), "out", u.get("output_tokens"))
Run it as python3 usage.py <session>.jsonl 2026-11-16T04:30. Then resume a session that has been idle longer than its cache lifetime, send a short message, and compare the two logs. Keep everything else idle while you do it.
L2Cache reads your Claude Code session files and the same statusline data on your Mac, so it can step in at each point where this test spent the limit. Nothing is sent anywhere.
The first step is knowing what a session will cost before you open it. Developer Home in L2Cache has a Pick up where you left off card for each recent session, showing its context size and cache state:
Next to it, the card compares the current session with a fresh start plus a handoff, so you can pick before spending anything. In the example below, 254k tokens against an estimated 52k starting context.
Cold cache at 14:05 — this session's cache expired 3 h ago.
Your next message reloads 183k tokens (≈ 40× a warm turn).
Cheaper: type /clear — L2Cache starts a fresh session with this session's handoff.
Or just send your message to continue as is.
/clear and the new session starts with a short handoff (goal, files, what's done, what's next) instead of 183k tokens./compact now for the same task, or /clear for a new one; below that, a repeat is cheap and it says no action is needed./compact before leaving it, while the cache is still warm./clear and start from a short handoff instead of reloading 200k tokens. Background on why cold reloads cost so much is in Why resuming a cold Claude Code session costs more.L2Cache shows each session's size, cache state and live plan limits, and stops a cold reload before it happens.
Download L2Cache for Mac