Statement

Every assistant turn in the window, priced from its own model and its own token counters. Two figures, because they answer different questions.

loading Reading the dataset.

Cache lab

Almost all of the token volume here is cache traffic, so almost all of the bill is decided by cache pricing. A read costs a tenth of fresh input; a one-hour write costs double it.

Repo scanner

What a codebase costs to put in front of a model. Run releve-repo.py and drop the result here, or pick a folder and count it in the browser. Both count characters and divide by a per-language factor measured from real transcripts, which lands within about 20% of a whole response; --tokenizer api counts exactly.

curl -O https://releve.neorgon.com/scripts/releve-repo.py
curl -O https://releve.neorgon.com/scripts/releve_cost.py
curl -O https://releve.neorgon.com/data/tokenizer.json
python3 releve-repo.py . --out releve-repo.json

Drop releve-repo.json here or · Nothing is uploaded. Both paths read the file locally.

Projector

What the next stretch of work costs, from the per-turn medians measured in the loaded dataset rather than a guess. The sensitivity ranking says which lever actually moves the number.

Iterations 20

Turns per iteration 40

Cache hit ratio 97.5%

Share of writes at the 1-hour TTL 67%

Cache multipliers

Cache rates are derived from base input, never typed per model, so correcting a base rate can never leave a stale cache rate behind.

Service tiers

A tier scales every rate. A tier whose pricing is not a flat multiple of standard is priced at standard and counted as an assumption, not guessed at.

Method

How each number is derived, what it excludes, and where to check it.

The six rules

Resolve rates per turn, from that turn's own message.model. A session that switched models mid-way is priced by turn, not by whichever model happened to be last in the file.
Never substitute a different model's rates. Exact id, then the longest declared prefix or suffix, then unpriced. An unpriced model is named and counted, never folded into a total and never treated as free.
Split the cache writes. Five-minute writes bill at 1.25× base input, one-hour writes at 2×. A turn carrying only the flat counter is assumed five-minute and flagged.
Honour usage.speed. Fast mode on Opus bills double, so a fast session must not be priced as standard.
A non-empty usage.iterations replaces the top-level counters, and is never added to them. Adding them double-counts; ignoring the array under-reports every multi-iteration turn.
Count each response once, keyed on message.id rather than on the entry's uuid. A response is written to the transcript one entry per content block, and every one of those entries repeats the same usage object: a turn that thought, spoke and called a tool appears three times and is billed once. On the author's machine 116,402 entries are 52,078 responses, and the per-uuid reading reports 30.0B cache-read tokens against a true 12.9B. Resuming a session replays its history into a new transcript on top of that, and the replay is sometimes the more complete record, so the copy with the most billable tokens wins.

What this dataset says about itself

Limits, stated

Run it yourself

Python 3, standard library only, no network calls unless you ask for them. Each script prints the date of the rates it used.

The file format

Every file a script writes carries its own schema string, and data/schema.json documents all six of them field by field: what a scan writes, what the repo counter writes, the fitted tokenizer table, the rate card, the pricing fixture, and the export this page produces. The two the site reads back are closed contracts, so a field added to a scanner and not to the schema fails make schema rather than turning up as a quietly wrong number here.

Releve