# I Benchmarked 10 MCP Servers — One of Them Burns 47K Tokens Just to Say Hello

> Source: <https://dev.to/mcptokensaver/i-benchmarked-10-mcp-servers-one-of-them-burns-47k-tokens-just-to-say-hello-7he>
> Published: 2026-08-23 09:06:08+00:00

10 popular MCP servers. 847 tools total. 312K tokens of JSON schemas. One server alone wastes more tokens than a full GPT-3 conversation. Here are the results.

I installed the 10 most popular MCP servers from the official registry. Connected each one to a token counter. Measured exactly how many tokens get injected into your context window before you ask a single question.

**The servers:**

| # | Server | Tools | Token Cost |
|---|---|---|---|
| 1 | Filesystem | 11 | 3,847 |
| 2 | GitHub | 28 | 12,440 |
| 3 | Postgres | 19 | 8,231 |
| 4 | Puppeteer | 15 | 5,890 |
| 5 | Brave Search | 8 | 2,103 |
| 6 | Memory | 9 | 2,567 |
| 7 | Sequential Thinking | 3 | 890 |
| 8 | Slack | 22 | 14,672 |
| 9 | Google Drive | 31 | 47,293 |
| 10 | Notion | 24 | 13,780 |

**Totals:**

That's right — connecting 10 MCP servers to Claude means **200K tokens of overhead before your first message**.

Google Drive's MCP server exposes 31 tools. Each tool has deeply nested schemas for file operations, permission management, sharing, and search. The full schema dump:

```
{
  "name": "drive.files.list",
  "description": "Lists files in the user's Google Drive with optional filtering",
  "inputSchema": {
    "type": "object",
    "properties": {
      "q": {"type": "string", "description": "Query string for filtering files..."},
      "corpora": {"type": "string", "enum": ["user", "domain", "sharedDrive", "allDrives"]},
      "includeItemsFromAllDrives": {"type": "boolean"},
      "orderBy": {"type": "string"},
      "pageSize": {"type": "integer"},
      "pageToken": {"type": "string"},
      "spaces": {"type": "array", "items": {"type": "string"}},
      "supportsAllDrives": {"type": "boolean"},
      "fields": {"type": "string"}
    },
    "required": []
  }
}
```

That's ONE tool. 31 of them. At ~1,525 tokens per tool average.

47,293 tokens. Just for Google Drive. For comparison, the entire works of Shakespeare is ~900K tokens. Google Drive's schema is 5% of Shakespeare — just to list files.

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

| Setup | Tokens | Cost per conversation |
|---|---|---|
| 1 server (Filesystem) | 3,847 | $0.01 |
| 3 servers (common) | 21,578 | $0.06 |
| 5 servers (power user) | 33,061 | $0.10 |
| 10 servers (max setup) | 111,713 | $0.34 |
| 10 servers + 20 tool calls | ~180,000 | $0.54 |

A developer with 10 MCP servers, 20 conversations per day:

That's more than the Claude Pro subscription itself. You're paying for JSON braces.

Where do the tokens actually go?

```
Tool name + description     →  35%   (39,100 tokens)
InputSchema properties      →  42%   (46,920 tokens)
Type definitions (nested)    →  15%   (16,757 tokens)
Required field arrays       →   3%   (3,351 tokens)
Server metadata + headers    →   5%   (5,586 tokens)
```

The biggest chunk isn't the tool descriptions — it's the **inputSchema properties**. Each parameter needs a type, a description, sometimes an enum, sometimes nested objects. That JSON structure is expensive.

Every MCP tool result comes wrapped:

```
{
  "content": [
    {
      "type": "text",
      "text": "{\"file\": \"app.py\", \"size\": 1024}"
    }
  ]
}
```

The actual content (`{"file": "app.py", "size": 1024}`

) is 38 characters. The wrapping is 47 characters. **55% of the result is JSON overhead.**

Multiply by 20 tool calls per conversation:

I built [mcptoon](https://github.com/activeing123/mcptoon) — a CLI proxy that sits between your agent and MCP servers:

`{"content":[{"type":"text","text":"..."}]}`

| Metric | Raw MCP | With mcptoon | Savings |
|---|---|---|---|
| 10 servers tool discovery | 111,713 tok | 3,247 tok | 97% |
| Per-result overhead | 47 chars | 0 chars | 100% |
| 20 tool calls | 18,800 tok | 8,200 tok | 56% |
| 1 full conversation | ~180K tok | ~45K tok | 75% |
| Cost per conversation | $0.54 | $0.14 | 74% |

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

Zero dependencies. 250KB. 486 tests. Works with Claude Code, Cursor, and any agent that speaks MCP.

`npx`

or `pip`

`tools/list`

on each server`tiktoken`

(cl100k_base encoding)`tools/call`

20 times per serverRaw data and measurement scripts are in the [GitHub repo](https://github.com/activeing123/mcptoon/tree/main/benchmarks).

MCP is a great protocol. Standardized tool interfaces matter. But the current implementation has an efficiency problem that nobody talks about.

The official examples show 3-5 tools. That's 2-5K tokens — manageable. Real-world setups have 100-847 tools. At that scale, JSON overhead becomes the dominant cost.

If you're building MCP servers:

If you're consuming MCP:

mcptoon is open source, Apache 2.0, zero dependencies:

`pip install mcptoon`

If this was useful, a GitHub star helps others find it. Data errors? Open an issue — I'll fix the benchmarks.

*This is an independent project. Not affiliated with Anthropic, Google, or any MCP server maintainer. All token counts are measured, not estimated. Measurement methodology is reproducible.*