# ComparEdge LLM Cost (npm · @comparedge/llm-cost-mcp)

Token cost math for LLM API calls: verified per-1M-token rates for 69 models, 17 providers.

- Trust score: 66/100 (medium)
- Change this week: −15
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- npm · `@comparedge/llm-cost-mcp`: 66/100 (this document), [markdown](https://verifymcp.io/servers/imkemit-ops-comparedge-llm-cost/comparedge-llm-cost-mcp.md), [page](https://verifymcp.io/servers/imkemit-ops-comparedge-llm-cost/comparedge-llm-cost-mcp)

## Channel facts

- Registry: `npm`
- Package: `@comparedge/llm-cost-mcp`
- Version: `1.0.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-03.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - No production dependencies, so there is no dependency health to assess.
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 22 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 77/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 1661 tokens (~276/item across 6 items; 6 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Capabilities**: 40/100
  - Spec-recency check failed: implements MCP spec 2025-03-26; the latest is 2026-07-28.

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### Claude

```bash
claude mcp add imkemit-ops-comparedge-llm-cost -- npx -y @comparedge/llm-cost-mcp
```

### Codex

```bash
codex mcp add imkemit-ops-comparedge-llm-cost -- npx -y @comparedge/llm-cost-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "imkemit-ops-comparedge-llm-cost": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@comparedge/llm-cost-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add imkemit-ops-comparedge-llm-cost --command npx --arg -y --arg @comparedge/llm-cost-mcp
```

### Hermes

```yaml
mcp_servers:
  imkemit-ops-comparedge-llm-cost:
    command: "npx"
    args: ["-y", "@comparedge/llm-cost-mcp"]
```

### Other

```json
{
  "mcpServers": {
    "imkemit-ops-comparedge-llm-cost": {
      "command": "npx",
      "args": [
        "-y",
        "@comparedge/llm-cost-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-02 (score 66, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-07-31 (score 51, −12)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-28 (score 63, −18)

- [security regression] Malware scan: pass → unverified

### 2026-07-27 (score 81, +34)

- [functional improvement] Tool coverage: unverified → 100
- [functional improvement] Schema quality: unverified → 100
- [functional] First check of Schema quality: fail
- [functional] First check of Tool coverage: 100
- [functional] First check of Schema quality: fail
- [functional] First check of Schema quality: excellent

### 2026-07-26 (score 47)

First indexed and scored.

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

## MCP tools (6)

### `list_providers` (~172 tokens)

List every LLM API provider ComparEdge tracks, with model count, whether a batch API is available, and the cheapest model per provider.

BEHAVIOR: Returns every provider we track (OpenAI, Anthropic, Google, DeepSeek, Amazon, Groq, Mistral, xAI, and more), each with its model count and a one-line cheapest-model summary. Prices are USD per 1M tokens.

USAGE GUIDELINES:
\- Use first when the user asks "which providers exist?" or "who sells the cheapest tokens?".
\- Use before list_models when you want the provider slug to filter by.
\- No parameters.

EXAMPLE QUERIES: "What LLM providers are there?", "Which providers have a batch API?", "Show me the model vendors you cover"

### `list_models` (~240 tokens)

List LLM models with their per-1M-token input and output prices, cached-input rate where offered, context window, and tier. Optionally filter to one provider.

BEHAVIOR: Returns every model (or just one provider's) with id, display name, input/output/cached rates, context window, and tier (flagship, standard, fast, reasoning). The id is what estimate_cost, compare_models_cost, and monthly_budget expect.

USAGE GUIDELINES:
\- Use to find the exact model id before pricing a call.
\- Pass provider (a slug like "openai", "anthropic", "google") to narrow the list.
\- Use cheapest_models instead when the user wants the lowest price rather than a full list.

EXAMPLE QUERIES: "List Anthropic models and prices", "What does GPT-5.5 cost per token?", "Show all reasoning models", "Which Gemini models have a 1M context window?"

Input parameters:

- `provider` (string): Optional provider slug to filter by (e.g. "openai", "anthropic", "google", "deepseek", "mistral")

### `estimate_cost` (~397 tokens)

Estimate the exact dollar cost of one LLM call, or a batch of identical calls, from input and output token counts. Returns a per-call breakdown plus cached-input and batch-API savings where the model supports them.

BEHAVIOR: Resolves the model reference (id or display name, fuzzy matched), then computes input_tokens/1M x input_rate + output_tokens/1M x output_rate. Multiplies by calls for a total. If the model offers cached-input pricing or a batch API, it shows those cheaper totals too.

USAGE GUIDELINES:
\- Use whenever the user knows roughly how many tokens a call reads and writes.
\- A rough token rule: 1 token is about 4 English characters, or 0.75 words. A page of text is ~500 tokens.
\- Set calls when the same-shaped request runs many times (e.g. one per support ticket).
\- Use monthly_budget instead when the user thinks in calls-per-day rather than a fixed batch.
\- Use compare_models_cost to price the same call across several models at once.

EXAMPLE QUERIES: "What does a 10k-token prompt with a 2k-token answer cost on Claude Opus 4.8?", "Price 50,000 GPT-5-mini calls at 800 in / 400 out tokens", "How much for a 200k-token document summarized by Gemini 3.1 Pro?"

Input parameters:

- `calls` (number): How many identical calls to price (default: 1)
- `input_tokens` (number, required): Number of input (prompt) tokens per call
- `model` (string, required): Model id or name (e.g. "claude-opus-4-8", "GPT-5.5", "gemini-3.1-pro"). Use list_models if unsure.
- `output_tokens` (number, required): Number of output (completion) tokens per call

### `compare_models_cost` (~291 tokens)

Price the same call across 2 to 6 models and rank them from cheapest to most expensive, with a multiplier showing how much more each costs than the cheapest option.

BEHAVIOR: Resolves each model reference, computes the per-call cost at the given token counts, sorts ascending, and reports each model's cost and its ratio to the cheapest. If any reference cannot be resolved, it says which one and stops so you can correct it.

USAGE GUIDELINES:
\- Use when the user is choosing between named models for a known workload.
\- Pick the token counts that reflect the real task, not a round guess, so the ranking is meaningful.
\- Use cheapest_models instead when the user has not named specific models.

EXAMPLE QUERIES: "Compare GPT-5.5, Claude Opus 4.8, and Gemini 3.1 Pro for a 5k/1k call", "Cheapest of Haiku 4.5, GPT-5-mini, Gemini 3 Flash for classification", "Opus vs Sonnet vs Fable at 20k in 2k out"

Input parameters:

- `input_tokens` (number, required): Input tokens per call, applied to every model
- `models` (array, required): Array of 2 to 6 model ids or names to compare
- `output_tokens` (number, required): Output tokens per call, applied to every model

### `cheapest_models` (~273 tokens)

List the cheapest LLM models, optionally filtered to those with at least a given context window. Ranked by a blended input:output rate.

BEHAVIOR: Ranks models by a blended per-1M rate weighted 3:1 input to output (most workloads read more than they write), lowest first. min_context filters out models with a smaller context window. Returns the blended rate plus the raw input and output rates so you can sanity-check against your own token split.

USAGE GUIDELINES:
\- Use when the user wants "the cheapest model" without naming candidates.
\- Pass min_context when the task needs a large window; it accepts "200" (read as 200K) or "200000" (raw tokens).
\- Follow up with estimate_cost using the real token split, since the blended ranking is an approximation.

EXAMPLE QUERIES: "What are the cheapest LLMs right now?", "Cheapest model with at least a 1M context window", "Five lowest-cost models for high-volume tagging"

Input parameters:

- `limit` (number): How many models to return (default: 5, max: 30)
- `min_context` (number): Minimum context window. Pass 200 for 200K, or 200000 for raw tokens (default: no minimum)

### `monthly_budget` (~288 tokens)

Project the daily, monthly, and yearly spend for a recurring LLM workload from calls-per-day and average token counts. Includes cached-input and batch-API projections where available.

BEHAVIOR: Computes per-call cost from average input and output tokens, then scales to daily (x calls), monthly (x30 days), and yearly (x365) totals, and reports the monthly token volume. Cheaper cached-input and batch paths are shown when the model supports them.

USAGE GUIDELINES:
\- Use for planning a feature that calls an LLM on a steady cadence (per ticket, per user action, per cron run).
\- avg_input_tokens and avg_output_tokens should be typical values, not worst case.
\- Use estimate_cost instead for a one-off or fixed batch.

EXAMPLE QUERIES: "Monthly cost if we run 5,000 Claude Haiku calls a day at 1,200 in / 300 out", "Budget GPT-5-mini for 200 summaries an hour", "Yearly spend on Gemini 3 Flash at 50k calls/day, 500/200 tokens"

Input parameters:

- `avg_input_tokens` (number, required): Average input tokens per call
- `avg_output_tokens` (number, required): Average output tokens per call
- `daily_calls` (number, required): Number of calls per day
- `model` (string, required): Model id or name to budget for

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/imkemit-ops-comparedge-llm-cost/comparedge-llm-cost-mcp#diagnostics

## Score history

- 2026-08-03: 66
- 2026-08-02: 66
- 2026-08-01: 51
- 2026-07-31: 51
- 2026-07-30: 63
- 2026-07-28: 63
- 2026-07-27: 81
- 2026-07-26: 47

## Links

- npm package: https://www.npmjs.com/package/@comparedge/llm-cost-mcp
- Socket report: https://socket.dev/npm/package/@comparedge/llm-cost-mcp
- Repository: https://github.com/comparedge/llm-cost-mcp
- Website: https://comparedge.com/llm-calculator
- Changelog RSS feed: https://verifymcp.io/servers/imkemit-ops-comparedge-llm-cost/comparedge-llm-cost-mcp/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/imkemit-ops-comparedge-llm-cost/comparedge-llm-cost-mcp/changelog.json
- HTML version of this page: https://verifymcp.io/servers/imkemit-ops-comparedge-llm-cost/comparedge-llm-cost-mcp