Where your Claude Code tokens went

25 Sep 2026 to 10 Nov 2026 (46 days) · $2,465 spent, about $375 a week · 594 sessions · list prices as of anthropic-list-2026-11-09
Claude Code deletes session logs once they have gone unused for 30 days (by default), so older work drops out of reports. Set "cleanupPeriodDays": 365 in Claude Code's settings to keep a year.
25 turns used a model with no known price and are left out.

You are on the Max 5× plan, a flat fee: these figures are list prices, a measure of how much of your usage limits work takes, not money you would get back. Claude Code stopped 2 times because a usage limit was reached (1 at the 5-hour limit and 1 at the weekly limit), most recently on 10 Oct. Not enough status-line readings yet to show savings as a share of your weekly limit.

58% of your spend went on sending turns over 200k tokens

A token is a word-piece of about four characters. Every turn sends the whole session so far, so turns get dearer as a session grows: only 43% of turns were this large, but each cost $0.14–$0.25, against $0.07 for smaller ones.

Spend

Turns

Up to 50k tokens: $113, 5% of spend, 8% of turns50k–200k tokens: $702, 28% of spend, 49% of turns200k–500k tokens: $721, 29% of spend, 25% of turnsOver 500k tokens: $929, 38% of spend, 18% of turns

$2,006 paid to send the session to Claude

Claude's replies cost another $459. This is what was being sent.

Your messages and Claude's replies, sent again each turn: $1,077 (54%)Tool output: $378 (19%)Commands and files Claude wrote: $239 (12%)System prompt and tool definitions: $183 (9%)Text Claude Code added: $129 (6%)

What to do first

Largest possible saving first. Several of these target the same money, so their savings can't be added up.

Compact long sessions earlier

Every turn sends the whole session again, so long sessions get dearer each turn. 31 sessions passed 200,000 tokens; Claude Code compacts on its own only near the limit. 5 sessions went past 500,000 tokens without compacting at all.

likely about $618 ($585–$680) · up to $947

Compact when a session passes about 200,000 tokens, or between tasks.

Run /compact yourself (/context shows the current size). Claude Code compacts on its own only near the context limit.

How "likely" was worked out: Replays each main session as if compacted to 92,239 tokens (what the first request after a compaction typically sends) whenever it passed 200,000, including the cost of each compaction, and assumes it then went on the same way. Re-reading files after a compaction would lower the saving. The size after a compaction varies (the middle half of 20 measured runs from 77k to 99k tokens): at 77k the likely saving is $680, at 99k it is $585.

Shares money with the long-pause and tool-output fixes: do not add them.

38% of spend at most · Trimloop pattern P19

Or: Start a new session for each task.

Use /clear between tasks, carrying over a short note of where things stand.

Run sub-agents on a cheaper model

Sub-agents (helpers Claude starts for side tasks) cost $661, and 98% of that was on a model with a cheaper choice. The saving assumes all of those moved to Sonnet 5.5.

up to $337 · mostly general-purpose, Explore, Plan

Run sub-agents that search, read and summarise on Sonnet 5.5.

Define the agents you use for searching, exploring and web research in .claude/agents/<name>.md with "model: sonnet" in the front matter, and use them instead of general-purpose.

Then check: Untested for quality: after a week, compare the agent type's turns per run and tool errors with before, and switch back if they rose.

14% of spend at most · Trimloop pattern P13

Or: Ask for the cheaper model when starting a sub-agent.

Add to CLAUDE.md: "When starting a sub-agent to search, read or summarise, pass model: sonnet; keep the main model for design work and tricky changes."

Start fresh after a long break

109 times, you carried on after more than an hour away. The saved copy of the session (the cache) had expired, so the next turn paid to store all of it again. Starting a new session instead costs about $0.07 for its first turn. Another 30 long waits were on a tool, a sub-agent, a timer or another agent, not on you; they are left out of this saving.

likely about $302 · up to $312

After a break of over an hour, start a new session with a short note instead of carrying on.

Before the break, ask Claude for a short note of where things stand; afterwards, /clear and paste it in.

How "likely" was worked out: As if each of those turns had started a new session of about 14,011 tokens.

Shares money with the compaction fix: do not add them.

13% of spend at most · Trimloop pattern P09

Or: Compact before a long break, while the cache is still warm.

Run /compact before stepping away; compacting after the break re-sends the whole session.

14 smaller changes

Keep long waits out of sessions with a 5-minute cache

83 times (81 in sub-agents), a session whose cache lasts 5 minutes waited longer, up to an hour, so its next turn paid to save its whole history again. In these logs 273 main sessions and 239 sub-agents used the 5-minute cache; 82 main sessions and 0 sub-agents kept theirs for an hour.

up to $101

Run long builds, test suites and other slow commands in a session that keeps its cache for an hour.

A session on the 5-minute cache that waits on a slow command, or on its own background task, saves its whole history again when it carries on. In Claude Code that is usually the main session rather than a sub-agent; sessions run through the SDK may use the 5-minute cache too.

Then check: After a week, the weekly "short waits" figure should fall.

Separate from the long-break fix (waits over an hour); shares sub-agent turns with the cheaper-model fix: do not add them.

4% of spend at most · Trimloop pattern P02

Or: Tell Claude not to give sub-agents work that waits on slow commands.

Add to CLAUDE.md: "Run slow builds and test suites yourself, in the background if they take minutes; don't hand them to a sub-agent."

Use Opus 5.5 for routine main-session work

334 main-session turns ran on Fable 5.1. The same turns on Opus 5.5 would have cost less; whether it does the work as well is not known from the logs.

up to $79 · mostly Fable 5.1

Start sessions on Opus 5.5 and switch to Fable 5.1 for the hardest problems.

Choose the model with /model at the start of a task, or set "model" in .claude/settings.json.

Then check: Untested for quality: after a week, compare turns per task and tool errors with before, and switch back if they rose.

May share turns at the highest effort with the effort fix: do not add them.

3% of spend at most · Trimloop pattern P13

Read only the lines you need

Output from viewing files stayed in the session and was sent again on every later turn: keeping it there cost $207. Results over 2,000 tokens account for the saving.

up to $61 · mostly Read, sed -n, cat

Read only the lines needed, and don't re-read a file that hasn't changed.

Add to CLAUDE.md: "View files with the Read tool, using offset and limit for long files; don't use cat, sed -n, head or tail to view files. Don't re-read a file you have already read unless it has changed."

2% of spend at most · Trimloop pattern P04

Or: Stop whole-file views through the shell.

Add a PreToolUse hook on Bash that blocks cat, sed -n, head and tail on files, with the reason "use Read with offset and limit".

Or: Survey many files in a sub-agent, which returns only a summary.

Add to CLAUDE.md: "To explore code across many files, use a sub-agent and bring back only file:line references and conclusions."

Turn off skills and plugins you don't use

Claude Code lists every available skill near the start of each session, and the list stays in the session; MCP servers that plugins bring send their tool definitions with each request: $54. Each plugin you install adds to both.

up to $54 · mostly skill_listing, plugin:terraform:terraform (instructions), mcp__plugin_terraform_terraform

Disable plugins and remove skills you don't use.

Run /plugin to disable plugins you don't use, and delete unused skills from ~/.claude/skills and the project's .claude/skills.

2% of spend at most · Trimloop pattern P07

Save the highest effort for hard problems

1,689 turns ran at the highest effort levels (xhigh or max); most turns ran at medium. Had 1,689 of them thought as much per turn, on average, as the same model's high-effort turns, they would have cost $42 less. Harder work gets higher effort on purpose, so a lower level would save less than this.

up to $42

Use xhigh and max effort only for hard problems, and come back to medium after.

The xhigh and max turns ran on Opus 5.5 and Fable 5.1. Effort can be set per model ("modelSettings" in ~/.claude/settings.json): if it is, lower it there. Otherwise keep the default at medium with /effort medium (or "effortLevel" in .claude/settings.json), and raise it with /effort for a task that needs it.

Then check: Untested for quality: after a week, compare turns per task and tool errors with before.

May share turns with the cheaper-model fixes: do not add them.

2% of spend at most · Trimloop pattern P14

Move to the newer model

400 main-session turns ran on Opus 5 and Sonnet 5. Each has a newer version that costs less per token and counts tokens the same way.

up to $29 · mostly Opus 5, Sonnet 5

Switch main sessions from Opus 5 to Opus 5.5 and from Sonnet 5 to Sonnet 5.5.

Choose the model with /model, or set "model" in .claude/settings.json.

Then check: Prompts tuned for the older model may need adjusting: compare turns per task for a week after switching.

1% of spend at most · Trimloop pattern P13

Use the terminal app when you don't need the desktop app's tools

The desktop app adds its own MCP servers, whose tool definitions are sent with every request. Some were never used in this period (claude-artifacts, Claude_Code_iOS_Simulator, ccd_session), and still cost $17.

up to $17 · mostly claude-artifacts, Claude_Code_iOS_Simulator, ccd_session

For work that doesn't need them, run Claude Code in a terminal (claude), which doesn't load them.

These servers come with the desktop app, so /mcp and claude mcp remove do not list them. Sessions started from the terminal leave them out.

Then check: After a week, the cost of these tool definitions should fall.

1% of spend at most · Trimloop pattern P06

Pick the model when a session starts

4 times, in 4 sessions, a session moved to another model part-way through. The saved copy of the conversation (the cache) belongs to one model, so the first turn on the new one paid to save the whole conversation again.

up to $11

Choose the model when you start a session, and keep it.

Use /model at the start. To change model mid-way, run /compact first, so there is less to save again; or start a new session with a short note of where things stand.

Then check: After a week, the model-switch figure should fall.

0% of spend at most · Trimloop pattern P01

Trim memory files

Memory files such as CLAUDE.md are added to every session and stay there: $7.

up to $6.97 · mostly Project CLAUDE.md, User CLAUDE.md, AutoMem MEMORY.md

Keep memory files short; move instructions needed only sometimes into a skill.

Trim CLAUDE.md to what every session needs. Put task-specific instructions in a skill (.claude/skills/<name>/SKILL.md), which loads only when it is used.

0% of spend at most · Trimloop pattern P07

Keep long command output short

Other command output stayed in the session and was sent again on every later turn: keeping it there cost $47. Results over 2,000 tokens account for the saving.

up to $6.27 · mostly cat, awk, Artifact

Keep long command output short.

Add to CLAUDE.md: "Pipe long command output through tail -n 80 or a filter; don't print what you won't use."

0% of spend at most · Trimloop pattern P04

Or: Limit how much shell output reaches the model.

Set BASH_MAX_OUTPUT_LENGTH (characters) in the "env" section of .claude/settings.json. Claude Code cuts the middle of longer output, so the end, with errors and summaries, stays.

Trim MCP tool results

Output from MCP tools stayed in the session and was sent again on every later turn: keeping it there cost $10. Results over 2,000 tokens account for the saving.

up to $4.46 · mostly mcp__Claude_Browser, mcp__visualize, mcp__plugin_terraform_terraform

Make MCP servers return less, and remove ones the project doesn't use.

Remove unused servers with claude mcp remove <name>; for the rest, use their options for summaries, fewer fields or paged results.

0% of spend at most · Trimloop pattern P04

Or: Limit the size of MCP results.

Set MAX_MCP_OUTPUT_TOKENS in the "env" section of .claude/settings.json (default 25,000).

Or: Call noisy MCP tools from a sub-agent.

Add to CLAUDE.md: "Use a sub-agent for MCP tools that return large results, and bring back only what's needed."

Keep the computer awake while Claude works

57 times the computer went to sleep while Claude was replying, in sessions of about 259,849 tokens. Each reply was cut off and the request sent again; the cut-off part is not in the logs, so the saving counts only the conversation read again. After a long sleep the cache has often expired too, and the next turn saves the whole conversation again; the long-break card counts that, so it is not added here.

up to $4.03

Keep the computer awake during long tasks.

In the Claude desktop app, turn on keeping the computer awake while Claude works. In a terminal on macOS, run caffeinate -i alongside, or start Claude Code with caffeinate -i claude.

Then check: After a week, the count of replies cut off by sleep should fall.

0% of spend at most · Trimloop pattern P12

Remove MCP servers you don't use

Every connected MCP server sends its tool definitions with each request and adds its instructions to the session: $4.

up to $3.98 · mostly claude.ai Claude Docs, an unnamed connector

Remove MCP servers this project doesn't use.

claude mcp remove <name> for a server you added, or turn it off for this project in /mcp; a server named by a long id is a connector, turned off in Claude's connector settings.

0% of spend at most · Trimloop pattern P07

Or: Limit what each MCP result can add.

Set MAX_MCP_OUTPUT_TOKENS in the "env" section of .claude/settings.json.

Filter data before printing it

Data printed by scripts, APIs and diffs stayed in the session and was sent again on every later turn: keeping it there cost $41. Results over 2,000 tokens account for the saving.

up to $3.44 · mostly python3 inline, python3 script, git diff

Filter data before printing it.

Add to CLAUDE.md: "Don't print whole data structures, API responses or diffs. Select fields (jq, gh --jq), limit rows, print counts or summaries; use git diff --stat before diffing files."

0% of spend at most · Trimloop pattern P04

Or: Ask the source for less.

Use the tools' own filters: gh api --jq, kubectl -o name or -o jsonpath, SQL with LIMIT and only the needed columns.

Or: Explore data in a sub-agent, which reports only the answer.

Add to CLAUDE.md: "When exploring data or logs, use a sub-agent and bring back only the findings."

Where the money went

medlar was the costliest project, at $668 (27%). The largest part of the spend (44%) paid for re-reading the session from the cache, Claude's cheaper saved copy of it.

Show details

What the money paid for

Re-reading from the cache $1,080 (44%) Saving to the cache, kept 1 hour $594 (24%) Saving to the cache, kept 5 minutes $331 (13%) Claude's replies $459 (19%) New input sent without the cache $0.28 (0%)

By project

Bar length is spend; the light part was spent by sub-agents.

Project	Spent	Share	Sessions	By sub-agents
medlar	$668	27.1%	204	49%
willow	$581	23.6%	13	25%
yarrow	$490	19.9%	1	12%
stork	$268	10.9%	5	5%
poplar	$122	4.9%	8	47%
tern	$89	3.6%	9	31%
elm	$66	2.7%	6	0%
ash	$51	2.1%	8	43%
sycamore	$19	0.8%	1	0%
oak	$17	0.7%	8	0%

By skill, plugin and MCP server

Claude Code names a skill, plugin or MCP server (a connected tool provider) on some turns. The cost is those turns' cost, which can include work that followed the tool.

Skill

Name	Spent	Share	Turns	Sessions
checked-plans:spec	$40	1.6%	95	1
code-review	$13	0.5%	121	2
checked-plans:cold-review	$8.80	0.4%	14	1
newsletter:newsletter-ai	$7.96	0.3%	157	2
claude-api	$7.93	0.3%	102	2
checked-plans:implement	$4.22	0.2%	21	1
simplify	$2.84	0.1%	51	1
checked-plans:research	$2.39	0.1%	24	3
spec	$1.91	0.1%	14	1
anthropic-skills:docs	$1.08	0.0%	23	2

Plugin

Name	Spent	Share	Turns	Sessions
checked-plans	$56	2.3%	154	4
newsletter	$7.96	0.3%	157	2
anthropic-skills	$1.96	0.1%	30	3

MCP server

Name	Spent	Share	Turns	Sessions
Claude app: task list and wrap-up	$109	4.4%	802	7
Claude Browser	$15	0.6%	103	4
visualize	$1.09	0.0%	4	1
terraform (from plugin terraform)	$0.89	0.0%	11	2
unnamed connector	$0.88	0.0%	17	2
claude.ai Claude Docs	$0.78	0.0%	10	1
terminal	$0.21	0.0%	4	1
Claude app: folder access	$0.19	0.0%	4	3
Claude app (ccd_pr)	$0.13	0.0%	2	1

Week by week

The busiest week began 26 Oct 2026, at $773. Compare the weeks before and after a change to see whether it worked.

Show details

Week of	Spent	Turns	In large turns	By sub-agents	Tool output	Re-reads	After breaks	Compactions	Short waits	Top effort	Cheaper choice	Limit hits
21 Sep 2026	$31	250	57%	0%	$8.78	0%	$0	0	$0	$0	$28	0
28 Sep 2026	$163	1,168	68%	15%	$24	2%	$20	1	$2.67	$0	$35	0
5 Oct 2026	$595	3,654	78%	8%	$90	8%	$163	6	$2.58	$31	$0	2
12 Oct 2026	$66	595	52%	9%	$7.24	8%	$20	0	$0.49	$1.02	$2.91	0
19 Oct 2026	$84	868	45%	8%	$15	1%	$10	1	$0.33	$1.85	$6.87	0
26 Oct 2026	$773	7,313	50%	50%	$134	1%	$28	5	$93	$19	$29	0
2 Nov 2026	$532	3,706	51%	22%	$67	1%	$66	7	$1.83	$58	$108	0
9 Nov 2026 (so far)	$222	2,702	51%	33%	$32	1%	$4.86	4	$0	$0	$5.05	0

"In large turns": the week's spend sent in turns over 200k tokens. "Tool output": the cost of keeping that week's tool output in the session. "Re-reads": file views that re-read a file already seen, unchanged. "After breaks": saving the session to the cache again after breaks you took. "Short waits": what a 5-minute cache expiring after a wait of 5 minutes to an hour cost. Dashes: not measured for that week (stored by an earlier version). "Top effort": the output cost of xhigh and max turns. "Cheaper choice": main-session spend on a model with a newer, cheaper version or a cheaper tier. "Limit hits": requests Claude Code refused because a subscription usage limit was reached. "Kept": figures from earlier runs, after Claude Code deleted some or all of the week's logs. "Older method" or "older prices": worked out with an earlier analysis or price list, so they may not compare exactly.

Long sessions and breaks

The 5 costliest sessions made 60% of spend. 7 grew past 500k tokens without ever compacting ($308). Coming back after more than 1 hour cost $372 in re-saving the cache.

Show details

Costliest sessions

Session	Project	Spent	Share	Turns	Largest size (tokens)
Untitled session4 Oct 2026	yarrow	$490	19.9%	3,549	967k
Untitled session5 Nov 2026	willow	$420	17.0%	3,492	967k
Untitled session7 Oct 2026	stork	$265	10.8%	1,205	966k
Untitled session30 Oct 2026	medlar	$205	8.3%	930	736k
Untitled session26 Oct 2026	medlar	$110	4.5%	996	966k

A typical session cost $0.15.

Compaction

Compacting replaces the session with a short summary. Claude Code did it 24 times (1 when asked), typically shrinking 868k tokens to a 22k summary; with the system prompt and re-attached files, the next request sent about 92k; the longest wait was 2m7s.

Long breaks

139 times in 30 sessions, work carried on after more than 1 hour away. The cache had expired, so the next turn paid to save the whole session again: $372 (15% of spend). 30 of these waits ($60) were not breaks you could restart from: Claude was waiting on a tool, a sub-agent, a timer or another agent. The other $312 followed breaks you took.

Shorter waits

In these logs 273 main sessions and 239 sub-agents kept their cache for 5 minutes; 82 main sessions and 0 sub-agents for an hour.

83 times (81 in sub-agents) a session on the 5-minute cache waited longer, up to an hour, and saved its whole history again: $110, $101 more than with the cache still there. Putting every session on the 5-minute cache on the hour's would have cost $35 more: its writes are dearer.

Session	Waits	Largest context	Cost of the expiry
Untitled session (a sub-agent)30 Oct 2026	13	612k	$28
Untitled session (a sub-agent)30 Oct 2026	10	734k	$27
Untitled session (a sub-agent)28 Oct 2026	6	206k	$5.61
Untitled session (a sub-agent)30 Oct 2026	5	248k	$5.50
Untitled session (a sub-agent)30 Oct 2026	4	278k	$4.97

Keeping the cache for an hour cost $385 to $860 less than the 5-minute cache would have, in the sessions that used it: the hour pays for itself here. The first figure is if only waits over 10 minutes lost a 5-minute cache, the second if every wait over 5 minutes did. Neither is exact: the logged wait includes the next reply's own time, and requests the logs do not record can keep a cache alive, even past 10 minutes.

Tool output

When Claude runs a command or reads a file, the output stays in the session and is sent again on every later turn. Keeping it there cost $378 (15% of spend), and 2% of file views re-read a file already seen.

What Claude writes in its tool calls (commands, scripts, file contents) stays in the session too: $239 to carry (10% of spend), mostly Bash $137, Write $72, Edit $13. Compacting clears it as well.

Show details

By tool

Bash	$259	16,562 uses
Read	$85	1,599 uses
WebSearch	$7.30	475 uses
WebFetch	$4.42	721 uses
Artifact	$3.02	42 uses
mcp__Claude_Browser	$2.94	191 uses
Agent	$2.77	237 uses
mcp__visualize	$2.69	4 uses
Edit	$2.18	1,378 uses
Write	$2.11	835 uses

Shell commands by type

Commands are grouped with file names and values removed, so sed -n '1,50p' a.go and sed -n '9,20p' b.go are one type. "Already filtered" is the share whose output was cut down, for example with head or grep.

Command type	Cost to keep	Uses	Tokens	Already filtered
sed -n	$75	2,550	2,557,697	12%
cat	$31	1,703	1,345,351	63%
grep	$24	1,713	785,650	75%
python3 inline	$20	2,306	483,623	2%
cat -n	$16	376	1,085,487	28%
grep -A	$8.35	441	218,680	58%
grep -r	$7.15	634	278,984	92%
python3 script	$6.15	660	155,365	48%
ls	$3.72	333	173,453	33%
awk	$3.36	81	81,528	43%

What every request carries

Each request also sends Claude Code's own instructions (the system prompt), the definitions of every tool, and text Claude Code adds such as the skill list and CLAUDE.md. That cost $312 (13% of spend).

Show details

Source	Cost	Size	Who can change it
Built-in tool definitions	$123	22k tokens	Claude Code (no setting)
List of available skills	$53	7k tokens	you: skills and plugins
System prompt	$23	3k tokens	Claude Code (no setting)
MCP server Claude_Browser: tool definitions	$13	7k tokens	Claude Code (no setting)
MCP server claude-artifacts: tool definitions	$11	6k tokens	Claude Code (no setting)
Token-count reminders	$9.66	22 tokens	Claude Code (no setting)
Background-task notices and messages from other agents	$8.02	507 tokens	Claude Code (no setting)
Notes on tools loaded when needed	$7.81	559 tokens	Claude Code (no setting)
List of available sub-agents	$6.53	912 tokens	Claude Code (no setting)
Skills that were used	$5.22	5k tokens	Claude Code (no setting)
Files you attached	$5.00	902 tokens	Claude Code (no setting)
Project CLAUDE.md	$5.00	808 tokens	you: memory files

Sub-agents

Sub-agents are helpers Claude starts for side tasks. 239 runs cost $661 (27% of spend); 98% of that was on a model with a cheaper choice.

Show details

Agent type	Spent	Runs	On a cheaper model, less by	Model	Suggested
general-purpose	$644	207	$335	Opus 5.5	Sonnet 5.5
fork	$12	3	$0	Fable 5.1	—
Explore	$1.93	2	$0.96	Opus 5.5	Sonnet 5.5
Plan	$1.69	1	$0.85	Opus 5.5	Sonnet 5.5
web-fetch	$0.95	21	$0	Haiku 5.5	—
claude-code-guide	$0.44	5	$0	Haiku 4.5	—

Each run starts with an empty session, so 46% of sub-agent spend goes on saving to the cache (34% in main sessions). No cheaper model is suggested for "fork" agents: they continue the main session and reuse its cache.

Models and effort

Main sessions ran on 4 models. Moving to the newer version where there is one would have cost $29 less. Routine work one tier down would have cost up to $79 less, quality untested.

Show details

Main sessions by model

Model	Spent	Turns	Newer version	Less by	Tier down	Less by
Opus 5.5	$1,590	11,505	—		—
Fable 5.1	$143	334	—		Opus 5.5	$79
Opus 5	$63	245	Opus 5.5	$27	—
Sonnet 5	$7.96	157	Sonnet 5.5	$2.45	—

Effort level

Level	Turns	Spent	Output cost	Thinking a turn
not logged	23	$0.38	$0.03	330
low	1	$0.13	$0.03	57
medium	12,467	$1,334	$236	387
high	6,051	$687	$113	347
xhigh	374	$131	$60	1,523
max	1,315	$313	$50	1,205

Thinking was $188 of $459 output spend (41%), at every level.

Levels mix models, and each model thinks a different amount, so the saving compares each model's xhigh and max turns with its own high-effort turns: $42 less had they done the same on average. Harder work gets higher effort on purpose, so a lower level would save less.

Interruptions and switches

Model switches: 4 times a session moved to another model part-way through, so its first turn on the new model saved the whole conversation again: $11 more than reading it.
Replies cut off: 57 when the computer slept, 2 by the network, 0 other. Each was sent again, at least $4.10 in all; the cut-off part of the reply is not in the logs.
Desktop-app tools never used: claude-artifacts ($11), Claude_Code_iOS_Simulator ($3.48), ccd_session ($2.45). The desktop app adds these servers; the terminal app does not load them.

When you work

26% of spend was at weekends; at most 5 main sessions ran at once. Local time.

Mon	$554
Tue	$198
Wed	$343
Thu	$253
Fri	$484
Sat	$150
Sun	$483

Checking the totals

Claude Code's own records show $221 (11%) more than its logs: requests the logs don't record, such as session titles, summaries after a break, compactions and web searches. 6 sessions (14% of spend) have no record to check against.

Show details

For 346 sessions with a record, Claude Code recorded $2,213 and the logs show $1,992. 308 web searches cost about $3.08 in search fees. 3 sessions have a record that does not cover all of them (they began before the record's first run, or went on after its last) and are left out.

Model	Claude Code's record	In the logs	Difference
Opus 5.5	$1,959	$1,791	$169
Fable 5.1	$247	$200	$47
Haiku 5.5	$5.62	$1.01	$4.61
Haiku 4.5	$1.38	$0.38	$1.00

Words used in this report

Show the words

Token: The unit Claude is paid by: a word-piece of about four characters.
Turn: One request to Claude and its reply. One prompt from you can take many turns while Claude works.
Session: One Claude Code conversation, with any sub-agents it started. Every turn sends the whole session so far.
Session size: How many tokens a turn sends: everything said so far, including tool output.
Cache: A saved copy of the session that Claude can re-read cheaply. It expires after 5 minutes or 1 hour without use.
Effort level: How hard Claude is asked to think before answering: low, medium, high, xhigh or max. Higher levels write more output, which costs more, and suit hard problems.
Compact: Replace the session with a short summary (/compact in Claude Code).
Sub-agent: A helper Claude starts for a side task; only its final report returns to the main session.
MCP server: A connected tool provider, such as a browser or an issue tracker.
System prompt: Claude Code's own instructions to Claude, sent at the start of every request.
Memory file: A file such as CLAUDE.md whose instructions are added to every session.
Likely, up to: "Likely" is an estimate for one change; "up to" is the most it could save.