Blog · 2026-11-07 · By Dhrumil Barot, Founder

LLM Pricing Resources: 12 Sources for API Price Data

The best LLM pricing resources are provider pages plus machine-readable feeds like OpenRouter, LiteLLM and models.dev. Here is what each one misses.

TL;DR: For a price you will bill against, read the provider's own pricing page. For code, pull a machine-readable feed: OpenRouter's public /api/v1/models, LiteLLM's model_prices_and_context_window.json or the models.dev api.json. Comparison sites are fine for browsing, but check their update date before you trust a number.

The most useful LLM pricing resources fall into four groups: official provider pricing pages (the source of truth), machine-readable price files you can load into code, comparison trackers for browsing, and calculators that turn token prices into cost per task. We checked every source below on 2026-11-07 and recorded how fresh it was and what it leaves out. The short version: OpenRouter's API listed 460 models with per-token prices, LiteLLM's JSON had 4,771 entries and a commit from that morning, and one popular tracker was 12 days stale.

Where can I find current LLM API prices?

The provider's own pricing page is the only source that is current by definition. Everything else copies from it, with a delay.

• Anthropic pricing: Claude models, including prompt caching write and read rates and batch discounts. The old docs.anthropic.com URL now redirects here, so update old bookmarks.
• Google Gemini API pricing: now redirects to aistudio.google.com/docs/pricing. Watch for prices that change above a context-length threshold.
• OpenAI API pricing: the reference for GPT models. It returned HTTP 403 to our script on 2026-11-07, so plan to check it by hand or through a feed.
• DeepSeek pricing: a plain docs page that is easy to scrape. DeepSeek has run time-of-day pricing before, so read the footnotes.
• Mistral pricing: list prices for Mistral's hosted API.
• AWS Bedrock pricing: needed when you buy models through AWS. Rates can differ by region and from the model vendor's direct price.

What these pages miss: they never compare across vendors, and none of them tells you cost per task. Our own provider guides track the details that change: OpenAI API pricing, Claude API pricing and Gemini API pricing.

Is there a machine-readable LLM price list?

Yes. Several, and they differ in units, coverage and how often they update. Five worth using:

• OpenRouter models API: public, no key needed. It returned 460 models on 2026-11-07. Prices are strings in USD per token, so "0.000002" means $2 per 1M tokens. It also has fields that most trackers drop: input_cache_write_1h, internal_reasoning, web_search and overrides for long-context tiers. Caveat: these are OpenRouter's prices, which usually but not always match the provider's direct price.
• LiteLLM model_prices_and_context_window.json: the biggest file, at 4,771 entries and about 3.3 MB, and it had a commit at 09:32 UTC on 2026-11-07, the day we checked. Prices are per token (input_cost_per_token). It also stores max_input_tokens, mode and deprecation_date. Best when you already use LiteLLM, because its cost tracking reads this file.
• models.dev api.json: an open-source database covering 235 providers and 8,943 model entries. Prices are USD per 1M (input, output, cache_read, cache_write), next to release_date, last_updated and open_weights. It is the cleanest choice for a model picker.
• llm-prices.com current-v1.json: Simon Willison's small, hand-curated list, priced per 1M. It is easy to read, but updated_at said 2026-10-26 when we checked.
• Cloud price APIs: the Azure Retail Prices API needs no authentication and returns per-region meters for Foundry Models with an effectiveStartDate. The AWS Price List bulk API does the same for Bedrock.

The unit trap is the most common bug when people merge these feeds. Here is a normalizer that works for all three:

import json, urllib.request

def get(url):
    return json.load(urllib.request.urlopen(url, timeout=30))

# OpenRouter: USD per token as strings
openrouter = {m["id"]: float(m["pricing"]["prompt"]) * 1e6
              for m in get("https://openrouter.ai/api/v1/models")["data"]}

# models.dev: USD per 1M already
md = get("https://models.dev/api.json")
models_dev = {f"{p}/{k}": v["cost"]["input"]
              for p, prov in md.items()
              for k, v in prov.get("models", {}).items() if v.get("cost")}

print(openrouter.get("anthropic/claude-sonnet-5"))  # 2.0 on 2026-11-07

What feeds miss: tiered prices are where they disagree. On 2026-11-07 OpenRouter listed openai/gpt-6.1-terra at $1 input and $5 output per 1M, with an override above 272,000 prompt tokens of $2 input and $7.50 output. A flat "input/output" column hides that, and long-context jobs are exactly where the bill jumps.

Which price comparison sites are kept up to date?

Trackers are good for browsing and bad as a billing source. Check each one's "updated" date, and check one model you know against the provider page.

• models.dev: sortable by price, context, release date and open weights. It is backed by the JSON above, so it is as fresh as that file.
• Artificial Analysis: pairs price with measured speed and quality indexes. Use it when the choice is price against capability, not price alone.
• Helicone LLM cost: a searchable per-model price table from an observability vendor.
• llm-prices.com: a simple calculator and table. Its list was last updated on 2026-10-26.
• OpenRouter models page: useful for checking what a route costs on OpenRouter specifically.

What trackers miss: cache write rates, batch discounts, regional cloud prices and the dates prices changed. When a number decides a contract, go back to the provider.

How do I estimate cost per task rather than per token?

Multiply each token type by its own rate, then by tasks. Per-token prices alone mislead because tasks differ in shape. A support reply might be 3,000 input tokens and 400 output tokens; an agent step might be 40,000 input tokens that are mostly cache reads.

Worked example, using OpenRouter prices from 2026-11-07 for anthropic/claude-sonnet-5 ($2 input, $10 output, $0.20 cache read per 1M):

Derivation: support reply = 3,000 × $2/1M + 400 × $10/1M = $0.006 + $0.004 = $0.0100. Agent step = 4,000 × $2/1M + 36,000 × $0.20/1M + 600 × $10/1M = $0.008 + $0.0072 + $0.006 = $0.0212. Without caching, the agent step's 40,000 input tokens would cost $0.08 plus $0.006 output, or $0.086: about 4 times more. Our prompt caching break-even analysis covers when that discount is real.

To do this across models without a spreadsheet, enter your task shape into the Vynaris cost calculator. It prices one task across models, and you can browse current per-model rates on /models. If the cheapest model per task changes by workload, Vynaris can route each request to it through one OpenAI-compatible API.

Which resource should I use for which job?

Match the source to the decision. A wrong price in a dashboard is an annoyance; a wrong price in a customer quote costs money.

How do I get alerted when an LLM price changes?

Snapshot a feed every night and diff it against yesterday. Providers rarely announce price cuts loudly, and promotional prices can expire quietly. A 20-line script is enough:

import json, pathlib, urllib.request, datetime

url = "https://openrouter.ai/api/v1/models"
today = {m["id"]: m["pricing"] for m in
         json.load(urllib.request.urlopen(url, timeout=30))["data"]}

snap = pathlib.Path("prices-last.json")
if snap.exists():
    before = json.loads(snap.read_text())
    for model_id, price in today.items():
        old = before.get(model_id)
        if old and old != price:
            print(datetime.date.today(), model_id, old, "->", price)
    for model_id in before.keys() - today.keys():
        print(datetime.date.today(), model_id, "removed")
snap.write_text(json.dumps(today, sort_keys=True))

Run it from cron and send the output to Slack or email. Watch for two things besides changed numbers. A model that disappears from the feed usually means a deprecation, and LiteLLM's deprecation_date field can warn you earlier. A new overrides entry means a long-context price tier, which matters if your prompts are near the threshold.

Point a second copy at your direct provider pages if you can scrape them, because the feed and the provider can diverge. When they do, trust the provider and report the gap to the feed's maintainers: LiteLLM and models.dev both accept pull requests on GitHub.

What details do most LLM price lists leave out?

Most tables show one input price and one output price. Real bills have more lines than that:

• Cache writes and reads. Anthropic charges for writing to the cache as well as reading from it. On OpenRouter, Claude Sonnet 5 lists $2.50 per 1M for a 5-minute cache write and $4 for a 1-hour write, against $0.20 for a cache read.
• Reasoning tokens. Thinking models bill hidden reasoning as output. OpenRouter exposes this as internal_reasoning, and LiteLLM as output_cost_per_reasoning_token.
• Long-context tiers. Prices that step up past a threshold, such as the 272,000-token override on GPT-6.1 Terra.
• Tool fees. Web search is billed per call, not per token: $0.01 per call for several models on OpenRouter.
• Batch discounts. Batch APIs price lower in exchange for slower delivery; see our OpenAI vs Anthropic batch comparison.

Start here: a 15-minute path

1. Pick your 3-5 candidate models on models.dev or Artificial Analysis.
2. Open each provider's pricing page and note input, output, cache and batch rates with today's date.
3. Write down one realistic task shape (input, cached input, output tokens).
4. Compute cost per task, or use a calculator.
5. For ongoing monitoring, load the OpenRouter or LiteLLM feed nightly and alert on any change.

The tradeoff: a feed saves you the scraping but adds a dependency on someone else's update speed. For anything you invoice on, keep one direct check against the provider.

FAQ

What is the most accurate source of LLM API pricing?

The provider's official pricing page. Feeds and trackers copy from it, sometimes days later. Record the date you checked it.

Is OpenRouter pricing the same as buying direct?

Often for list prices, but not always. OpenRouter's feed shows OpenRouter's prices, and providers on cloud platforms such as Bedrock or Azure can price differently by region. Compare the two before you commit volume.

Why do LLM price feeds disagree?

Units (per token or per 1M), update lag, and tiers. Long-context overrides, 1-hour cache writes and batch rates exist in some feeds and not in others.

Is there a free API for LLM prices?

Yes. OpenRouter's /api/v1/models, models.dev's api.json, LiteLLM's JSON on GitHub and the Azure Retail Prices API all need no key.

How often do LLM prices change?

Often enough to automate. LiteLLM's price file had a fresh commit the morning we checked (2026-11-07), while a hand-curated list we checked was 12 days behind. Check the price on the day you budget.