MCP Cost: What Model Context Protocol Servers Add in Tokens

MCP itself costs nothing. The Model Context Protocol, its SDKs and most community servers are free. What you pay for is tokens: every connected server's tool definitions are injected into every request, and a server with around 25 tools adds an estimated 3,000 to 8,000 tokens of schema. Ten servers is roughly 50,000 tokens per step. On the reference 12-step run that lifts Claude Sonnet 5 from $0.39 to about $1.53, GPT-5.4 from $0.50 to about $1.93, Gemini 3.8 Flash from $0.15 to about $0.58 and DeepSeek V4 Flash from under $0.01 to about $0.04.

Those figures are before prompt caching. With caching the Sonnet 5 run comes back to roughly $0.36. The rest of this article shows where the numbers come from and which levers move them.

An MCP client calls each server's tools/list at start-up and converts the result into the model vendor's tool format. Each tool becomes a name, a description and a JSON schema for its arguments. That block is sent with every model call, whether the model uses the tool or not, because the model cannot call what it cannot see.

Two things make this expensive rather than merely untidy. First, the schemas are verbose: a database server that documents every column, or a browser server with twenty navigation actions, can be several thousand tokens on its own. Second, an agent loop re-sends the whole context on every step, so the schema cost is paid once per step, not once per run. The mechanics of that re-send are covered in [how much an AI agent costs to run](/guides/how-much-does-an-ai-agent-cost-to-run).

Do not estimate. Ask the vendor's token counter for the request with and without the tool list; the difference is the schema overhead for that server. This TypeScript snippet pulls a server's tools over MCP, converts them to Anthropic's tool shape and prices the overhead per step on Claude Sonnet 5:

import Anthropic from "@anthropic-ai/sdk";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";

const anthropic = new Anthropic();

export async function toolListCost(mcp: Client, system: string) {
  const { tools } = await mcp.listTools();
  const anthropicTools: Anthropic.Tool[] = tools.map((t) => ({
    name: t.name,
    description: t.description ?? "",
    input_schema: t.inputSchema as Anthropic.Tool["input_schema"],
  }));
  const probe = [{ role: "user" as const, content: "ping" }];
  const withTools = await anthropic.messages.countTokens({
    model: "claude-sonnet-5", system, tools: anthropicTools, messages: probe,
  });
  const noTools = await anthropic.messages.countTokens({
    model: "claude-sonnet-5", system, messages: probe,
  });
  const schemaTokens = withTools.input_tokens - noTools.input_tokens;
  // Sonnet 5: $2 per 1M uncached, roughly $0.20 per 1M as a cache read
  const perStepUSD = (schemaTokens * 2) / 1_000_000;
  return { schemaTokens, perStepUSD, perStepCachedUSD: perStepUSD / 10 };
}

Run it once per server and keep the numbers in the agent's config. A server that costs 6,000 tokens per step and is called on 2% of runs is a strong candidate for removal.

Schemas are the fixed cost. Tool results are the variable one, and they are often larger. A file read, a web page or a SQL result can be 5,000 to 20,000 tokens. Once a result enters the conversation, every later step re-sends it.

Take the reference trace (1,500-token results) and replace four of the twelve results with 15,000-token SQL dumps at steps 2, 4, 6 and 8. Each dump adds 13,500 tokens over the baseline and is re-sent on every subsequent step: 10 + 8 + 6 + 4 = 28 re-sends, plus the four original sends, 32 in total. That is 13,500 × 32 = 432,000 extra input tokens, or about $0.86 on Sonnet 5 at $2 per million, for four queries that could have returned a row count and the first twenty rows.

The reference run is a 4,000-token prefix (1,500 system, 2,500 of hand-written tools), a 500-token task, and twelve steps that each add a 300-token tool call and a 1,500-token result. Uncached input across the run is 172,800 tokens; output is 4,800.

Swap the 2,500 tokens of hand-written tools for ten MCP servers at roughly 5,000 tokens each. The prefix becomes 52,000 tokens and step 12 alone sends 52,000 + 11 × 1,800 = 71,800 tokens. Input across the run is 12 × 52,000 + 118,800 = 742,800 tokens, 4.3 times the baseline for exactly the same work.

The cached column assumes 71,800 tokens written once (the prefix at step 1 plus each step's 1,800 new tokens) and 671,000 read from cache. The write premium is Anthropic's roughly 125%; OpenAI has none. Everything in that column follows the rules in [prompt caching for AI agents](/guides/prompt-caching-for-ai-agents).

• Fewer servers per agent. Give each agent the two or three servers its task needs. Three servers instead of ten drops the prefix from 52,000 to 17,000 tokens and the uncached Sonnet 5 run from $1.53 to about $0.69 (322,800 × $2 + $0.048).
• Tool filtering and lazy loading. The OpenAI Agents SDK and the Claude Agent SDK both accept an allow-list of tool names per MCP server, so a 25-tool server can present 4. Anthropic's API also offers a tool-search tool with defer_loading on the rest, so schemas are fetched into context only when the model searches for them. Either way the model never pays for a schema it will not call.
• Truncate results at source. Cap every tool result at a few thousand tokens and return a hint such as total rows, a byte offset or a "call again with page=2". Four capped SQL results save the 432,000 tokens computed above.
• Cache the prefix. Tool definitions render first and never change, so they are the easiest tokens in the request to cache. One breakpoint on the last tool on Anthropic, or simply a stable tool order on OpenAI, converts the schema cost into cache reads at roughly 10% of list.

Do all four. They multiply rather than add: three filtered servers with truncated results and a warm cache is a run where the MCP overhead is under a cent.

For an agent whose MCP tools are well specified and whose task is clear, DeepSeek V4 Flash ($0.05 / $0.16) runs the ten-server trace for about $0.04 and Gemini 3.8 Flash for about $0.58. In our experience both make correct structured tool calls when the schema is unambiguous. Compare the wider field in [cheapest LLM for AI agents](/guides/cheapest-llm-for-ai-agents) and the [model catalogue](/models).

Pay for Claude Sonnet 5 or GPT-5.4 when the agent must choose between many similar tools (ten servers often means several overlapping "search" and "read" tools) or recover from tool errors without a human. A cheap model that picks the wrong server and loops re-sends the 52,000-token prefix on every wasted step, and at that point the flagship is cheaper per completed task. Claude Opus 5 at $5 / $25 is rarely justified for tool plumbing; save it for the planning step, as described in [multi-agent system cost](/guides/multi-agent-system-cost).

Large tool lists make runaway loops expensive faster, so the guardrails matter more, not less:

• max_tokens on every call, sized for a tool call, not an essay
• A step limit per run; a ten-server agent that has not finished in 20 steps is usually confused, not thorough
• A stop condition the model can trigger explicitly
• A per-run dollar cap computed from usage on each response, including cache read and write tokens, that aborts the loop when exceeded

The [token budget guardrails](/guides/ai-agent-token-budget-guardrails) article has the runner code. For per-vendor specifics on how tool definitions are billed, see [Claude agent API cost](/guides/claude-agent-api-cost), and use the [calculator](/calculator) to price your own server list once you have measured it.