An MCP server advertises its tools to the model by injecting their JSON schemas into the context window — and it does this on every single request, whether or not any tool is actually called. That's a fixed tax you pay before the conversation starts. Nobody publishes what that tax actually is, so we measured it. Using our open-source token-budget linter tooltax, we scored 20 popular MCP servers on the exact tokens their tool definitions consume.
The short version: the servers we measured range from 237 tokens (Fetch, one tool) to 17,430 tokens (Notion, 24 tools). Across all 20 there are 290 tools totalling 73,323 tokens — meaning if you loaded every one of these servers at once, 36.7% of a 200,000-token context window would be gone before the user typed anything. The numbers below are real measurements, not estimates; tooltax never reports a figure it didn't measure. Data snapshot: 24 July 2026, tokenizer `o200k_base`.
Why MCP tool schemas are a hidden cost
When you connect an MCP server to a client like Claude or ChatGPT, the model has to know what tools exist and how to call them. That knowledge is the tool schema — a name, a description, and a typed parameter spec for each tool — and it's placed into context so the model can reason about it on every turn. Three consequences follow, and all three are easy to miss:
- You pay whether or not the tool is used. A server with 17k tokens of schemas costs 17k tokens on a turn where the model calls nothing. The tax is for *availability*, not usage.
- It compounds across servers. Connect five servers and their schemas stack. Our 20-server total — 36.7% of a 200k window — is what "just install a few MCP servers" quietly does to your budget.
- It costs latency and money, every request. Those tokens are processed on each turn, so they show up in both your bill and your time-to-first-token, forever, not once.
The data: 20 MCP servers by token cost
Every row is a live measurement of the server's advertised tool schemas, lowest cost first. "Context @200k" is the share of a 200,000-token window the schemas alone consume. The full, continuously-updated list — including servers still pending a clean fetch — lives in the tooltax leaderboard.
| Server | Tools | Tokens | Tokens/tool | Context @200k |
|---|---|---|---|---|
| Fetch | 1 | 237 | 237 | 0.1% |
| Time | 2 | 237 | 118.5 | 0.1% |
| Exa | 2 | 429 | 214.5 | 0.2% |
| Puppeteer (archived) | 7 | 543 | 77.6 | 0.3% |
| Sequential Thinking | 1 | 953 | 953 | 0.5% |
| Context7 | 2 | 977 | 488.5 | 0.5% |
| Git | 12 | 1,129 | 94.1 | 0.6% |
| 21st.dev Magic | 4 | 1,142 | 285.5 | 0.6% |
| Everything | 13 | 1,171 | 90.1 | 0.6% |
| Tavily | 5 | 1,668 | 333.6 | 0.8% |
| Memory | 9 | 2,028 | 225.3 | 1.0% |
| Filesystem | 14 | 2,383 | 170.2 | 1.2% |
| Playwright (ExecuteAutomation) | 33 | 2,956 | 89.6 | 1.5% |
| Playwright (Microsoft) | 24 | 3,423 | 142.6 | 1.7% |
| GitHub (archived) | 26 | 3,588 | 138.0 | 1.8% |
| Heroku | 33 | 4,770 | 144.5 | 2.4% |
| Kubernetes | 23 | 5,066 | 220.3 | 2.5% |
| MongoDB | 29 | 6,375 | 219.8 | 3.2% |
| Firecrawl | 26 | 16,818 | 646.8 | 8.4% |
| Notion | 24 | 17,430 | 726.3 | 8.7% |
MCP tool-schema token cost, measured with tooltax (o200k_base tokenizer, snapshot 24 Jul 2026). Lower is better.
What the numbers actually say
The most useful finding is what does *not* drive the cost. Token cost tracks how verbosely each tool is described far more than how many tools a server has — so the fix is almost always writing, not cutting features.
- Tool count is a weak predictor. Playwright (ExecuteAutomation) exposes 33 tools for 2,956 tokens — about 90 tokens each. Notion exposes fewer tools (24) for nearly six times the total, at 726 tokens each. A lean 33-tool server can cost a fraction of a verbose 24-tool one.
- Description verbosity dominates. The two most expensive servers, Notion (726 tokens/tool) and Firecrawl (647 tokens/tool), pay for long prose descriptions and richly-typed parameters. That prose is loaded on every request, used or not.
- The cheap servers are cheap on purpose. Fetch (237 tokens, one tool) and Git (94 tokens/tool across 12 tools) show that tight, well-scoped descriptions keep a capable server nearly free in context terms.
- The real risk is stacking. No single server here is alarming on its own. The danger is the additive 36.7% you reach by connecting a handful without watching the budget — context you can no longer spend on the actual task.
How to cut your MCP token cost
If you build or run MCP servers, the schema budget is one of the few AI costs you fully control. In order of impact:
- Measure it first. You can't manage what you don't see. Run tooltax against your server (or any you're about to install) to get the exact number before it silently taxes every request.
- Tighten descriptions. Most schema bloat is prose written for a human, not a model. A crisp one-line description with a good name usually beats a paragraph — and costs a tenth of the tokens.
- Expose fewer tools per connection. Ship focused servers, or let clients enable only the tools a given workflow needs, rather than loading a 33-tool kitchen sink for a job that uses two.
- Trim parameter schemas. Deeply nested, exhaustively-typed parameters are expensive. Keep them as flat and as necessary as the tool genuinely requires.
- Budget across servers, not per server. The number that matters is the total loaded into a given client, because that's what's subtracted from every request. Watch the sum.
Methodology
Every figure here is produced by tooltax, our open-source, MIT-licensed linter. For each server, tooltax fetches the live tool schemas the server advertises over MCP, serialises them the way a client sends them to the model, and counts the tokens with the `o200k_base` tokenizer (the encoding used by current OpenAI models); "Context @200k" divides that by a 200,000-token window.
Two honesty notes. First, exact token counts vary slightly by model and tokenizer — Claude and GPT tokenize differently — so treat these as accurate relative rankings and close absolute estimates, not to-the-token universal truth. Second, tooltax never publishes a score it couldn't measure: servers whose schema couldn't be fetched cleanly in a run are listed as *pending* with no number rather than guessed at. The dataset is reproducible — run tooltax yourself against the same server registry and you'll get these numbers.
Building on MCP?
We measured this because we build MCP servers and kept seeing the same avoidable cost — a server that works perfectly in a demo and quietly taxes 8% of the context window on every production request. Lean schemas, real authentication, and defences against MCP-specific attacks are what separate a demo from something you can depend on; we wrote up the rest in how to choose an MCP server development company.
If you're building on MCP and want it done so it's fast, secure, and cheap to run, tell us what you want to expose to a model and we'll scope it honestly — or just run tooltax on what you've got and see where your budget is going.