Methodology
How Token Barometer sources, prioritises, confidence-scores and normalises LLM API prices, and how its cloud-vs-local calculator works. See About for the licence; the source list is generated below.
Sources
Current prices are collected daily by a scheduled Workflow from four kinds of source: official vendor pricing pages (parsed with cheerio, one parser per vendor, anchored on stable headings and column names rather than row position), the OpenRouter API (one price per host serving a model), community JSON price lists (BerriAI's LiteLLM price list, models.dev), and a Haiku-class LLM fallback used only when a page's structure changes and the deterministic parser breaks or returns zero prices. Prices from before tracking started come from a separate one-time backfill, described at the end of this section.
Every source has a priority (lower number wins on conflict), a kind (api, json, html, backfill or manual) and is enabled or disabled independently. A handful of official pages are disabled because they render their pricing table client-side with no server-rendered fallback, or point at a page with no extractable structured price at the time they were checked (listed under Limitations below); those vendors' prices still reach this site through the JSON aggregators, badged aggregator rather than official.
The table below is generated from the source table in the database (the same data as the sources field of /api/v1/meta): one row per source, enabled or not, with its latest run. A source that is registered but disabled or not implemented is listed as disabled and contributes no prices. A source disabled for cause shows the reason in the enabled column, and its earlier values no longer count toward canonical prices or conflicts.
Historical prices before this project started tracking a vendor come from a one-time backfill that walks that source's own git history (LiteLLM's price file, models.dev's per-model data files) and parses each past revision with the same parser used for live data, then attaches the result to whichever offering a live refresh has already discovered. A backfill never invents a model, host or offering.
| slug | kind | priority | enabled | last run | last status |
|---|---|---|---|---|---|
| official-alibaba | html | 1 | no | never | none |
| official-anthropic | html | 1 | yes | 2026-11-19T05:12:24.689Z | ok |
| official-cerebras | html | 1 | no | never | none |
| official-cohere | html | 1 | yes | 2026-11-19T05:12:32.032Z | unchanged |
| official-deepinfra | html | 1 | yes | 2026-11-19T05:12:34.670Z | ok |
| official-deepseek | html | 1 | yes | 2026-11-19T05:12:28.602Z | ok |
| official-fireworks | html | 1 | no: no structured per-model pricing; the page parser matched the wrong table and produced wrong prices (2026-10-06) | 2026-10-06T15:28:08.307Z | ok |
| official-google | html | 1 | yes | 2026-11-19T05:12:27.174Z | ok |
| official-groq | html | 1 | no | never | none |
| official-minimax | html | 1 | no | never | none |
| official-mistral | html | 1 | no | never | none |
| official-moonshot | html | 1 | no | never | none |
| official-openai | html | 1 | yes | 2026-11-19T05:12:25.947Z | parse_error |
| official-together | html | 1 | yes | 2026-11-19T05:12:32.607Z | ok |
| official-xai | html | 1 | yes | 2026-11-19T05:12:30.083Z | ok |
| official-zhipu | html | 1 | yes | 2026-11-19T05:12:36.702Z | ok |
| openrouter | api | 2 | yes | 2026-11-19T05:12:08.445Z | ok |
| litellm | json | 3 | yes | 2026-11-19T05:12:13.020Z | ok |
| modelsdev | json | 4 | yes | 2026-11-19T05:12:20.010Z | ok |
| helicone | json | 5 | no | never | none |
| backfill-litellm | backfill | 9 | no | 2026-10-04T09:55:30.728Z | ok |
| backfill-modelsdev | backfill | 9 | no | never | none |
Priority and confidence
Each offering (a model as served by one host, in one quantisation/variant, optionally one region) can be priced by more than one source at once, for example both the vendor's own pricing page and an aggregator. Sources are tried in this priority order, lower number wins when two disagree: official-* vendor pricing pages (1), openrouter (2), litellm (3), modelsdev (4), the one-time git-history backfill (9). The canonical price shown everywhere on this site is the open price (still in effect, not superseded by a later one) from the highest-priority source that currently has one for that offering, among sources whose last successful run finished within the last 14 days.
Every price carries one of four confidence badges, shown next to it in every table: official (parsed from the vendor's own pricing page, an official-* source), api (the OpenRouter API, per host), aggregator (a community price list: LiteLLM or models.dev) and unreviewed (extracted by the LLM fallback from unstructured page text). The badge is derived from the stored price record and its source, not a separate estimate. The stored confidence level maps from the badge as follows: official and api are high, aggregator is medium, unreviewed is low. Official and api share the high level because both read a price the host itself publishes (its pricing page, or the price it reports to OpenRouter), so what separates them is source priority: when both price the same offering, the official page (priority 1) is the canonical price, not OpenRouter (priority 2), and a gap over 1% is also flagged as a conflict (below). An unreviewed price is never applied as canonical automatically; it lands in the review queue first and becomes canonical once a human approves it.
When two sources that are not unreviewed disagree by more than 100 basis points (1%) on the same offering's input or output price, the higher-priority source's price stays canonical and only the lower-priority claim is flagged as a conflict: it is never applied over the higher-priority one and is shown as a "conflict" event in /changes (marked noindex there, since it is a data-quality flag, not a price change). A conflict closes itself when the sources converge to within 1%, when the lower-priority source is an aggregator that lags the higher-priority price (resolution aggregator_lag), or when it has stayed open for 14 days, in which case the lower-priority claim is marked stale (resolution stale_source). Only official versus official and official versus api disagreements wait for a human.
When a single source's own new price differs from its last known price by more than 50% (the default threshold; a specific source can set a different one) on any field, with no other corroborating change, the new claim is parked in the review queue instead of being published automatically: a large, sudden price move is more often a parsing break than a real price cut.
Review and rejection
A claim is rejected at ingest, before it can reach the review queue, when it breaks a price invariant: input price above zero unless the offering is free (a free variant, or zero on both input and output), cache read not above input, cache write not below cache read, and batch prices not above their standard prices.
When an official price differs by more than 50% from two or more independent lower-priority sources that agree within 5%, the official price is held for review (consensus_override) and the consensus price is canonical until a human approves the official one.
Every refresh is audited after ingestion: each price change event it created is checked against structural rules, and an event that comes from our own re-identification, re-mapping or correction rather than from the host changing its price is withdrawn before it reaches the changes feed or sitemaps; every withdrawn event is recorded with its rule and evidence in an append-only audit log, and ambiguous cases stay published and are queued for review.
The blended price
Where a single number is needed to rank or compare models (sorting a table, computing a price change's magnitude, picking the "cheapest" offering), this site uses a blended rate of 75% input price plus 25% output price per 1M tokens. The weighting approximates a typical chat/agent workload, which reads more context than it generates; it is a ranking convenience only, never a substitute for the full input/output/cache/batch breakdown shown on every model and offering page.
A price change's percentage magnitude (shown on change pages and in the changes feed) is computed the same way: the blended rate before versus after.
Tiers and discontinued hosts
Tiers are editorial: a person assigns each model a tier when it is added or when its vendor releases a new generation, and records a one-line reason and a date. A tier is never derived from price, benchmark score or popularity, and a price change never moves a model.
Frontier: the vendor's current flagship general model, at most two per vendor. Strong: the vendor's previous flagship, or its current mid-size model. Small: the current budget class (mini, Flash-Lite, Haiku class) or a general model well below mid-size. Edge: nano or micro class, or under 10B parameters. A model with no tier is untagged.
Compare pairs exist only inside one tier and only when both models are tagged, so a model appears in one tier section. Older models keep their last tier until a person moves them. Each model's reason and assignment date are recorded with its tier in the curated seed data.
A host that has shut down its inference service is marked discontinued. Its offerings are excluded from current prices, rankings, comparisons and the frontier and dollar series, and no longer refreshed from aggregators that still list them. Its price history is kept and shown on model pages, labelled discontinued.
Variants
An offering is a model on one host in one variant: standard, batch, flex, fast, off-peak, or a quantisation (fp8, int4 and so on). The standard variant is the plain list price; every other variant is a separate row and never overwrites it. Time-of-day pricing is stored as the off-peak variant with its window in UTC (DeepSeek's peak hours are 01:00-04:00 and 06:00-10:00 UTC on weekdays, so its off-peak window is the rest of the day and all weekend); the model and compare pages show it as a line under the standard row, and the calculator ignores it.
Normalisation
All prices are stored as integer micro-USD per 1 million tokens (a decimal USD price multiplied by 1,000,000), parsed from each source's own string representation without ever passing a price through a floating-point division. This avoids rounding drift across the full history this project keeps.
Cache read/write pricing (including multi-tier cache TTLs where a vendor publishes them, such as Anthropic's 5-minute and 1-hour cache writes), batch-API discounts, long-context pricing tiers, and per-request or per-image pricing are each normalised into their own dedicated field where a source publishes them; anything that does not fit this common schema is kept verbatim in a per-offering "extras" field rather than discarded.
Tokenizer normalisation
Different model families tokenize the same text differently, so a USD-per-1M-tokens price is not directly comparable across tokenizer families without a common yardstick. This project measures characters-per-token for each tracked tokenizer family (o200k and cl100k via OpenAI's published tiktoken rank data; Llama 3, Qwen2, Mistral, DeepSeek and Gemma via each model family's own public Hugging Face tokenizer) against a fixed, roughly 1 MB text corpus: English prose, source code (Python, TypeScript, Rust), German, Croatian, Chinese and JSON, every file either public domain or self-authored for this project.
The measured ratio is published per corpus slice and as a single blended figure across all slices; the price table's USD-per-1M-characters view defaults to the blended figure and lets the slice be changed (plain prose vs. code skews the ratio noticeably for some families). A tokenizer family with no measured ratio (for example one needing a live API call this project does not make at build time) shows the native per-token price only, with no invented conversion.
Calculator formulas and defaults
The cloud-vs-local calculator answers one question: for a given monthly workload (input/output tokens, cache hit ratio, batch share, concurrency, an interactive latency target), what does a specific cloud API offering cost per month, and what would an equivalent open-weight model cost to run on specific local hardware, with every cost on both sides made explicit?
Cloud cost multiplies the workload's input, output, cache-read and cache-write token volumes by that offering's own priced rates, applying batch discounts and long-context tiers where published; nothing here is estimated, it is the offering's stored prices applied to the stated workload.
Local cost has three parts, each a named default the calculator shows and lets you override: hardware amortisation (purchase price plus a spares allowance, spread over a chosen horizon of 24, 36 or 48 months, minus an estimated residual value), electricity (a chosen USD/kWh tariff, defaulting to the US commercial average from the EIA's Electric Power Monthly (table 5.6.A), applied to GPU and host power draw at load and at idle), and labour (an hourly rate times a monthly hours estimate for upkeep). Achievable throughput is derived from the hardware's published memory bandwidth and compute, the model's parameter count and quantisation, and a decode/prefill efficiency factor calibrated against reported real-world serving numbers, not measured on this site's own hardware; a measured tokens/second figure can be substituted for any of these at any time.
The full formulas, with a stable anchor per section, are published at /methodology/calculator. Every default value used in a given calculation, and its source, is listed in that calculation's own assumptions panel, not only here: hardware street prices are dated and re-verified periodically rather than being a one-time estimate.
Limitations
Coverage is not exhaustive. A small number of official vendor pricing pages render entirely client-side with no server-rendered fallback and are not parsed directly (their prices still reach this site through the JSON aggregators, badged aggregator rather than official); the full list of enabled and disabled sources is the generated table under Sources.
The review queue holds anything this pipeline is not confident enough to apply automatically: a brand-new model or host this project has not mapped to a known entry yet, a large unexplained price move, a disagreement between two sources, or an LLM-extracted price. An item sitting in the queue does not appear as a canonical price until a human resolves it, so a very new offering can take longer than one refresh cycle to show up.
Local-hardware cost estimates model throughput from published hardware specifications and a calibrated efficiency factor; they are not a benchmark of real serving software on real hardware, and will diverge from measured numbers for any specific inference stack, batching strategy or driver version. Hardware and electricity prices move and are dated at the time they were recorded, not live-quoted.
No quality or capability signal (benchmark scores, "price per intelligence point") is factored into any price, ranking or comparison on this site today; prices are compared as published, not adjusted for how good a model is. EUR and other non-USD display, rate limits, a deprecation calendar and per-host latency/throughput are tracked as future work, not built yet.