mcpcost

mcpcost

Is that MCP server alive, and what does it cost your context window?

Live board: [mcpcost.ulehla.dev](https://mcpcost.ulehla.dev)

mcpcost probes every remote server in the official MCP registry and records, for each one:

• whether it answers initialize and tools/list, and how fast
• the protocol version it negotiates
• whether it needs auth, which scheme (from WWW-Authenticate), and how a client gets in: OAuth with dynamic client registration, OAuth with a client id from the publisher, or a key, read from the server's public OAuth metadata
• whether it asks for payment (HTTP 402)
• how many tools it has and how many tokens their definitions cost

mcpcost: what do your own servers cost?

npx mcpcost                     # reads Claude Code, Claude Desktop, Cursor, VS Code, Windsurf and Gemini CLI configs

npx mcpcost --config .mcp.json # one file npx mcpcost --budget 30000 # exit 1 when the total is above the budget, for CI npx mcpcost --claude # exact counts from the Anthropic count_tokens endpoint (free, needs ANTHROPIC_API_KEY) npx mcpcost mcp # the same measurements as an MCP server over stdio, for your agent

It starts every configured server the way your client does, lists the tools and prints the token cost per server and in total. See packages/mcpcost.

Servers that need auth

A server that answers 401 is reachable but not measured until it gets credentials. Store them once; every later measurement of that URL uses them.

npx mcpcost auth https://mcp.linear.app/mcp                                   # OAuth: register, consent in the browser, store the tokens

npx mcpcost auth https://api.githubcopilot.com/mcp/ --header "Authorization: Bearer ghp_…" # an API key instead npx mcpcost auth --list # what is stored, without the secrets

The OAuth flow follows the MCP authorization spec: discovery, dynamic client registration, PKCE, a callback on 127.0.0.1. The consent screen is the one step that needs a person. After it, the tokens live in ~/.mcpcost/credentials.json (mode 0600, or $MCPCOST_CREDENTIALS), npx mcpcost sends them for that URL, and a refreshed token goes back to the file.

The board does the same: npm run credentials:push copies the file into the D1 table credentials; the daily run reads it before the probe, writes the refreshed tokens back after it, and marks the server "measured with credentials". A refresh token that a service revokes or lets expire needs the consent step again.

Without credentials, the board still shows a tool set for many gated servers: tool definitions do not depend on the token, so when the publisher's repository holds a package on npm or PyPI, probe/derive-packages.ts finds it and the weekly container run measures it with placeholder values. The server page then says "from the publisher's package". probe/derived-aliases.json maps the few servers whose registry entry names no repository.

In CI, as a GitHub Action

- uses: ondraulehla/mcpcost@v1

with: config: .mcp.json # one or more config files, one per line budget: 30000 # fail when the tool definitions cost more than this

The job summary gets a table with every server, its result and its cost, plus the most expensive tools. A pull request that adds a 40 000-token server fails the check. Set claude: true and put ANTHROPIC_API_KEY in env for exact counts from the free count_tokens endpoint; the default is the o200k_base estimate. Outputs: tokens, servers, over-budget.

On a pull request the action also measures the same config files on the base branch and posts one comment with the difference: servers added, removed and changed, the token delta per server, the new total and the budget verdict. The comment is updated on every push, never duplicated. The job needs pull-requests: write for it; without that permission the step warns and the check still runs. Set comment: false to turn it off. A complete workflow is in .github/examples/mcp-budget.yml.

In Claude Code, as a plugin

In a Claude Code session:

/plugin install mcpcost --marketplace ondraulehla/mcpcost

Or from the shell: claude plugin marketplace add ondraulehla/mcpcost, then claude plugin install mcpcost@mcpcost.

The plugin adds one skill, /mcpcost:measure, which runs npx mcpcost on your configs and reads the result, and the board's MCP server, so Claude can look up or probe a server before it goes into a config. What the plugin itself costs: one skill description in the context, and four tools that Claude Code defers behind tool search.

The board

mcpcost.ulehla.dev is rendered on the edge from a D1 database and refreshes every night. The only scripts it loads are a theme switch and the Cloudflare Web Analytics beacon, which counts page views without cookies.

• Overview: the share of servers that answer, token cost percentiles, and a form to check any server
• Check: probes one URL live, with the same steps as the daily run; the exact token count runs in the browser
• Statistics: results by cause, token cost and tool count percentiles, the heaviest tool sets, protocol versions, auth schemes, transports, biggest publishers
• Servers: full-text search over name, title, description and host (word prefixes, so git copilot finds the GitHub Copilot servers), filters by result, protocol and transport, seven sorts, and every filter is a plain URL you can share
• Server page: status, latency, protocol, capabilities, the most expensive tools, servers with the same tool set, history, the badge, and e-mail alerts: a mail when the server stops answering, comes back, or its tool set or token cost changes
• Compare: two to five servers side by side, status, access, tools, exact tokens, share of a 200k window, latency, with the cheapest and the spread; /compare?s= &s= , linked from every server page
• Track: a server that is not in the registry can be tracked from the check page; the daily probe then measures it under the name url/ /
• Hosts: the 500 biggest publishers with how many distinct tool sets they actually serve
• Report: one page a month, *The state of the MCP registry*, read from the daily runs, with a CC BY 4.0 dataset of every server

For agents and scripts

• JSON: /api/s/ .json, /api/lookup.json?url=… (the board's row for an endpoint URL, no probe), /api/servers.json?q=…&status=ok&sort=tokens, /api/check.json?url=…, /api/summary.json. The list API takes at most 6 requests in 10 seconds from one address; its answers are cached for three hours.
• Re-check evidence for the registry, the newest run: /data/mcpcost-evidence-latest.json.gz (the row shape of modelcontextprotocol/registry#1715, changes after each daily run), with its index /data/mcpcost-evidence-latest.index.json.
• MCP server over Streamable HTTP, no auth: https://mcpcost.ulehla.dev/mcp with the tools lookup_server, search_servers, compare_servers, check_server, registry_summary. The manifest for the registry is site/server.json.
• /llms.txt lists all of it. /tokens answers the general question: how many context tokens does an MCP server cost.

Each server on the board gets a page and a badge:

[![mcpcost](https://mcpcost.ulehla.dev/badge/io.github.you/your-server.svg)](https://mcpcost.ulehla.dev/s/io.github.you/your-server)

First full run, 2026-10-03

The registry held 38 942 latest entries. 24 294 of them have a remote endpoint, and the probe connected to all of them in 40 minutes.

Of the 12 975 servers that answered:

• the median tool set costs 1 727 tokens, the 90th percentile 7 429, the 99th 28 200
• 208 servers cost more than 20 000 tokens, 46 more than 50 000, and 3 more than a whole 200k window
• the heaviest is com.replynodes/mcp: 66 tools, 431 925 tokens
• the median server has 8 tools, the largest 1 385
• median initialize latency is 455 ms, the 90th percentile 1.5 s
• 60 % negotiate protocol 2025-11-25, 24 % still 2025-03-26, 4 % 2024-11-05
• 122 servers answer with protocol 2026-07-28, which the current TypeScript SDK rejects

The registry is lumpy. 16 161 of 16 534 hosts publish one server. Five hosts publish more than 6 000 entries between them: one Workers subdomain with 2 365 near-identical entries, a gateway with 1 716 entries of which 1 321 return a JSON-RPC error on initialize, and a host with 276 entries that all answer 402.

The monthly report and the dataset

/report/2026-10 is *The state of the MCP registry, October 2026*: the registry in numbers, what changed between the first full run and the run of 2026-10-31, token cost, auth, the lumps, protocol versions, what the registry does not catch, and the method in six sentences. The page reads only the runs table (the runs of the month up to the run day, one query) and is cached for a day, so it costs nothing on the free tier. /report lists the months; site/src/lib/reports.ts has one entry per report with the day of the run it is pinned to. The dataset that goes with it, data/mcpcost-2026-10.json.gz on the site, has one row per probed server: name, host, transport, status, HTTP status, auth scheme and kind, protocol version, tool count, the o200k estimate, the exact Claude counts and the probe time. A row's numbers are what /api/s/ .json gives for that server on that day. The licence is CC BY 4.0; the document carries the licence, the field list and a citation at the top. probe/dataset.ts writes data/latest/dataset.json and its gzip on every daily run (kept in the run artifact), and --publish site/public/data/mcpcost-YYYY-MM.json.gz copies the gzip into the site when it is under 10 MB: a static file is served before the Worker and costs no request. A bigger file would go out as a GitHub release asset instead. To publish a month: run the probe or download the run artifact into data/latest, run node --import tsx probe/dataset.ts --publish site/public/data/mcpcost-YYYY-MM.json.gz, add the month to reports.ts, write the page, and commit the file with it.

The same run goes out as re-check evidence for the registry, in the row shape agreed in modelcontextprotocol/registry#1715: entry, checked_at, check (endpoint or package), state (alive, auth, transient, dead, unknown) and evidence. probe/dataset.ts writes it daily next to the dataset, and the month's copy is /data/mcpcost-evidence-YYYY-MM.json.gz. The newest run is always at `/data/mcpcost-evidenc