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.

The experiment

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.

What MCP tool schemas actually look like

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:

• Server status messages (~200 tokens each)
• Tool listing headers (~50 tokens per server)
• Error handling schemas (~100 tokens per tool)

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

The result wrapping problem

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.

The cost in dollars

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

A developer having 20 conversations per day with MCP:

• Daily cost: $7.80 - $15.00
• Monthly cost: $156 - $300
• Annual cost: $1,872 - $3,600

That's not counting output tokens.

I built a tool to fix this

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

• Caches tool schemas - injects them once, not per conversation
• Compresses results - strips JSON wrapping, returns clean text
• Uses TOON format - Token-Optimized Object Notation

What TOON looks like

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.

Real-world results

How to use it

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.

The bigger picture

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:

• Keep tool descriptions short
• Minimize schema complexity
• Don't nest JSON in results
• Consider token cost as a first-class concern

If you're consuming MCP tools:

• Use a proxy like mcptoon to compress
• Cache schemas across conversations
• Limit the number of servers you connect

Show me the code

mcptoon is open source, Apache 2.0, zero dependencies:

• GitHub: https://github.com/activeing123/mcptoon
• PyPI: pip install mcptoon
• Size: 250KB
• Dependencies: 0
• Tests: 486

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.