ComparEdge LLM Cost
Token cost math for LLM API calls: verified per-1M-token rates for 69 models, 17 providers.
Open source Open in the app JSON README (API)
About
Token cost math for LLM API calls: verified per-1M-token rates for 69 models, 17 providers.
Details
- Kind
- MCP servers
- Topic
- AI, RAG & memory
- Publisher
- imkemit-ops
- Origin
- official
- Category
- ferramentas
- Transport
- local
- Version
- 1.0.0
- Stars
- 2
- Last push
- 2026-07-10T23:44:33Z
- Repository state
- ativo
- Language
- JavaScript
- License
- MIT
- Added
- 2026-08-29 04:00:10
- Updated
- 2026-08-29 04:00:10
- Origin id
io.github.imkemit-ops/comparedge-llm-cost
README
<div align="center">
   
</div>
Someone asks what the AI feature will cost at scale, and the honest answer around most teams is a shrug. Rates moved twice since anyone last checked, and the model itself will happily quote prices from its training data. This MCP server keeps current per-million-token rates for 69 models where your assistant can reach them, and does the arithmetic itself.
## Watch it work
```
$ You: price Claude Opus 4.8 on a 25k-token prompt with a 1k answer, run 5,000 times
llm-cost › estimate_cost
Cost estimate: Claude Opus 4.8 (Anthropic)
Rates: input $5/1M, output $25/1M, cached input $0.5/1M
Per call (25,000 in + 1,000 out tokens):
input: $0.1250
output: $0.0250
per call total: $0.1500
Across 5,000 calls: $750.00
Ways to pay less for the same 5,000 calls:
with cached input: $187.50
via batch API: $375.00
```
Nothing here is rounded or guessed. The rate is verified, date-stamped, and the server multiplied.
<details>
<summary><b>Open a second session: same call across four models, ranked</b></summary>
```
$ You: compare that call on Opus 4.8, Sonnet 5, GPT-5.6 Terra and Gemini 3.1 Pro
llm-cost › compare_models_cost
25,000 in + 1,000 out, cheapest first:
1. Claude Sonnet 5 $0.0600 /call $300.00 /5k
2. Gemini 3.1 Pro $0.0620 /call $310.00 /5k
3. GPT-5.6 Terra $0.0775 /call $387.50 /5k
4. Claude Opus 4.8 $0.1500 /call $750.00 /5k
Ranking uses each model's live feed entry, not remembered prices.
```
</details>
## The gap it closes
| An assistant on its own | An assistant with llm-cost |
|---|---|
| quotes output rates from training data, often a generation stale | reads the current rate, dated |
| flattens the estimate to "a few cents" | `$0.1500` per call, `$750.00` across 5,000 |
| never mentions batch or caching discounts | `$375.00` batch, `$187.50` cached, only where the model really offers them |
| confidently wrong, no way to tell | every figure traces to a feed entry with a verification date |
The same numbers answer in a browser through the [LLM calculator](https://comparedge.com/llm-calculator), and the [LLM category hub](https://comparedge.com/best/llm) ranks every tracked model by rating and price.
## Where the numbers travel
```mermaid
flowchart LR
V["provider pricing pages<br/>17 providers"] --> CE["verification<br/>date-stamped checks"]
CE --> F["model prices feed<br/>69 models, USD per 1M tokens"]
F -->|"6h cache, serve stale on failure"| MCP["llm-cost server<br/>local arithmetic"]
MCP --> A["your agent"]
```
The server never calls a provider API. It reads one public feed, [`llms-model-prices.json`](https://comparedge.com/llms-model-prices.json), and computes locally. Nothing to rate-limit, no key to leak, and a network hiccup serves the last good copy instead of an error. How each price gets checked is written up in the [methodology](https://comparedge.com/methodology), and the catalog behind it ships as an [open dataset](https://comparedge.com/open-data) under CC BY 4.0.
## The six tools
Four do the math. Two help you find the exact model id the math wants.
| Tool | Answers | Params |
|---|---|---|
| `estimate_cost` | one call, or N identical calls, in dollars | `model`, `input_tokens`, `output_tokens`, `calls?` |
| `compare_models_cost` | the same call priced across 2 to 6 models | `models[]`, `input_tokens`, `output_tokens` |
| `monthly_budget` | daily, monthly, yearly spend for a workload | `model`, `daily_calls`, `avg_input_tokens`, `avg_output_tokens` |
| `cheapest_models` | lowest-cost models, optional context floor | `min_context?`, `limit?` |
| `list_models` | every model with rates, context and tier | `provider?` |
| `list_providers` | providers with model counts and cheapest pick | none |
<details>
<summary><b>Token rules of thumb, for when nobody knows the counts</b></summary>
- A page of English prose is roughly 500 tokens; one token is about four characters.
- Model references are forgiving: `claude-opus-4-8`, `Opus 4.8` and `anthropic/opus` resolve to the same model. When the resolver is unsure, it returns candidates instead of guessing.
- `cheapest_models` ranks by a blended rate weighting input to output 3 to 1, because real workloads read far more than they write. Confirm the winner with `estimate_cost` on your actual split.
</details>
## Prompts
| Prompt | Args | Runs |
|---|---|---|
| `estimate_my_workflow` | `workflow`, `model?` | token estimates plus per-run and monthly cost for a described workflow |
| `pick_cheapest_model` | `task` | cheapest model that still meets the requirement, top candidates priced |
| `forecast_ai_budget` | `model`, `usage` | monthly and yearly bill projected from expected volume |
## Wire it up
```json
{
"mcpServers": {
"llm-cost": {
"command": "npx",
"args": ["-y", "@comparedge/llm-cost-mcp@latest"]
}
}
}
```
Claude Desktop keeps this file at `~/Library/Application Support/Claude/claude_desktop_config.json`. Cursor: Settings, then MCP. VS Code with Copilot reads `.vscode/mcp.json`. Restart the client; six tools appear. No API key, no account. Per-client walkthroughs live in the [setup guide](https://comparedge.com/mcp/docs).
## Family
Built by [ComparEdge](https://comparedge.com), where software prices are checked against vendor pages before anyone quotes them. Two siblings share the data: the full catalog server and a price-change watcher, both on [ComparEdge MCP](https://comparedge.com/mcp).
MIT licensed. JSON-RPC 2.0 over stdio, standard Model Context Protocol.