Model Price Watch
This server lets you query live LLM API pricing data across models and providers directly from your AI assistant:
Search models — Find models by name, provider, ID, or category (flagship, reasoning, budget, coding, embedding, etc.), with optional open-source/proprietary filters.
Get model pricing — Retrieve full pricing details for a specific model by ID, including input/output/cached price per 1M tokens, blended cost, context window, modality, release date, and a link to its pricing page.
Compare models — Side-by-side comparison of 2–5 models on price, context window, and capabilities, with a verdict on which is cheapest for input, output, and blended workloads.
Find cheapest models — Rank models by input, output, or blended cost, with optional filtering by category or open-source status.
List providers — View all tracked AI providers (OpenAI, Anthropic, Google, Mistral, xAI, DeepSeek, etc.) along with descriptions and links to their official 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 198 current models across 32 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-03. 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 (13292 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?
With no annotations, the description carries full burden. It mentions side-by-side comparison and verdict but omits details like whether results are real-time, what 'capabilities' includes, or output format.
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?
Single sentence with no wasted words, front-loading core purpose and result, including range constraint.
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 tool complexity, description is decent but lacks explicit linkage to sibling tools and fails to mention that model_ids come from search_models (though in parameter note). No output schema provided.
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% with parameter description explaining model_ids. Tool description adds context about comparison but does not significantly enhance schema explanation.
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 compares 2–5 models on price, context window, and capabilities, and gives a cost verdict. It distinguishes from siblings like cheapest_models and get_model_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 use when comparing multiple models but does not explicitly state when not to use or mention alternatives like cheapest_models for a single cost comparison.
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 provided, so description must disclose behavior. 'List' implies read-only, but no explicit mention of no side effects, authentication, or rate limits. Adequate for a simple read operation but lacks full transparency.
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 sentence that is concise, front-loaded with the action, and contains no unnecessary words.
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 zero parameters, no output schema, and low complexity, the description is complete. It adequately informs the agent what the tool returns.
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?
No parameters exist, and schema coverage is 100% (empty). The description adds meaning beyond schema by specifying that the list includes descriptions and pricing pages, which is useful context.
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 verb 'List' and resource 'all tracked AI model providers', with examples (OpenAI, Anthropic, Google) and content details (short description, pricing page). It is distinct from sibling tools which focus on 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 usage context is clear: use when you need a list of providers. No explicit when-not or alternatives mentioned, but the simplicity of the tool makes it implied.
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 provided, so description carries full burden. It accurately describes the read-only search behavior and return fields. Could explicitly mention non-destructive nature but generally 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?
Two sentences, front-loaded with action and return, followed by usage examples. No fluff.
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?
With 4 parameters fully described in schema and return fields listed, description is complete. Could mention default limit but schema handles that.
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%, baseline is 3. Description adds context like 'free-text match' and usage examples, but does not significantly extend schema 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?
Description clearly states the tool searches a live pricing database by model name, provider, or id, and returns specific fields. It also gives example use cases that distinguish it from siblings like cheapest_models and compare_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?
Provides explicit usage scenarios: answering cost queries or listing models by provider. No explicit when-not-to-use, but the examples are strong guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TDQS
The tools are mostly distinct: search and get_model_pricing form a clear search-then-detail flow, and list_providers is unique. Some mild overlap exists between compare_models and cheapest_models since both can address cost questions, but their intended use cases are explained well enough to avoid serious confusion.
All tool names follow the same snake_case verb_noun pattern: search_models, get_model_pricing, compare_models, cheapest_models, list_providers. The naming is predictable and makes the purpose of each tool immediately recognizable.
Five tools is an appropriate scope for a focused pricing lookup service. Each tool covers a distinct query need without unnecessary bloat or missing core functionality.
For a read-only pricing watch ser, the tool surface covers the key user journeys: finding models, getting detailed pricing, comparing models, finding cheapest options, and listing providers. No critical gap is apparent for this domain.
Maintenance
Related MCP Connectors
Live LLM API pricing: token prices, comparisons, cheapest-model lookups. No key required.
Live LLM API price + status radar across 11 providers, with public per-model price HISTORY.
Compare up-to-date pricing for 40+ LLMs (incl. Chinese) & estimate cost from tokens. EN/zh.
LLM and GPU rental prices: model price lookup, GPU listings, cheapest-GPU search, price history
Related MCP Servers
- AlicenseAqualityCmaintenanceGlobal 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.8103MIT
- 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.562MIT
- 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
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/romanshumy/llm-prices-data'
If you have feedback or need assistance with the MCP directory API, please join our Discord server