LLM Price Tracker — OpenRouter Markup vs Provider List Prices

See what OpenRouter's markup is right now, and get a structured feed of LLM API price changes on a schedule. Free keyless JSON sources, no scraping, no personal data. Detection is per-run: changes surface on your next scheduled run, not in real time.

What you get

1. The current markup table — every run, including the first. OpenRouter resells other providers' models, often at a markup, sometimes at a discount. One markup_snapshot row per OpenRouter model with a confidently matched direct list price (from the LiteLLM price map), worst markup first:

{
    "eventType": "markup_snapshot",
    "modelId": "google/gemini-flash-latest",
    "openrouterPromptPrice": 1.5,
    "openrouterCompletionPrice": 9,
    "listPromptPrice": 0.3,
    "listCompletionPrice": 2.5,
    "markupPromptPct": 400,
    "markupCompletionPct": 260,
    "matchedLitellmKey": "gemini/gemini-flash-latest",
    "detectedAt": "2026-07-12T06:00:00.000Z"
}

Matching is high-confidence only: provider family + exact normalized name. Ambiguous names are refused, not guessed — models without a confident match don't get a row. The markup is an estimate (LiteLLM's list price is community-maintained); matchedLitellmKey lets you audit every pairing. Toggle with includeMarkupSnapshot (needs both sources).

2. A change feed for scheduled alerting. Each run diffs current prices against your previous run and emits one event per change:

{
    "eventType": "price_change",
    "modelId": "openai/gpt-5",
    "source": "openrouter",
    "field": "completionPrice",
    "oldValue": 10,
    "newValue": 8,
    "pctChange": -20,
    "direction": "decrease",
    "detectedAt": "2026-07-10T09:00:00.000Z",
    "prevRunAt": "2026-07-09T09:00:00.000Z"
}

eventType is one of price_change, context_change, new_model, removed_model, markup_change (markup changes also carry the four underlying prices so you can check the arithmetic). All prices are $ per 1,000,000 tokens — the unit providers quote. 0 = free; when a percent genuinely can't be computed (e.g. free → paid), the event still fires with pctChange: null, never a fabricated number.

How to use it (zero setup, no API key)

1. Optionally set a watchlist — model-id substrings or globs (gpt-5, claude-opus, anthropic/*). Empty = watch everything.
2. Pick sources (default both): openrouter (~350 models) and litellm (broad multi-provider map).
3. Run it on a schedule (hourly/daily). Give each independent schedule its own monitorId — two schedules sharing one starve each other, because each run consumes the diff.
4. First run is a baseline: it emits zero change-events (nothing to compare yet) but still delivers the full markup table. A later run with 0 items just means nothing changed — normal, not an error.

Cost controls

• changeThresholdPct — suppress price/context moves smaller than this relative % (e.g. 5 hides a +4% move).
• markupThresholdPts — suppress markup moves smaller than this many absolute percentage points.
• maxItems caps delivered rows per event class. The cap is lossy: excess changes are dropped permanently (the snapshot still advances), not queued for next run.
• Change events are delivered before the markup table, so alerts keep budget priority if your Max total charge runs out.

When a source breaks

If a source returns zero priced models, or its model count drops more than maxSourceDropPct (default 40%) since the last run, the run skips the diff: nothing charged, snapshot untouched, so an upstream outage can't bill you a flood of false removed_model events. The run still succeeds and emits one uncharged source_degraded item you can alert on.

Pricing

Pay per delivered row: price-change-detected per change-event, markup-snapshot-row per markup-table row (set includeMarkupSnapshot: false for a pure change feed), plus the standard per-run apify-actor-start charge. Rows filtered out by your watchlist or thresholds are never charged. One real-world price cut can produce more than one row — e.g. a completion-price drop is 1 price_change and, since it moves OpenRouter's markup, 1 markup_change.

Limitations

• Coverage follows the aggregators. A model shipped only through a lab's own API (e.g. Meta's Muse Spark, July 2026) is invisible here until OpenRouter or LiteLLM lists it — then a new_model event fires automatically.
• Markup is an estimate, dependent on LiteLLM's community-maintained prices; unmatched models carry null, not a guess.
• Detection is per-run. Run more frequently for tighter latency.

Data sources

OpenRouter models API and the LiteLLM price map — both public JSON, queried with an identifying User-Agent. Not affiliated with or endorsed by OpenRouter, BerriAI/LiteLLM, or any provider; verify prices against the provider's official page before commercial decisions.

---

Found this useful? A review helps others find it. Hit a problem? Open an issue and I'll fix it fast.

Telemetry

Each run records one anonymous event to the developer's own storage: a salted hash of the caller account ID (never the raw ID), the run origin, and a timestamp. No inputs, results, or personal data — this only measures adoption.