Real Token Cost of MCP: 91K Tokens of JSON

255 MCP tools. 91,000 tokens of JSON schemas. Before you ask a single question. Here's what I found and how I fixed it.

I connected Claude Code to 5 MCP servers. File system, GitHub, Postgres, Puppeteer, and a custom search tool. Then I counted every token that flowed through the system.

The numbers:

That's a GPT-4 conversation where 60% of your tokens are JSON braces, brackets, and repeated schema definitions.

Let me show you what I mean.

Here's ONE tool definition from a typical MCP server:

{
  "name": "search_files",
  "description": "Search for files matching a pattern in a given directory",
  "inputSchema": {
    "type": "object",
    "properties": {
      "pattern": {
        "type": "string",
        "description": "Glob pattern to match files"
      },
      "path": {
        "type": "string",
        "description": "Root directory to search in"
      },
      "case_sensitive": {
        "type": "boolean",
        "description": "Whether to perform case-sensitive matching",
        "default": false
      }
    },
    "required": ["pattern"]
  }
}

That's 347 characters, ~87 tokens. For ONE tool.

A typical MCP server exposes 30-60 tools. Five servers = 255 tools. That's 22,185 tokens just for tool definitions.

But it gets worse. The model also gets:

Realistic total: 91K tokens for a 5-server setup.

Every MCP tool result comes wrapped in this structure:

{
  "content": [
    {
      "type": "text",
      "text": "The actual content you care about"
    }
  ]
}

That's 47 characters of JSON overhead per result. For a 100-character result, 32% of tokens are pure overhead.

If the result is structured data:

{
  "content": [
    {
      "type": "text",
      "text": "{\"file\": \"app.py\", \"matches\": [\"line 42\", \"line 87\"]}"
    }
  ]
}

Now you have JSON inside JSON. The inner JSON is stringified. The outer JSON wraps it. Double encoding. Double parsing. Double tokens.

At Claude 3.5 Sonnet pricing ($3/M input tokens):

A developer having 20 conversations per day with MCP:

That's not counting output tokens.

mcptoon — a CLI that sits between your AI agent and MCP servers. It:

Instead of:

{"name": "search_files", "inputSchema": {"type": "object", "properties": {"pattern": {"type": "string"}, "path": {"type": "string"}}, "required": ["pattern"]}}

TOON outputs:

name search_files
pattern string required
path string

That's 62 tokens instead of 2,034 for all 255 tools. 97% reduction.

pip install mcptoon

Then in your Claude Code config:

{
  "mcpServers": {
    "filesystem": {
      "command": "mcptoon",
      "args": ["serve", "--stdio", "npx", "@anthropic/mcp-filesystem"]
    }
  }
}

Or if you use Cursor:

mcptoon add filesystem --stdio npx @anthropic/mcp-filesystem
mcptoon list

Zero dependencies. 250KB. Works with any agent that runs shell commands.

MCP is a great protocol. The idea of standardizing tool interfaces across AI agents is important. But the implementation has a token efficiency problem that nobody talks about.

When Anthropic announced MCP, the examples showed 3-5 tools. That's manageable. But real-world setups have 50-255 tools. At that scale, the JSON overhead becomes the dominant cost.

If you're building MCP servers:

If you're consuming MCP tools:

mcptoon is open source, Apache 2.0, zero dependencies:

pip install mcptoon

The entire codebase is readable in an afternoon. No transitive dependencies to audit. No supply chain risk.

If this was useful, a GitHub star helps others find it. Questions? I'm in the comments.

This is an independent project. Not affiliated with Anthropic or the MCP team. All token counts are measured, not estimated.