Forecast the real token spend behind every tool call, resource read, and prompt your Model Context Protocol server exposes — before the host model quietly burns through a five-figure month on schema overhead nobody costed up front. Models cross-mapped against GPT-5, Claude 4.6, Gemini 3, DeepSeek, and 25+ more.
Model Context Protocol turned 2025 into the year of the tool. By mid-2026 the registry of public MCP servers cleared 4,000 entries and almost every serious AI workflow runs through at least three of them. The protocol is brilliant. The cost model underneath it is invisible — and that is exactly why MCP server developers ship into production with no real number on what their server costs the people using it.
The trap is structural. Your server does not bill tokens; the host model on the other end does. Every tool you expose injects its full JSON schema into the host's system prompt at connection time. Every parameter description, every enum, every resource manifest gets serialized in. The host model carries that overhead on every single turn, whether the tool fires or not. A chatty server with 30 tools and verbose descriptions can quietly add 8,000+ tokens of pure schema to each user message before a single tool call happens.
This calculator is the cost model your MCP server design doc is missing. Plug in the number of tools, average schema size, expected invocation rate, and typical resource payload, and it cross-multiplies against the published rates for every host model that speaks MCP. The output is a defensible per-session and per-tool-call cost table that drops into a README, an ADR, or a pricing page for a hosted MCP service.
The biggest line on most MCP servers' actual cost contribution is not the tool calls — it is the schema your server ships to the host on every turn. The calculator models the static overhead explicitly: tool count, average description length, parameter complexity, and resource manifest size. The output is the per-turn fixed cost your server adds before any tool fires. For a 40-tool server with verbose descriptions and three exposed resources, the static overhead alone is frequently $0.04-$0.18 per user turn against a flagship host model.
When a tool actually fires, the cost is the prompt expansion (input context), the model's reasoning trace before the call, and the tool result you return that flows back into context for the next turn. The calculator separates these three components so the per-invocation number is realistic rather than a single-shot completion estimate. Multi-step agent loops that chain several of your tools together get a multiplier so the per-task number reflects how Claude or GPT-5 actually consume the server in practice.
Should your server return the full 200KB file, a 4KB summary with a pagination cursor, or a 500-byte pointer the host model can dereference on demand? The calculator turns that design decision into a number. A resource that returns 200KB will balloon into roughly 50,000 tokens of carried context the host model lugs around for the rest of the session. Comparing the three payload shapes side by side usually settles the design argument inside ten minutes.
If you ship a server that targets multiple hosts — Claude Desktop, Cursor, Windsurf, custom Anthropic API clients, GPT-5 with MCP, Gemini 3 with MCP — the cost behavior differs sharply between hosts. Caching policies, prompt caching discounts, and tool-use billing semantics all shift the per-session number. The calculator covers each host's published pricing so the cost section of your README can quote real numbers for every supported runtime rather than just the one you happened to develop against.
If your MCP server is going to be a hosted service rather than a self-installed binary, the per-tool-call and per-session token math becomes the foundation of your pricing page. The calculator's output drops directly into the COGS row of a unit-economics spreadsheet so subscription tiers, included-call quotas, and overage rates have margin baked in from day one rather than reverse-engineered from the first month's bill.
Three failure modes show up repeatedly in production MCP servers, and all three are visible in the calculator before the server ships:
For the canonical protocol spec see the Model Context Protocol documentation. Per-token rates live on the OpenAI pricing page and the Anthropic Claude pricing page. The official MCP servers repo is also a good reference for tool-description style that does not over-bill on schema overhead.
To make the numbers concrete, here is how a typical mid-sized MCP server — 18 tools, 5 resources, average 35-word tool descriptions, two paged result endpoints — lands when run through the calculator across a typical 90-minute Claude Desktop session with 22 user turns:
| Host model | Per-session cost (this server) | Of which is schema overhead |
|---|---|---|
| Claude Sonnet 4.6 (Desktop) | $0.92 | $0.38 (41%) |
| Claude Opus 4.6 | $3.10 | $1.28 (41%) |
| GPT-5 with MCP | $1.45 | $0.58 (40%) |
| GPT-5 mini with MCP | $0.18 | $0.07 (39%) |
| Gemini 3 with MCP | $0.71 | $0.29 (41%) |
Numbers above are illustrative. Plug your real server shape into the live tool to get a current comparison against published rates. Notice the schema-overhead share: roughly 40% of the per-session cost across every host model is pure tool-description overhead the user pays whether tools fire or not. That is the line most worth optimizing — a 30% reduction in description verbosity is usually achievable in an afternoon and propagates to every session for the lifetime of the server.
The token math is one piece of shipping a credible MCP server. The other pieces — marketing the server, documenting its contract, declaring AI involvement in its outputs, and signaling crawler intent on its docs site — the TinyTools suite covers without adding seats to your toolchain:
The pattern is the same across all of them: free, single-purpose, no signup. For broader reading on MCP server economics and protocol design, the Model Context Protocol GitHub org publishes the reference servers and SDKs, and Anthropic's news archive tracks protocol-level changes that affect how host models bill the connections.
Yes. Static schema overhead, per-invocation input/output costs, tool-result echo back into context, and host-side prompt caching discounts where the host publishes them are all modeled. The output is calibrated to the actual billing patterns of MCP-aware clients rather than treating each tool call as an isolated completion.
Yes. Set the expected sessions per user per month and the average session shape, and the calculator produces a per-user cost number you can use as the COGS line for each subscription tier. Most hosted MCP services land on a 65-80% gross margin once they price overage above the included-call quota correctly.
Yes. GPT-5 mini, Claude Haiku 4.5, Gemini 3 Flash, and DeepSeek's lineup are all included. For MCP servers where the host model is doing light reasoning over tool results, the mini tier is frequently the right default and runs 6-15x cheaper than the flagship.
The calculator reads from a price table updated whenever a major provider publishes a change. Expect 1-3 day lag on smaller providers and near-real-time on the top five.
Yes — the cost breakdown is designed to be a defensible artifact in a README's "what does this cost?" section. Shipping the math up front is the right call for trust, and the table format pastes cleanly into Markdown.