--- title: "LLM Pricing Resources: 12 Sources for API Price Data" description: "The best LLM pricing resources are provider pages plus machine-readable feeds like OpenRouter, LiteLLM and models.dev. Here is what each one misses." canonical: https://vynaris.com/blog/llm-pricing-resources author: "Dhrumil Barot" author_bio: "Dhrumil is an AI inference and LLM infrastructure expert. Dhrumil built Vynaris to make model access, routing and pricing simple and transparent for developers." published: 2026-11-07 updated: 2026-11-07 --- # LLM Pricing Resources: 12 Sources for API Price Data Published 2026-11-07 · By [Dhrumil Barot](https://vynaris.com/about#founder), Founder 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. ![Price data flows from provider pages into feeds, then trackers and calculators, and each hop can add lag](https://cdn.sanity.io/images/u1qdn8dx/production/c7d3d314835f7e0d3e8cc16c902c6157ceaba192-1344x326.png?w=1440&fit=max&auto=format) *Each hop adds lag: verify billing numbers at the first box.* ## 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](https://platform.claude.com/docs/en/about-claude/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](https://ai.google.dev/gemini-api/docs/pricing): now redirects to aistudio.google.com/docs/pricing. Watch for prices that change above a context-length threshold. - [OpenAI API pricing](https://openai.com/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](https://api-docs.deepseek.com/quick_start/pricing): a plain docs page that is easy to scrape. DeepSeek has run time-of-day pricing before, so read the footnotes. - [Mistral pricing](https://mistral.ai/pricing): list prices for Mistral's hosted API. - [AWS Bedrock pricing](https://aws.amazon.com/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](https://vynaris.com/blog/openai-api-pricing), [Claude API pricing](https://vynaris.com/blog/claude-api-pricing) and [Gemini API pricing](https://vynaris.com/blog/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](https://openrouter.ai/api/v1/models): 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](https://github.com/BerriAI/litellm/blob/main/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](https://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](https://www.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](https://prices.azure.com/api/retail/prices) needs no authentication and returns per-region meters for Foundry Models with an `effectiveStartDate`. The [AWS Price List bulk API](https://pricing.us-east-1.amazonaws.com/offers/v1.0/aws/AmazonBedrock/current/region_index.json) does the same for Bedrock. ![The same Claude Sonnet 5 input price is stored in three different units across feeds](https://cdn.sanity.io/images/u1qdn8dx/production/824d0ff30bb319dbd0e34d7b25fe16060f7bf8a8-1344x410.png?w=1440&fit=max&auto=format) *Normalize units before you merge feeds.* The unit trap is the most common bug when people merge these feeds. Here is a normalizer that works for all three: ```python 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](https://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](https://artificialanalysis.ai/models): pairs price with measured speed and quality indexes. Use it when the choice is price against capability, not price alone. - [Helicone LLM cost](https://www.helicone.ai/llm-cost): a searchable per-model price table from an observability vendor. - [llm-prices.com](https://www.llm-prices.com): a simple calculator and table. Its list was last updated on 2026-10-26. - [OpenRouter models page](https://openrouter.ai/models): 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): | Task shape | Input (uncached) | Cache read | Output | Cost per task | Per 1,000 tasks | | --- | --- | --- | --- | --- | --- | | Support reply | 3,000 | 0 | 400 | $0.0100 | $10.00 | | Agent step with cached context | 4,000 | 36,000 | 600 | $0.0212 | $21.20 | 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](https://vynaris.com/blog/prompt-caching-break-even-2026) covers when that discount is real. To do this across models without a spreadsheet, enter your task shape into the [Vynaris cost calculator](https://vynaris.com/calculator). It prices one task across models, and you can browse current per-model rates on [/models](https://vynaris.com/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. | Job | Best resource | Why | Watch out for | | --- | --- | --- | --- | | Quoting a customer or setting a budget | Provider pricing page | Source of truth | Bot blocking (OpenAI returned 403 to scripts) | | Cost tracking inside an app | LiteLLM JSON | Per-token fields match usage logs | 3.3 MB file, so cache it | | Model picker or internal catalog | models.dev api.json | Per 1M units, release dates, open-weights flag | Coverage is broad, so filter by provider | | Comparing gateway routes | OpenRouter /api/v1/models | Includes cache, reasoning and long-context overrides | OpenRouter's price, not always the direct one | | Enterprise cloud procurement | Azure Retail Prices API, AWS Price List | Regional meters with effective dates | Meter names are cryptic, so map them by hand | | Quick browsing | models.dev, Artificial Analysis, Helicone | Sortable tables | Check the update date first | ## 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: ```python 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](https://vynaris.com/blog/batch-apis-openai-vs-anthropic-when-latency-is-free). ## Start here: a 15-minute path 1. Pick your 3-5 candidate models on [models.dev](https://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. ## About the author [Dhrumil Barot](https://vynaris.com/about#founder), Founder. Dhrumil is an AI inference and LLM infrastructure expert. Dhrumil built Vynaris to make model access, routing and pricing simple and transparent for developers. [LinkedIn](https://www.linkedin.com/in/bdhrumil) · [X](https://x.com/fyidhrumil)