canonical: https://jentic.com/apis/modelpricewatch.com/modelpricewatch

# Model Price Watch API

The Model Price Watch API serves read-only JSON feeds of LLM token prices, with every price traced to the provider's official pricing page and re-verified on a schedule. It returns every tracked model with its current prices in USD per 1,000,000 tokens, the list of providers, published benchmark scores keyed by model id, recorded price changes over time, and a dated changelog of model and price updates. It also publishes the LLM Price Index, a single citeable figure for the cost of frontier inference, broken out by capability tier, and ranked model lists for use cases such as coding, long-context, reasoning, and embedding.

## For AI agents

Look up current LLM token prices, price history, benchmark scores, the LLM Price Index, and ranked models for use cases such as coding or long-context with Model Price Watch. Free tier needs no key; an optional X-API-Key raises the daily limit.

## Scope

Does not run model inference, route requests to providers, or track your own token spend. Use for reading published LLM price, benchmark, and price-index data only.

## Capabilities

- Retrieve every tracked model with its current input and output token prices
- Rank models for a use case such as coding, reasoning, long-context, or prompt-caching
- Pull published benchmark scores keyed by model id, with null where none exists
- Track recorded price changes over time from the price history feed
- Cite the LLM Price Index value and its breakdown by capability tier
- Find the cheapest input, cheapest output, and largest context across the dataset

## Use cases

### Agent Model Selection Through Jentic

An AI agent choosing which model to route a task to fetches the ranked list for that use case, such as reasoning or cheap-api, and compares current token prices before deciding. Through Jentic the agent finds the best-for operation by intent and calls it with the intent slug, using a stored key if you have one to lift the daily request limit.

Example prompt: Get the ranked models for intent 'coding', then look up each model's current token prices in the models feed and return the three cheapest

### LLM Cost Tracking and Budgeting

Finance and platform teams track what inference costs by pulling the price history and changelog feeds to see when providers cut or raised prices, and quote the LLM Price Index when reporting cost trends. Prices are in USD per 1,000,000 tokens, so cost estimates multiply directly by token volume.

Example prompt: Fetch the price history feed and list every recorded price change, then fetch the LLM Price Index and report its value and change

### Pricing Pages and Comparison Content

Publishers and tool builders embed current model prices and benchmark scores in comparison tables, citing Model Price Watch with attribution as the free tier allows. The stats feed supplies headline figures such as total models, total providers, open-source and multimodal model counts, and the cheapest input and output prices.

Example prompt: Fetch the stats feed and return total_models, total_providers, cheapest_input, and largest_context

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/api/v1/models.json` | Every tracked model with current token prices |
| GET | `/api/v1/best-for/{intent}.json` | Ranked models for a use case |
| GET | `/api/v1/benchmarks.json` | Benchmark scores keyed by model id |
| GET | `/api/v1/price-history.json` | Recorded price changes over time |
| GET | `/api/v1/price-index.json` | The LLM Price Index |
| GET | `/api/v1/stats.json` | Headline counts and extremes for the dataset |

## Key resources

- **Models** — Every tracked model with its current token prices
- **Providers** — Every tracked model provider
- **Benchmarks** — Published benchmark scores keyed by model id
- **Price History** — Recorded price changes over time
- **LLM Price Index** — A single citeable figure for frontier inference cost, with tier breakdowns
- **Best For** — Ranked models per use-case slug

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 60 / 100
- **Maturity:** Foundational
- **Dimensions:**
  - Foundational Compliance: 52 / 100
  - Developer Experience & Jentic Compatibility: 63 / 100
  - AI-Readiness & Agent Experience: 50 / 100
  - Agent Usability: 94 / 100
  - Security: 50 / 100
  - AI Discoverability: 70 / 100
- **View full report:** https://jentic.com/apis/modelpricewatch.com/modelpricewatch/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring Model Price Watch by hand is light: the feeds are plain JSON GETs and the X-API-Key header is optional. Through Jentic you install once, import Model Price Watch from the API Directory, optionally store a key once to lift the daily limit, and your agent calls it alongside the model APIs it is choosing between.
- **Permission scoping:** Model Price Watch puts the use-case slug in the URL path (`/api/v1/best-for/{intent}.json`), so a rule can pin your agent to one ranking such as coding. Every operation is a read, so scoping here is about keeping the agent on the feeds it needs.
- **Credential handling:** If you use a Model Price Watch key, it is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'compare LLM token prices' or 'find the best model for coding', and Jentic returns the matching Model Price Watch operation with its input schema so the agent calls the right feed without reading the reference docs.

## Related APIs

- **OpenRouter** — Unified API that routes requests across many LLM providers
- **Hugging Face Hub** — Model hub metadata for open models and datasets
- **Groq** — Fast LLM inference API

## FAQ

### What authentication does the Model Price Watch API use?

Per its OpenAPI spec, authentication is optional: every operation works with no credential on the free tier, and an API key sent in the `X-API-Key` header raises the daily request limit. The health check never requires a key. If you use a key, Jentic stores it once, encrypted, in your own Jentic One instance and injects it at call time.

### Can I find the best model for a specific use case with the Model Price Watch API?

Yes. The best-for operation takes a use-case slug in the path, such as coding, chatbot, cheap-api, prompt-caching, long-context, multimodal, reasoning, open-source, fast-inference, embedding, or enterprise, and returns ranked models for it.

### Can I limit what my agent is allowed to do with the Model Price Watch API?

Yes. Every operation is a read, so the useful limit is on which feeds the agent may call: for example, write a rule that allows only the models and best-for operations so the agent sticks to price lookups and rankings, and every call it makes is logged.

### What are the rate limits for the Model Price Watch API?

The OpenAPI spec says the free tier needs no key and that adding a key raises the daily request limit, but does not state the numbers; see https://modelpricewatch.com/api-pricing/ for current limits. The health check is not rate limited.

### How do I compare LLM prices with Model Price Watch through Jentic?

Search Jentic for the intent 'compare LLM token prices', which returns the Model Price Watch models operation on `/api/v1/models.json`; the agent calls it and compares current prices in USD per 1,000,000 tokens. To run it on your own infrastructure, install Jentic One from its GitHub repo.

### Is there a Model Price Watch MCP server?

You don't need an MCP server to give your agent the Model Price Watch API. Jentic connects it directly from the API Directory: import it, optionally store a key once, and your agent calls the price, benchmark, and index feeds. Operations are discovered on demand, so no extra tool definitions are loaded into the agent's context.