Coding Usage

Coding Usage aggregates every local Claude Code, Codex and OpenCode session on your machines into one API-equivalent cost view. Across sessions it totals ( authoritative, OpenCode, estimated), spanning . On a flat subscription you do not actually pay these amounts — the figure answers “what would this have cost on the API”, exactly like Claude Code's own /usage.

Two kinds of cost

Authoritative — for Claude sessions you have opened, the cost is Claude Code's own /usage figure. The status line records it per session to ~/.claude/usage-ledger.json and the report uses it verbatim (no estimation).

OpenCode — OpenCode stores aggregate tokens and a session cost in ~/.local/share/opencode/opencode.db. The report uses that cost when present and still shows the tokens/model even when the OpenCode provider is free. OpenCode subagent rows with session.parent_id are folded into the root user-started session.

Estimated (shown with a leading ~) — older Claude sessions and all Codex sessions have no ledger entry, so their cost is tokens × API list price. Only sessions opened after the status line was configured have an authoritative entry; that is why most rows are estimates. For Codex the token counts are exact (the CLI records cumulative usage), so only the dollar figure is an estimate — Codex never writes a billed cost, so there is nothing authoritative to prefer. That is why Codex stays in the estimated bucket even though its tokens are precise.

Per-model breakdown vs. session total

The Cost column is the whole-session total. Expand a row to see every model it used, most expensive first, with that model's tokens and an estimated API-equivalent cost. The Cost by model and Tokens & cost by model charts also use those token-based model estimates so free or flat-plan provider rows still show which model consumed the value. Whole-session totals, Cost by day and Cost by month keep using the best available session total: Claude /usage, OpenCode's stored session cost, or fallback estimate. When the session total is authoritative, per-model estimates will not sum to exactly the same number. That is expected: one is the session's recorded cost, the other is a token-based model allocation. It is not a double count. The Cost by model chart is sorted by cost so the biggest spender is on top; the High → low / Low → high toggle flips the direction, and clicking any bar hides that model (useful when a near-zero model just adds a row) — hidden models collect under the chart where Show all or a single chip restores them. Cost by project aggregates the same best-available session costs by project attribution instead of by model; clicking a bar sets the Project filter to that project, and clicking the active bar again clears it. At most 14 projects are shown, sorted by cost; any remainder collapses into a single non-clickable +N more row.

Models and the <synthetic> marker

Each session lists all models it used. Claude Code subagent and sidechain transcripts from <session-id>/subagents/*.jsonl are folded into the parent session, so a mostly Opus row can also show Sonnet or Haiku when Claude delegated work. Claude Code's internal <synthetic> entries (locally-generated messages such as interrupts and error notices) carry no tokens and no API call, so they are filtered out — they are not a real model.

Codex subagents

When a Codex session spawns a subagent, Codex writes the subagent as its own rollout transcript that shares the parent's thread id but carries its own session_id and a non-empty parent_thread_id. The report folds every such child into the session that started the thread, so a task that delegated to three subagents shows as one row, not four. Expand it to see each subagent listed separately with its own model and tokens; the folded subagents chip counts how many were merged. The session total already includes them, so the headline cost is unchanged.

Codex auto-review sessions

codex-auto-review entries are automatic reviewer-agent transcripts that Codex writes when Auto-review evaluates approval requests. They are read-only model calls, not coding sessions you manually started. Like subagents they are linked by parent_thread_id, so the report folds the auto-review under the matching Codex session instead of showing it as a separate top-level row. Use the Model filter to find sessions that include them.

OpenCode subagents

OpenCode stores @explore and other subagents as separate SQLite session rows. Those rows carry parent_id, so the importer folds the root session and all descendants into one OpenCode row. Continuing the root session later keeps updating the same row.

Filters and saved view

The filter panel is collapsed by default so the charts stay visible first, especially on mobile. Next to the Filters toggle sit always-visible date presets — 7d, 30d, This month and All — that set the usage date range in one click; the active preset is highlighted, and a custom calendar range highlights none of them. Reset filters sits next to them so it is reachable without expanding the panel, and is disabled when nothing is filtered. Rows per page lives in the pager and Expand all next to the Sessions table, where they apply. For a precise range the filter panel has an inline two-month calendar: click a start day, then an end day (either order) to set Usage between; Clear dates removes it. Cost by day is a scrollable, newest-first panel (no longer a collapsed section), so recent days are visible immediately and older days scroll into view.

The Sessions table also carries an in-column filter row right under the headers: the Project, Device, Agent, Surface and Models dropdowns filter without scrolling back up to the panel, and stay in sync with it (changing one updates the other). The Local time / UTC toggle next to Expand all switches the Started and Last activity columns between your browser's local time zone (default) and the raw stored UTC value; all timestamps are stored as UTC.

The report stores your selected filters, filter-panel state, sort order, page size, expanded state, and active tab in this browser's localStorage, so refreshing the file keeps your view.

Tokens & cost by model

This chart breaks each model's usage into input (fresh, uncached), output (generated, including reasoning tokens), cache read and cache write, and gives you three controls so you can read it the way that answers your question:

• Tokens / Cost — bar length is either the raw token count or the estimated USD (tokens × API list price). Cost view matters because a cache-read token is ~10× cheaper than input and ~250× cheaper than output, so by sheer volume cache reads dominate the token view yet are a small slice of the money — Cost view rebalances the bars toward where you actually spend.
• Composition / Absolute — Composition fills every bar to 100% so you compare the category mix regardless of size; Absolute scales bars against the largest model so you compare totals.
• Category legend — click Input, Output, Cache read or Cache write to include or exclude it. The bars, the per-model value and the summary line all recompute, so e.g. excluding both cache categories in Cost view shows what input+output alone would cost.

Hover any segment for its exact value and share. Codex exposes no cache-write tokens (that segment is always empty for Codex), and Codex models with no configured rate drop out of the Cost view. These controls only reshape this chart — the headline cost figures (chips, Cost by day/month, the Sessions table) stay the best available whole-session totals. The chart respects the active filters, exactly like the cost charts.

Daily attribution

The session totals stay cumulative, but the timeline uses committed data/<host>.json snapshots to derive positive deltas. If a hook commit grows a session from one token total to a larger one, only that growth is attributed to the commit's day. That avoids putting a long-running session's full cost on its start date. A session's first appearance is attributed to its own timestamp, and snapshots before this timeline feature existed are treated as legacy baseline; otherwise historical sessions imported during repository bootstrap would all land on the bootstrap commit day. Cost-only changes without token growth are ignored as timeline events because they are pricing/parser corrections, not new usage.

Caching

Anthropic bills a cache-write premium (5-minute TTL 1.25×, 1-hour 2×) and cheap cache reads (0.1×). OpenAI has no write surcharge — only a cached-input discount — so Codex cache writes are not charged.

Where the data comes from

Each app writes transcripts to its own home directory, so WSL and Windows are separate locations:

CLI vs Desktop is not a different folder — it is recorded inside each transcript and shown in the Surface column. Cloud / container sessions (Codex Cloud tasks, Claude Code on the web) run server-side and leave no local transcript, so they cannot be measured here.

Multiple devices & privacy

Each machine writes a committed data/<host>.json; this site is rebuilt from those files, and the Device filter narrows totals to one machine. The data holds project names, dates and costs — no secrets — but keep the repo private if that matters.

For this host, the previous data/<host>.json is imported before scanning local transcripts. Normal hook runs only add or grow known sessions: an archived, missing, or briefly smaller transcript does not remove already exported history.

API list prices per 1M tokens for every model with a configured rate. Rows flagged used appear in at least one session; the rest are reference prices for comparison. Cache write is the 5-minute write rate (Claude/OpenCode); OpenAI bills no write surcharge, so its column is —. Rates are the same ones the cost engine uses — edit pricing.py to add or update a model.

* “1M each” = input + output + cache read + cache write for one million tokens of each category, a quick rough-cost comparison. Sort by clicking any column header.