A $240 monthly AI setup, through the lens of ccusage

An investigation of recorded Claude Code, Codex and OpenCode activity: which models carried the work, where the estimated API cost went, and how it compares with the monthly plans.

By the Maborak engineering team · 2026-10-30 · 10 min read

The monthly setup was straightforward: $200 for Claude, $20 for Codex access and $20 allocated to OpenRouter. What was harder to see was the activity behind those payments, spread across Claude Code, Codex and OpenCode. Reading their local histories with ccusage put numbers beside the setup: 28 dates with recorded usage, a broad model mix in OpenCode, and $7,475.92 in reported token costs for 1–29 October.

Checked 30 October 2026. Activity and cost figures below were collected locally with ccusage 20.0.41 and are labelled [reproduced]. The monthly amounts were supplied by the operator and are labelled [reported]; receipts and provider billing dashboards were not inspected. Vendor explanations are labelled [vendor].

The setup before the numbers

The starting point was a monthly allocation, not a single-provider workflow:

[reported] OpenRouter is different from the two subscriptions. Its documentation describes credits as deposits, with request costs deducted from the balance. A monthly $20 allocation does not necessarily mean $20 was consumed during that month. [vendor]

There is another distinction in the setup: OpenCode is a client, not a model provider. Its model references identify both a provider and a model. Switching models inside it can therefore cross billing routes. [vendor] That makes the client useful for comparing models, but its entire usage total cannot automatically be assigned to the OpenRouter budget.

Bringing the activity into one view

ccusage aggregates local agent histories. Its combined reports can include every supported source detected on the machine, while focused commands isolate one client. [vendor] The investigation used 1–29 October 2026 inclusive, in UTC, excluding the unfinished current day.

The commands that exposed the different views were:

bunx --no-install ccusage --version
bunx --no-install ccusage daily --since 20261001 --until 20261029 --timezone UTC
bunx --no-install ccusage weekly --since 20261001 --until 20261029 --timezone UTC
bunx --no-install ccusage opencode monthly --since 20261001 --until 20261029 --timezone UTC

The installed version was 20.0.41, run with Bun 1.4.4 on macOS arm64. --no-install used the existing cached executable. For the aggregate analysis, one JSON export collected the daily, weekly and monthly views together:

bunx --no-install ccusage daily \
  --since 20261001 --until 20261029 --timezone UTC \
  --sections weekly,monthly --by-agent --json > activity.json

That command creates a local report file. The analysis counted each client’s distinct UTC dates with positive recorded token usage, collected model identifiers and summed cost fields. Daily, weekly and monthly token totals agreed. [reproduced] No private session titles or prompts are needed to show the result.

OpenCode appeared most often; Claude carried most of the estimated cost

[reproduced] The combined cost is rounded after summing; the independently rounded rows add to one cent more. An activity date means recorded token usage, not a full workday. Several clients can appear on the same date.

The two rankings differ. OpenCode had the most activity dates and model identifiers, but Claude Code contributed 97.1% of ccusage’s combined cost. The number of days a tool appeared did not explain the size of its estimated cost.

The daily view made that concentration more concrete. 14 October was the largest estimated-cost date at $2,350.31, with $2,350.22 attributed to Claude Code. The week of 12–18 October also had the largest processed-token total. [reproduced] Those dates identify where the recorded activity was concentrated; the aggregate reports do not explain which task caused it.

The daily chart covers every date in the interval, including 15 October, when the export has no records. That is shown as a gap, not confirmed zero activity. Very small dollar values can disappear at this scale; the daily CSV preserves the exact reported values.

The model mix behind the totals

The following tables include every model identifier in each client’s report, rather than only the largest entries. Output tokens show generated volume; the cost columns also include recorded input and cache usage. Names are reproduced as recorded, without merging aliases or speed variants.

Claude Code: five identifiers, mostly Opus

Claude Code’s five model identifiers were not used equally:

[reproduced] The dollar amounts include recorded input and cache usage as well as output; they are not calculated from the output column alone. Opus 5.5 accounted for 94.4% of Claude Code’s 22,415,116 output tokens. The history shows a workload dominated by one model rather than an even split across five.

Codex: four identifiers, mostly Astra by estimated cost

[reproduced] Astra entries contributed $107.77 of the $110.11 estimate. The smaller models appear in the history, but their estimated cost was a small part of Codex’s total.

OpenCode: thirteen identifiers across several model families

[reproduced] The two unknown rows carry missingPricing: true. Their zero values are not evidence that inference was free. Positive values for identifiers labelled free are also retained exactly as reported, rather than presented as verified provider charges.

OpenCode had the broadest mix: Claude, GPT, DeepSeek, GLM and other identifiers. Its largest output count was 2,107,669 tokens under deepseek-v4.1-flash-free. [reproduced] Identifier counts need some care: aliases and speed variants can have separate names without being separate model families.

The model CSV contains all 22 client/model rows, including unrounded costs, the stored-cost portion and missing-pricing flags. A model used in two clients has two rows; 22 is not a count of unique model families.

The practical discovery was that the tools served different recorded patterns. OpenCode appeared across more dates and more identifiers. Claude Code’s output was heavily concentrated in Opus. Codex appeared on fewer dates, with most of its estimated cost concentrated in Astra. The reports show those patterns without requiring guesses based on which tool felt busiest.

Cache reuse explains the huge token counts

Claude Code’s 25,945,739,471 recorded tokens initially look difficult to reconcile with a single workstation. The categories explain the scale:

[reproduced] Cache reads made up 98.6% of recorded input, using cache reads divided by the sum of uncached input, cache creation and cache reads. This is a token-weighted ratio, not the percentage of requests that hit the cache.

Anthropic documents that coding sessions repeatedly send conversation context and can reuse cached prefixes. Cached input has its own price. [vendor] The total therefore includes the same context being processed repeatedly; it is not a count of unique code or newly generated text. The cache breakdown made the monthly activity far easier to interpret than the total token number alone.

Putting the plan fees beside the API estimates

The clearest contrast is Claude: a stated $200 monthly subscription beside $7,258.73 calculated from Claude Code’s recorded tokens during the sample. The latter is about 36.3 times the plan fee. That is a ratio between two dollar figures, not a claim about the plan’s quota or verified savings.

Codex showed the same direction at a smaller scale: $110.11 in ccusage costs beside the stated $20 subscription allocation. OpenAI’s pricing documentation distinguishes subscription usage from API-key billing; Anthropic likewise says the session dollar estimate does not represent billing for included Pro and Max usage. [vendor]

The OpenCode figure needs a different reading. Its $107.09 combined approximately $62.07 of stored cost values with $45.01 calculated by ccusage, rounded separately. Two identifiers had missing pricing. The report even assigned $22.91 to the identifier ending in flash-free. [reproduced] That is an unresolved pricing-mapping question, not evidence of a charge for a free endpoint.

The comparison explains why a subscription can be attractive for a workload with this much recorded usage. [inferred] It does not establish a precise alternative API bill: the window is a partial calendar month, the cost methods are mixed, and the audit did not map every request to its payment route. Subscription limits, extra usage, taxes and unused credits also sit outside this comparison.

What the investigation revealed

The $240 allocation described access and budget. ccusage supplied the missing view of activity: which clients appeared across the month, which models dominated the recorded output, and how much repeated context sat behind the token totals.

For this sample, Claude Code dominated the estimated cost, OpenCode exposed the widest model mix, and cache reads accounted for nearly all recorded Claude input. The difference between the subscription amounts and token-cost estimates was substantial, but the more useful result was being able to explain that difference with the workload’s actual composition.

This is a local-history investigation. Other devices, browser conversations and missing records can change the picture. The numbers describe the captured activity, not hours worked or developer productivity; they make the setup visible enough to discuss plan value with evidence rather than memory.

The three charts and both CSV files use the same captured interval. The exports contain aggregate dates, model identifiers, token counts and cost fields only; they omit prompts, session identifiers, project paths and credentials. [reproduced]

Sources

• Primary local evidence: ccusage 20.0.41, collected 30 October 2026 for 1–29 October 2026 UTC, with daily, weekly and monthly views and per-client model breakdowns. Raw session content is not published.
• ccusage introduction, combined reports, supported local sources and estimate limitations; checked 30 October 2026.
• ccusage JSON output, --sections, --by-agent, stored costs and missing-pricing fields; checked 30 October 2026.
• ccusage cost modes, token calculations versus stored cost values; checked 30 October 2026.
• Anthropic: Manage costs effectively, repeated context, caching and subscription cost estimates; checked 30 October 2026.
• Anthropic API pricing, separate input, output and cache rates; checked 30 October 2026.
• OpenAI: Codex pricing, subscription access, usage limits and separate API billing; checked 30 October 2026.
• OpenCode V2: Models, provider/model references and model selection; checked 30 October 2026.
• OpenRouter FAQ, credit deposits, request deductions and Activity; checked 30 October 2026.

Topics: ai-agents, observability, cost