Model Price Watch
Query a live, daily-verified LLM API pricing database (216 models, 37 providers) through four read-only tools.
search_models — free-text search by model name, provider, or id; filter by category (flagship, reasoning, budget, coding, embedding, fast, mid-tier) or open-source vs. proprietary; returns current input/output prices (USD per 1M tokens), context window, modality, and category.
get_model_pricing — full detail for one model id: input/output/cached prices, blended cost, context window, modality, release date, and its modelpricewatch.com source page URL.
cheapest_models — rank the cheapest current models by input price, output price, or blended cost, optionally scoped to a category (e.g. embedding) or open-source only; helps answer "cheapest model for X".
list_providers — enumerate all tracked providers with short descriptions and official pricing-page links.
All tools are read-only lookups; no API key is required, and results answer "how much does model X cost" and "what does provider Y offer" over current pricing rather than historical series.
Provides access to current and historical pricing data for Google's LLM models, including input/output/cached costs per million tokens, context windows, and model status.
Provides access to current and historical pricing data for Meta's LLM models, including input/output/cached costs per million tokens, context windows, and model status.
Provides access to current and historical pricing data for OpenAI's LLM models, including input/output/cached costs per million tokens, context windows, and model status.
LLM Prices — daily-verified LLM API pricing data
Machine-readable LLM API pricing for 217 current models across 38 providers (OpenAI, Anthropic, Google, Mistral, xAI, DeepSeek, Meta, Groq, Together, …), maintained by modelpricewatch.com. Every price links to the provider's official pricing page; prices are cross-checked daily against an independent reference and top models are re-read weekly from the provider pages with dated receipts.
Last sync: 2026-10-12. This repo is updated automatically after each refresh cycle.
Files
File | What it is |
Every tracked model: input/output/cached $ per 1M tokens, context window, modality, category, status, source URL | |
Provider metadata + official pricing-page URLs | |
Per-model price timeline (21447 dated points; see caveats) | |
The LLM Price Index — one number for the blended cost of frontier intelligence, daily series | |
Human-readable launches & price changes | |
MCP server: query these prices live from Claude/Cursor — |
Related MCP server: ohmytoken
Live API (no key required)
The same data, always current, CORS-open:
https://modelpricewatch.com/api/v1/models.json
https://modelpricewatch.com/api/v1/price-history.jsonDocs: https://modelpricewatch.com/api/ · Price-change feed (Atom): https://modelpricewatch.com/news/feed.xml
The LLM Price Index
A fixed, equal-weighted basket of frontier flagship models, blended 3:1 input:output, re-verified daily — a single citeable number for "what does a million tokens of frontier intelligence cost?" Methodology: https://modelpricewatch.com/price-index/methodology/
Caveats (honesty first)
History points are labelled by
source: our ownverified/snapshot captures vslitellm-archive(reconstructed from the open-source LiteLLM repo's git history — marked, never mixed silently).A deeper 2024→2026 history backfill is in progress; some models currently have short timelines. Known baseline discontinuities are under audit.
License & attribution
Data: CC-BY-4.0 — free for any use, with attribution to modelpricewatch.com. MCP bridge code: MIT.
Available Tools
4 toolscheapest_modelsFind cheapest modelsA
Find the cheapest current models, ranked by input price, output price, or a blended cost. The generic ranking covers generative text models (embeddings, OCR and realtime models are excluded — they price different work); pass category to rank a specific pool instead, e.g. 'embedding'. Use to answer 'what is the cheapest model for '.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | How many to return (default 10, max 50). | |
| sort_by | No | Ranking metric: 'input', 'output', or 'blended' (default 'blended'). | |
| category | No | Filter by category, e.g. flagship, reasoning, budget, coding, embedding. | |
| open_source | No | If true, only open-source models. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It discloses a key behavioral trait: the generic ranking excludes embeddings, OCR, and realtime models because they price different work, and explains how category adjusts the pool. This adds meaningful context beyond the obvious.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences front-loaded with purpose, followed by a necessary exclusions caveat and a direct usage statement. No redundant content; every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 4 optional parameters and no output schema. The description covers scope, exclusion behavior, category-specific use, and intended use case, giving an agent enough to select and invoke correctly without additional context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. The description adds value by illustrating category usage with 'embedding', clarifying the meaning of the ranking metrics, and noting the default behavior. This goes slightly beyond the schema's dry parameter descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Find') and resource ('cheapest current models'), and details ranking options (input, output, blended). It also distinguishes itself from siblings by noting the generic ranking excludes embeddings/OCR/realtime and that category can target specific pools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit guidance: 'Use to answer "what is the cheapest model for <use case>"' and explains when to pass a category. While it doesn't name alternatives, it gives clear context and exclusions that frame appropriate usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_model_pricingGet model pricingA
Get full pricing and capability details for one model by its id (from search_models). Returns input/output/cached price per 1M tokens, blended cost, context window, modality, release date, and the modelpricewatch.com page URL.
| Name | Required | Description | Default |
|---|---|---|---|
| model_id | Yes | The model id, e.g. 'anthropic-claude-opus-4-8' or 'openai-gpt-5-5'. Get ids from search_models. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly enumerates the return fields (input/output/cached price per 1M tokens, blended cost, context window, modality, release date, and page URL) and identifies the id source. It does not mention read-only behavior or error handling, but the verb 'Get' and return-focused wording make the core behavior quite transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, information-dense sentence that front-loads the primary purpose and then concisely enumerates the returned details. Every clause adds value, with no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-parameter, read-only pricing lookup tool, this description is nearly complete: it explains what the tool does, what the input should be, where the input comes from, and exactly what data is returned. It lacks an explicit statement about behavior for an invalid or unknown model_id, but that is a minor gap given the overall clarity and lack of an output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already provides a complete, well-described parameter (model_id) with examples and the instruction to get ids from search_models, putting schema coverage at 100. The tool description only repeats the id source without adding any additional parameter semantics. Baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific action (get full pricing and capability details), a specific resource (one model by its id), and the id source (from search_models). It distinguishes itself from sibling tools by emphasizing 'one model' and listing detailed pricing/capability fields, which is different from comparing or listing cheapest models.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'by its id (from search_models)' provides clear workflow context: the agent should first use search_models to obtain a model id, then use this tool. The singular 'one model' conveys that this is for single-model lookup, implicitly distinguishing from compare_models and cheapest_models, though it does not explicitly enumerate when not to use alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_providersList providersA
List all tracked AI model providers (OpenAI, Anthropic, Google, etc.) with a short description and their pricing page.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries full burden. It discloses that the tool lists providers with descriptions and pricing pages, indicating a read-only nature with no destructive behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single well-structured sentence that conveys all necessary information without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description adequately explains the return values (short description and pricing page), making it complete for a simple listing tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With zero parameters, the description adds value by specifying the output includes short descriptions and pricing pages, fully compensating for the lack of a parameter schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists all tracked AI model providers with short descriptions and pricing pages, distinguishing it from sibling tools that focus on models and pricing.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not explicitly state when to use this tool versus alternatives, but the context of sibling tools implies it is for provider overviews while others are for model-specific tasks.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_modelsSearch modelsA
Search the live LLM pricing database by model name, provider, or id. Returns matching models with current input/output prices (USD per 1M tokens), context window, modality, and category. Use this to answer 'how much does cost' or 'what models does offer'.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max results (default 20, max 50). | |
| query | No | Free-text match against model name, provider, or id (e.g. 'claude', 'gpt-5', 'gemini flash'). Omit to list all. | |
| category | No | Filter by category, e.g. flagship, reasoning, budget, coding, embedding, fast, mid-tier. | |
| open_source | No | If true, only open-source/open-weight models; if false, only proprietary. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states the tool searches a 'live' database and returns pricing data, implying read-only behavior. However, it does not explicitly confirm no side effects, rate limits, or other behavioral traits beyond the search functionality.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences: first states the action and data source, second gives two concrete use-case examples. No filler words, well front-loaded, and every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given four parameters, no output schema, and no annotations, the description covers the tool's purpose, return fields, and example queries. It lacks only minor details like default limit or pagination, which are handled by the schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage, describing all four parameters. The description does not add extra meaning beyond what the schema provides, so the baseline score applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it searches a live LLM pricing database by model name, provider, or id, returning specific fields. It distinguishes itself from siblings like cheapest_models or list_providers by providing explicit use cases: cost queries and provider listings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives concrete examples of when to use the tool: 'how much does <model> cost' and 'what models does <provider> offer'. While it doesn't explicitly mention when not to use it or alternatives, the context is clear enough for most agents.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
1 tool update
v1.0.3- Removed
compare_models
1 tool update
v1.0.2- Changed
get_model_pricing1 field changed- changed
Input schema / properties / model_id / descriptionPrevious value: -"The model id, e.g. 'anthropic-claude-opus-48' or 'openai-gpt-5-5'. Get ids from search_models."New value: +"The model id, e.g. 'anthropic-claude-opus-4-8' or 'openai-gpt-5-5'. Get ids from search_models."
5 tool updates
v0.1.0- First observed
cheapest_models - First observed
compare_models - First observed
get_model_pricing - First observed
list_providers - First observed
search_models
TDQS
Scored across 4 tools
Each tool targets a distinct operation: price ranking (cheapest_models), detailed single-model lookup (get_model_pricing), provider listing (list_providers), and search by name/provider/id (search_models). The only potential overlap—search_models and cheapest_models both return price info—is resolved by the clear ranking vs. lookup distinction.
Three of four names follow a verb_noun pattern (get_model_pricing, list_providers, search_models), while cheapest_models uses an adjective_noun form. This is a minor deviation; all names are snake_case and easily readable.
Four tools cover the core read-only operations for an LLM pricing database without redundancy or bloat. The count is well-scoped for the narrow domain.
The surface covers search, single-model detail, provider listing, and cheapest ranking. Minor gaps include no direct model comparison or standalone capability filtering, though category filtering exists in cheapest_models.
Maintenance
Related MCP Connectors
Live LLM API pricing: token prices, comparisons, cheapest-model lookups. No key required.
LLM API prices across 70+ providers: cheapest offer, comparisons, history and cost estimates.
Find AI model pricing, estimate token costs and compare offers. No API key required.
Compare LLM API prices, search models and providers, and access reviewed benchmark results.
Related MCP Servers
- AlicenseAqualityBmaintenanceGlobal price benchmarking for AI inference across 2,600+ SKUs from 47 vendors. Query live pricing, market indexes, and model specs via 8 tools. Free tier available.860 npmMIT
- FlicenseNot gradedqualityDmaintenanceProvides real-time token pricing for AI models, model comparison, cost calculation, and token usage tracking for agents and developers.-
- AlicenseNot gradedqualityCmaintenanceToken cost math for LLM API calls: current per-million-token rates for 69 models across 17 providers, with local arithmetic for estimates, comparisons and monthly budgets. Rates are verified and date-stamped.44 npm2MIT
- AlicenseAqualityAmaintenanceDaily-verified LLM API pricing dataset (44+ models, CN & global) with a hosted MCP server for live price queries and token cost estimation.2CC BY-4.0