Model Price Watch
This server lets you query, compare, and analyze live LLM pricing data from Model Price Watch.
Search models – find models by name, provider, or id, with optional filters for category and open-source status, returning current prices, context window, modality, and category.
Get model pricing – retrieve full pricing and capability details for a specific model, including input/output/cached prices, blended cost, context window, release date, and its modelpricewatch.com page.
Compare models – compare 2–5 models side by side on price, context, and capabilities, with verdicts on cheapest options for input, output, and blended workloads.
Find cheapest models – rank the cheapest models by input price, output price, or blended cost, optionally filtered by category or open-source status.
List providers – list all tracked AI providers with short descriptions and links to their pricing pages.
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 214 current models across 36 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-09-22. 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 (18182 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
5 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.
compare_modelsCompare modelsA
Compare 2–5 models side by side on price, context window, and capabilities, with a verdict on which is cheapest for input, output, and a typical blended workload.
| Name | Required | Description | Default |
|---|---|---|---|
| model_ids | Yes | List of 2–5 model ids to compare (from search_models). |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. The description implies a read-only comparison operation with no side effects, but it does not explicitly state that it does not modify data or require special permissions. The behavior is clear given the nature of the tool (comparison), so a slight deduction for missing explicit safety statement.
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 front-loads the core action (compare 2–5 models) and provides key details (price, context, capabilities, verdict). No unnecessary words or repetition.
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 tool with only one parameter and no output schema, the description is sufficiently complete. It specifies the input constraints and the output (verdict on cheapest for different workload types). It could briefly mention the output format (e.g., a side-by-side table), but overall it provides adequate context for an AI agent to select and invoke the tool correctly.
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 coverage is 100% and the schema description already explains the parameter (list of 2-5 model ids from search_models). The tool description does not repeat this, which is appropriate. The baseline score of 3 is correct since the schema handles the parameter semantics adequately.
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's purpose: compare 2–5 models on price, context window, and capabilities, and provide a verdict on cheapest for input/output/blended. This specific verb+resource combination distinguishes it from siblings like cheapest_models (which likely lists cheapest models without comparison) and get_model_pricing (which focuses on a single model's 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 implies usage context: when you want to compare specific models, with a clear constraint of 2-5 models. However, it does not explicitly state when not to use this tool or mention alternative sibling tools (e.g., cheapest_models for a simple list or get_model_pricing for individual pricing). The mention 'from search_models' provides a prerequisite but lacks exclusions.
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.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 5 tools
The tools are largely distinct: search and detail retrieval are separated, and compare vs. cheapest serve different workflows. However, search_models already returns pricing information, so an agent might sometimes reach for it when get_model_pricing would be more appropriate.
Most tools follow a clear verb_noun pattern: search_models, get_model_pricing, compare_models, list_providers. The exception is cheapest_models, which lacks a verb and breaks the otherwise consistent imperative style.
With only 5 tools, the server is tightly scoped to its pricing lookup purpose. Each tool covers a distinct user need: search, detail, comparison, cheapest ranking, and provider discovery, with no unnecessary bloat.
The tool surface covers the full pricing lookup lifecycle: discovering models, retrieving detailed pricing, comparing specific models, finding cheapest options, and browsing providers. There are no obvious dead ends for common pricing questions.
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.
Live pricing data for AI models across vendors: input/output prices per 1k tokens as JSON.
Live LLM API price + status radar across 11 providers, with public per-model price HISTORY.
Related MCP Servers
- AlicenseAqualityDmaintenanceGlobal 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.878 npmMIT
- FlicenseNot gradedqualityDmaintenanceProvides real-time token pricing for AI models, model comparison, cost calculation, and token usage tracking for agents and developers.-
- AlicenseNot gradedqualityBmaintenanceToken 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.25 npm2MIT
- AlicenseAqualityBmaintenanceDaily-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