Methodology.

• OpenRouter rankings-daily — per-model token volumes, 30 days of history per snapshot. Pulled once per day.
• OpenRouter models catalog — pricing (prompt + completion $/token), context length, endpoints, supported parameters.
• Vercel AI Gateway models — per-model share on a second independent gateway; used for cross-source consistency checks.
• OpenRouter benchmarks — Artificial Analysis composite indices (intelligence, coding, agentic).
• OpenRouter session cost — median dollars spent per session, grouped by coding agent, model, and session length (1 turn through 50+ turns). Medians are reported upstream; we do not re-aggregate them, we only join them to usage share and benchmark scores. See cost per session.

Share is the % of tracked tokens on a given day, not total platform volume. Each source exposes a public top-50 slice, so shares always sum to 100% of that slice.

Calibration: OpenRouter reports roughly 100T tokens/month platform-wide; the public top-50 slice we track covers about 7–9T tokens/day. All Tidelines shares are of the tracked set — a lab at 12% share isn't 12% of the internet, it's 12% of the models people can see on the leaderboard.

Whenever we quote a dollar figure, it is: est. $ = tokens × blended catalog price where blended catalog price is 0.3 · prompt + 0.7 · completion in $ / M tokens.

Price basis. We use OpenRouter's model-level catalog price (the pricing field on the model, not any single provider). In practice this is the lowest standard rate among the model's providers, and it often equals the lab's own first-party price — e.g. Claude Opus 5.5 at $4 / $20 (shared by Bedrock, Azure and Google) or GPT-6 Luna at $0.10 / $0.50 (OpenAI, Azure). It is not always the absolute cheapest endpoint: discounted or batch endpoints can sit below it (GPT-6 Luna has a $0.05 input endpoint), and premium endpoints sit above it (some Opus 5.5 endpoints charge $8 / $40). For fast-moving open models it tracks the cheapest provider (DeepSeek V4.1 Flash: $0.024 input, versus a $0.195 median across 33 providers). Cache-read rates are never used as the input price.

Point-in-time. Each day is priced with the catalog snapshot saved that day. Daily snapshots begin on 16 Jul 2026; earlier days use the earliest snapshot and are shaded "prices reconstructed" on charts. A model missing from a day's catalog uses its last earlier listing, then its first later one.

Unpriced models. A model with no catalog price is excluded from both the numerator and the denominator of every dollar figure and share — never counted as $0. Spend views show a coverage line ("Priced models cover X% of tracked tokens"). :free variants are genuinely $0.

Spend share. A lab's (or model's) dollars ÷ all dollars over the same window. Raw = a single day; 7-day = trailing 7-day sums of dollars, then divided. Tables (Labs, Rankings, Spend) show the latest single day.

This is a catalog-price estimate. It ignores negotiated enterprise discounts, per-provider price differences, cached-token rebates, and free-tier promotional traffic. It is a directional gauge of where gateway inference dollars flow, not a revenue figure.

Published lists, sourced directly from the shared mapping the site uses everywhere:

Open-weights = the lab publishes model weights under a license that lets you run them yourself. Individual models within a mixed lab (e.g. Google Gemma) may be classified differently at the model level via the OpenRouter hugging_face_id field.

Whenever we quote a single price for a model, we compute blended price = 0.3 · prompt + 0.7 · completion, both in $ / M tokens. The 30 / 70 mix reflects that most gateway traffic is generation-dominated.

TPI v2 is the average price of a token routed through the gateway, weighted by real per-model volume and priced from the OpenRouter catalog. Anchored to 100 on the first archived day with a computable raw value.

raw(d)  =  Σ_model tokens(model, d) · blended_price(model)
          ────────────────────────────────────────────────
                    Σ_model tokens(model, d)

blended_price = 0.3·prompt + 0.7·completion  ($/M, catalog snapshot for day d)
:free variants price at $0
models with no catalog price are excluded from both sums
TPI(d) = 100 · raw(d) / raw(d0)

TPI is not a dollar figure; it moves with the mix of traffic across expensive and cheap models. A falling TPI means the average token routed is getting cheaper.

Usage-weighted median of blended $/M across every tracked model on a given day. Sort models by blended price ascending, walk cumulative token weight, stop at the 50th percentile. Robust to a few very expensive or very cheap outliers — this is the price the median token actually pays.

It is a price statistic only. Estimated daily spend is never median price × total volume: everywhere on the site, est. $ / day = Σ_model tokens(model, day) · blended_price(model), a usage-weighted sum. Because cheap models dominate volume while expensive models dominate dollars, the two methods differ by several times — the summed figure is the one we quote.

Herfindahl-Hirschman on the day's top-10 model shares: HHI = Σ share_i² where share_i is percent. Values approach 10,000 in a monopoly and drop toward 1,000 when the top-10 is evenly split. Computed on top-10 only, not the full market.

Reasoning flag v2 — metadata first: a model is classified as reasoning if the OpenRouter catalog's supported_parameters includes reasoning or include_reasoning, or the catalog's reasoning.default_enabled / reasoning.mandatory is set. Regex on slug + display name (matching o1|o3|o4|-r1|deepseek-r|qwq|thinking|reasoning) is used only as a fallback for models absent from the catalog.

Reasoning share = tokens routed to reasoning-flagged models ÷ total tracked tokens. Free share = tokens on :free variants ÷ total.

• Momentum — 30-day change in share, in percentage points.
• Acceleration — (7-day Δ per day) − (30-day Δ per day). Positive = the model is speeding up relative to its own trend.
• Adoption velocity — days from a model's first archive appearance to crossing 0.5% and 1% share thresholds.
• Breakout — 7-day mean share > trailing 30-day mean + 2σ.
• Half-life — consecutive days a model stays at rank #1.

For each model with both a benchmark score and a usage share: overrated_score = benchmark_rank − usage_rank. Positive values mean a model benchmarks better than it's used (overrated on paper); negative values mean it's used more than its rank would predict (a hidden workhorse).

Tidelines snapshots both sources daily and appends to an immutable archive; published history is never revised. History beyond each source's own rolling window comes from our archive.

Archive start: 2025-01-01. Latest snapshot: 2026-10-15.

• All figures are gateway-observed; direct enterprise API traffic is invisible.
• Dollar figures use point-in-time OpenRouter catalog prices (reconstructed before 16 Jul 2026) — negotiated rates are lower, providers differ, cached tokens are cheaper, and free-tier traffic does not clear at these rates.
• Two independent gateways (OpenRouter + Vercel) don't always agree; each chart labels its source.
• Token counts come from each provider's own tokenizer, so tokens aren't perfectly comparable across providers — cross-model and cross-app comparisons are ordinal, not exact.
• Top-50 coverage is exact: OpenRouter's daily feed includes one "other" row summing every model outside the top 50.
• Code vs natural language comes from a sampled weekly dataset and is labelled "Weekly estimate (sampled)". Tool-calling, context-length and modality shares are exact daily counts. Tool-calling and modality filter by model capability (models that support tools, images or audio), not by what each request used; context length is measured per request.
• Coding by form factor sums the top 100 apps in each coding subcategory per week, so the long tail of small apps is not included.
• HHI is computed on top-10 shares only; it is not a full-market HHI.
• Free-tier traffic is promotional and may not reflect paid demand (mirrors the Rankings footer note).

Upstream:

Usage data: OpenRouter (openrouter.ai/rankings) and Vercel AI Gateway (CC BY 4.0). Benchmarks: Artificial Analysis composite indices, Design Arena Elo ratings and OpenRouter's own evals, all via OpenRouter's benchmarks endpoint, each cited with the text that endpoint returns. App data: OpenRouter (openrouter.ai/apps). Prices: OpenRouter model-level catalog prices, saved daily. Session-cost and benchmark responses are archived weekly.

Citing us:

Cite as: Tidelines ({source}), {date}
e.g. "As of 2026-10-15, X holds Y% of OpenRouter token share (Tidelines)."

Charts may be embedded on other sites with attribution to Tidelines and the upstream source labelled on each chart.

• v1.3 · 15 Oct 2026 — New indices from the daily rankings feed, backfilled to 1 Jan 2025: tool-capable share, context-length mix and modality mix by model capability (exact), plus code vs natural language (weekly sampled estimate). Top-50 coverage is now exact. Chart footers use OpenRouter's required citation wording. Benchmarks add Design Arena and OpenRouter evals (cost and latency per task). Weekly archives of session cost, benchmarks and app rankings (top 200, with coding form factors) start now.
• v1.2 · 15 Oct 2026 — Point-in-time pricing: every day (spend, spend share, TPI v2, median price paid) is priced with that day's saved catalog instead of today's, with earlier days marked "prices reconstructed". Unpriced models are now excluded from both sides of every dollar calculation instead of counting as $0. History now keeps models that have since left the top list, so early-2026 spend shares no longer collapse onto Google. Spend share has one definition everywhere (dollars ÷ all dollars over the same window). Why: past days were priced at today's prices and older models counted as $0, which distorted spend shares and TPI history.
• v1.1 — TPI moved to v2 (real-price weighted, history recomputed); reasoning flag moved to catalog metadata; added share, spend, classification, trends, and archive definitions.
• v1.0 — Initial methodology (TPI v1 tier weights, regex-based reasoning flag).

Rule: every formula change increments the version and adds a line here.