What Does MCP Actually Cost in ₹? We Measured the Tool-Schema Token Tax of 5 Real MCP Servers (2026)
Short answer: connecting GitHub's official MCP server with its default tools, plus the reference Filesystem and PostgreSQL servers, adds 13,160 tokens of tool definitions to every request in our measurement, before the model reads a single line of your code. Over a 25-turn agent session, that overhead alone costs about ₹66 on Claude Sonnet 5.5 and ₹6.31 on DeepSeek V4 Flash at full input price. Prompt caching cuts it by about 85%. Sending only the seven tools the task actually needs cut the schema tokens by 90%, and a single shell-command tool needs just 58 tokens.
The Model Context Protocol (MCP) lets coding agents such as Claude Code, Cline, OpenCode and Cursor plug into GitHub, databases, browsers and your own services in a standard way. The catch is that most clients send every connected tool's full description and JSON schema with every request. You pay for those tokens on every turn, whether the agent uses the tools or not.
We measured that cost directly, on real servers, and priced it in rupees.
Key findings
- GitHub's MCP server is the heaviest. Its default toolsets expose 46 tools worth 11,363 tokens. Turning on all toolsets exposes 91 tools worth 23,595 tokens.
- A common three-server stack costs 13,160 tokens a turn. Add Microsoft's Playwright browser server and it rises to 17,219 tokens.
- The rupee cost depends mostly on the model. The same 25-turn overhead costs ₹1.66 on GPT-5 Nano and ₹132.81 on Claude Opus 5.5, a gap of 80 times.
- Caching is the biggest single fix. Tool definitions repeat on every turn, so they cache well. At a cached rate of 10% of input, the overhead falls by about 85%.
- Filtering tools is the second fix. A task-specific set of 7 tools needed 1,359 tokens, about a tenth of the full stack.
- Tool definitions are also a security surface. Every tool the model can see is a tool a prompt injection can try to call.
Why is everyone talking about MCP context bloat?
Because the people who build agents keep running into it. Anthropic's engineering team wrote that most MCP clients load all tool definitions upfront into the context window, and that once too many servers are connected, tool definitions and results can consume excessive tokens and reduce agent efficiency [1]. In a follow-up, Anthropic described a five-server setup in which GitHub alone took about 26,000 tokens, and said it had seen tool definitions consume 134,000 tokens before optimisation [2].
The wider industry has noticed too. Thoughtworks' Technology Radar (April 2026) notes that agent skills are one reason teams are becoming more cautious about defaulting to MCP, because many use cases can be handled just as well by pointing an agent at a local CLI or script [3]. The same edition recommends dynamic retrieval that loads only the necessary MCP servers to avoid unnecessary context growth [4].
What was missing was a simple, reproducible count of what popular servers actually cost, in rupees. So we made one.
How we measured the MCP token tax
This is a measurement, not an estimate. On 12 November 2026 we:
- Ran five real MCP servers locally: GitHub's official
github-mcp-serverv2.1.0 (default toolsets, then all toolsets), the reference Filesystem server (@modelcontextprotocol/server-filesystem), the reference PostgreSQL server (@modelcontextprotocol/server-postgres0.6.2, now archived) and Microsoft's Playwright server (@playwright/mcp0.0.85). - Asked each server for its tools using the standard MCP
tools/listrequest, exactly as a client does. - Converted each tool into the OpenAI function-calling format (name, description and JSON schema) that an OpenAI-compatible API receives.
- Counted tokens with the o200k tokenizer used by OpenAI's GPT-5 family, through the
gpt-tokenizerlibrary. - Priced the result using Velona's live rupee prices where listed, and Velona's published formula for the rest.
Two caveats matter. Other tokenizers, including Claude's, count differently, so treat these numbers as a close guide rather than an exact bill for every model. And some providers add their own hidden formatting around tool definitions, which can push the real count slightly higher. Anthropic's figure of about 26,000 tokens for GitHub [2] used a different server version and tokenizer, which is why it differs from ours.
How many tokens does each MCP server add?
GitHub's server adds the most by a wide margin: 11,363 tokens with default settings and 23,595 with everything enabled.
| MCP server | Tools | Tokens per request | Average per tool | Largest single tool |
|---|---|---|---|---|
| GitHub official, default toolsets | 46 | 11,363 | 247 | issue_write, 809 |
| GitHub official, all toolsets | 91 | 23,595 | 259 | projects_write, 1,577 |
| Playwright (Microsoft) | 25 | 4,061 | 162 | browser_take_screenshot, 333 |
| Filesystem (reference) | 14 | 1,764 | 126 | read_text_file, 194 |
| PostgreSQL (reference) | 1 | 37 | 37 | query, 36 |
The pattern is clear: cost scales with the number of tools and the length of their descriptions. A single read-only database tool is almost free. A server that wraps a whole product API, like GitHub, is expensive.
What a realistic stack costs per request
| Stack | Tools | Tokens per request |
|---|---|---|
| One shell-command tool (the CLI approach) | 1 | 58 |
| Lean: 7 tools picked for one coding task | 7 | 1,359 |
| Typical: GitHub default + Filesystem + PostgreSQL | 61 | 13,160 |
| Heavy: typical + Playwright | 86 | 17,219 |
| Everything: GitHub all toolsets + Filesystem + PostgreSQL + Playwright | 131 | 29,451 |
The lean set was get_file_contents, search_code and create_pull_request from GitHub, read_text_file, edit_file and write_file from Filesystem, and query from PostgreSQL. That is enough to read code, change it, check the database and open a pull request.
What does the MCP token tax cost in rupees?
For the typical three-server stack, the overhead of a 25-turn session ranges from ₹1.66 to ₹132.81 at full price, depending on the model.
The table prices only the tool definitions: 13,160 tokens sent on each of 25 turns, or 329,000 input tokens per session. The cached column assumes the first turn pays full price and the next 24 read the definitions from cache at 10% of the input price, with a 25% surcharge on the first write for Claude models.
| Model (Velona ID) | Input ₹ per 1M tokens | Overhead per session, no cache | Overhead per session, cached |
|---|---|---|---|
GPT-5 Nano (openai/gpt-5-nano) | ₹5.05 | ₹1.66 | ₹0.23 |
| Claude Haiku 5.5 | ₹10.09 | ₹3.32 | ₹0.48 |
DeepSeek V4 Flash (deepseek/deepseek-v4-flash) | ₹19.18 | ₹6.31 | ₹0.86 or less |
GPT-5 Mini (openai/gpt-5-mini) | ₹25.23 | ₹8.30 | ₹1.13 |
| GPT-5.1 | ₹126.15 | ₹41.50 | ₹5.64 |
| Claude Sonnet 5.5 | ₹201.85 | ₹66.41 | ₹9.70 |
| Claude Opus 5.5 | ₹403.68 | ₹132.81 | ₹19.39 |
GPT-5 Nano, DeepSeek V4 Flash and GPT-5 Mini use Velona's live prices on 12 November 2026, at ₹93.85 to the dollar [5, 6]. The other rows apply Velona's published formula (provider price × USD/INR × 1.005 forex buffer × 1.07 platform fee) to the provider list prices in our price per message guide. DeepSeek's cache discount is usually deeper than 10%, so its cached cost is likely lower than shown. Check each model's cached rate before you plan around it.
How much of a session is tool definitions?
A typical coding agent step sends about 30,000 tokens of code and conversation. Adding 13,160 tokens of tool definitions makes every step about 44% larger. On a heavy stack it is 57% larger. For short chat-style tasks the share is far higher, because the tools can be bigger than the conversation itself.
The same session on different stacks
| Stack | Claude Sonnet 5.5, no cache | DeepSeek V4 Flash, no cache |
|---|---|---|
| One shell tool | ₹0.29 | ₹0.03 |
| Lean (7 tools) | ₹6.86 | ₹0.65 |
| Typical (61 tools) | ₹66.41 | ₹6.31 |
| Heavy (86 tools) | ₹86.89 | ₹8.26 |
| Everything (131 tools) | ₹148.62 | ₹14.12 |
A developer running 10 such sessions a day on Claude Sonnet 5.5 with the typical stack and no caching spends about ₹664 a day on tool definitions alone, roughly ₹14,600 over 22 working days.
How do I cut MCP token costs?
Do three things, in this order: turn on caching, send fewer tools, and use a CLI where one exists.
- Make caching work. Keep tool definitions identical and in the same order on every request, and put them before anything that changes. Changing the tool list mid-session breaks the cache. On Velona, cached tokens appear in
usage.prompt_tokens_details.cached_tokensand are billed at the model's cached rate [7]. - Enable only the toolsets you need. GitHub's server lets you pick toolsets, name individual tools with
--tools, or run in--read-onlymode. Most coding tasks need a handful of GitHub tools, not 46. - Load tools on demand. Route each request to the tool groups it needs, as in the example below. Anthropic's tool search and code-execution approaches take the same idea further [1, 2].
- Prefer a CLI when one exists. Models already know
git,ghandpsql. One shell tool costs 58 tokens, though command output still counts as input when it comes back. - Cap the cost. Set a budget on the API key the agent uses, so a looping agent stops instead of draining your wallet.
Python tutorial: a lean, budget-capped tool agent on Velona
This example sends only the tools a question needs, for two Indian business tasks: checking a GSTIN and reading Razorpay webhook logs. It tracks the rupee cost of each call and stops at a session budget. The tool functions are stubs, so replace them with your real GST and Razorpay calls.
import json
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["VELONA_API_KEY"], # use a key with its own budget cap
base_url="https://velona.in/v1",
)
MODEL = "deepseek/deepseek-v4-flash"
INPUT_RS_PER_M = 19.18 # Velona price, 12 Nov 2026. Check /models for today's rate.
OUTPUT_RS_PER_M = 51.47
SESSION_BUDGET_RS = 5.00 # stop the loop before it costs more than this
# Every tool you might ever need, grouped by job. None of these is sent by default.
TOOL_GROUPS = {
"gst": [{
"type": "function",
"function": {
"name": "get_gstin_status",
"description": "Look up whether a GSTIN is active and its registered trade name.",
"parameters": {
"type": "object",
"properties": {"gstin": {"type": "string", "description": "15-character GSTIN"}},
"required": ["gstin"],
},
},
}],
"payments": [{
"type": "function",
"function": {
"name": "get_razorpay_webhook_logs",
"description": "Fetch recent Razorpay webhook deliveries for one event type.",
"parameters": {
"type": "object",
"properties": {
"event": {"type": "string", "description": "For example payment.captured"},
"limit": {"type": "integer", "default": 10},
},
"required": ["event"],
},
},
}],
}
KEYWORDS = {
"gst": ["gst", "gstin", "invoice", "tax"],
"payments": ["razorpay", "webhook", "payment", "refund", "upi"],
}
def pick_tools(question: str) -> list:
"""Send only the tool groups this question needs, not every tool you own."""
q = question.lower()
tools = []
for group, words in KEYWORDS.items():
if any(w in q for w in words):
tools.extend(TOOL_GROUPS[group])
return tools
def run_tool(name: str, args: dict) -> str:
# Replace these stubs with your real GST and Razorpay calls.
# Never return Aadhaar, PAN or full UPI IDs to the model unless the task needs them.
if name == "get_gstin_status":
return json.dumps({"gstin": args["gstin"], "status": "Active", "trade_name": "Example Traders"})
if name == "get_razorpay_webhook_logs":
return json.dumps({"event": args["event"], "deliveries": [{"status": 200, "attempts": 1}]})
return json.dumps({"error": f"unknown tool {name}"})
def cost_rs(usage) -> float:
# Upper bound: treats every prompt token as uncached.
# Cached tokens show up in usage.prompt_tokens_details.cached_tokens and cost less.
return (usage.prompt_tokens * INPUT_RS_PER_M + usage.completion_tokens * OUTPUT_RS_PER_M) / 1_000_000
def ask(question: str, max_turns: int = 8) -> str:
messages = [
{"role": "system", "content": "You are a support engineer for an Indian D2C store. Use tools only when needed."},
{"role": "user", "content": question},
]
tools = pick_tools(question) # 61 to 131 tokens of tool schema here, not 13,160
spent = 0.0
for _ in range(max_turns):
kwargs = {"model": MODEL, "messages": messages, "max_tokens": 600}
if tools:
kwargs["tools"] = tools
resp = client.chat.completions.create(**kwargs)
spent += cost_rs(resp.usage)
# Example: 1,200 prompt tokens + 180 output tokens = about 0.03 rupees on deepseek/deepseek-v4-flash
if spent > SESSION_BUDGET_RS:
return f"Stopped: session cost reached about Rs {spent:.2f}"
msg = resp.choices[0].message
if not msg.tool_calls:
print(f"Session cost: about Rs {spent:.4f}")
return msg.content
messages.append(msg)
for call in msg.tool_calls:
result = run_tool(call.function.name, json.loads(call.function.arguments or "{}"))
messages.append({"role": "tool", "tool_call_id": call.id, "content": result})
return "Stopped: too many turns"
if __name__ == "__main__":
print(ask("Is GSTIN 27AAPFU0939F1ZV active, and did the last payment.captured webhook succeed?"))
We measured the two tool groups at 61 and 72 tokens, or 131 tokens together. Keyword routing is deliberately simple. In production you can route with a cheap classifier model, or let the agent call a small "search tools" tool first, which is the idea behind Anthropic's tool search [2].
Is MCP safe? The main security risks in India
MCP itself is a protocol. The risks come from what an agent can reach and what it reads. These are the three that matter most for Indian teams.
1. Indirect prompt injection
Any text a tool returns can contain instructions. In May 2025, Invariant Labs showed that a malicious issue on a public GitHub repository could hijack an agent using GitHub's MCP server and make it leak data from the user's private repositories [8]. The researchers said the problem cannot be solved by server-side patches alone and needs architectural controls [9]. Treat issues, pull request comments, web pages and database rows written by users as untrusted input.
2. Over-privileged access
The injection only worked because the agent's token could see private repositories. Analysis of the incident points out that if the token can only reach public repositories, an attempt to read private ones fails [10]. Use fine-grained tokens scoped to one repository, GitHub's --read-only mode where you only need to read, and a read-only database role for the PostgreSQL tool.
3. Personal data leaking into prompts and logs
Tool results often carry customer data: names, phone numbers, Aadhaar or PAN numbers, GSTINs and UPI IDs. Everything a tool returns is sent to the model provider. India's Digital Personal Data Protection Rules were notified on 14 November 2025 with an 18-month phased rollout [11], and the DPDP Act allows penalties of up to ₹250 crore for failing to keep reasonable security safeguards [12]. Mask personal data before it reaches the model. Our Python guide to anonymising data before an LLM shows how, including Aadhaar and UPI ID detection.
Cap the damage with a budget per key
A looping agent can make hundreds of calls in minutes. On Velona, each API key can have an optional budget cap, and requests are rejected with HTTP 402 once the key's spend reaches it [7]. Create a separate key for each agent or MCP host, give it a small budget such as ₹50, and you limit both runaway costs and the blast radius of a leaked key.
When should I use MCP and when a plain CLI script?
Use MCP for services without a good CLI or with complex sign-in, and a CLI or script when one already exists.
| Question | MCP server | CLI or script |
|---|---|---|
| Token cost per turn | 37 to 23,595 tokens per server, every turn, in our measurement | About 58 tokens for one shell tool, plus command output |
| Setup | Install and configure each server once, then any MCP client can use it | Nothing to install if the CLI exists, but the agent needs shell access |
| Security | Scoped per tool, but every visible tool is reachable by a prompt injection | A shell is powerful, so run it in a sandbox or restricted environment |
| Best for | SaaS products without a CLI, OAuth sign-in, shared team setups | git, gh, psql, cloud CLIs, and your own repeatable scripts |
Many teams end up with both: a few lean MCP servers for services that need them, and a shell tool for everything with a CLI.
Frequently asked questions
How much does MCP add to API costs in rupees?
In our measurement, GitHub's official MCP server with default tools adds 11,363 tokens to every request. A three-server stack with Filesystem and PostgreSQL adds 13,160 tokens, which costs about ₹66 per 25-turn session on Claude Sonnet 5.5 and ₹6.31 on DeepSeek V4 Flash before caching.
How many tokens does the GitHub MCP server use?
Version 2.1.0 of GitHub's official server exposes 46 tools worth 11,363 tokens with default toolsets, and 91 tools worth 23,595 tokens with all toolsets, counted with the GPT-5 family tokenizer.
Which is the cheapest LLM for MCP tool calling in India?
On input price alone, GPT-5 Nano at ₹5.05 per million tokens and Claude Haiku 5.5 at about ₹10 are the cheapest options in our table. Price is not the only factor, because cheap models are more likely to pick the wrong tool or produce invalid arguments. Test on your own tasks, as described in our benchmark of cheap LLMs for agents.
Does prompt caching reduce MCP costs?
Yes, a lot. Tool definitions are identical on every turn, so they cache well. If cached tokens cost 10% of the normal input price, the overhead of a 25-turn session falls by about 85%. Keep the tool list stable during a session, or the cache breaks.
How do I connect Cline or Claude Code to Velona and pay with UPI?
Velona is OpenAI-compatible, so any agent that accepts a custom OpenAI base URL can use https://velona.in/v1 with a Velona API key, while its MCP servers keep running locally as before. Top up from ₹10 with UPI. Our guide to using Velona with coding agents has the setup for each tool.
Limits of this measurement
- One tokenizer. We counted with o200k. Claude, DeepSeek and Gemini tokenizers give somewhat different counts.
- Definitions only. We measured tool definitions, not tool results. Large results, such as a whole file or a page of search hits, can cost more than the definitions.
- Accuracy not measured. We did not test which models choose tools correctly. Fewer tools usually help accuracy, but measure it on your own tasks.
- Versions change. MCP servers add and rewrite tools often. Rerun the count when you upgrade.
- Cache assumptions. The cached column assumes a 10% cached rate and a perfect cache hit after turn one. Real hit rates are lower if the prompt prefix changes.
Reproduce our count
Ask any MCP server for its tools, then count them. This Node.js snippet counts a saved tools/list result.
// npm install gpt-tokenizer
import fs from 'node:fs';
import { encode } from 'gpt-tokenizer/encoding/o200k_base';
const tools = JSON.parse(fs.readFileSync('tools.json', 'utf8')); // the "tools" array from tools/list
const asFunctions = tools.map(t => ({
type: 'function',
function: { name: t.name, description: t.description || '', parameters: t.inputSchema },
}));
console.log(tools.length, 'tools,', encode(JSON.stringify(asFunctions)).length, 'tokens');
Try it on Velona
Velona gives you one OpenAI-compatible API key for GPT, Claude, DeepSeek and 300+ other models, prices every request in rupees, shows cached tokens in each response, and lets you put a budget cap on each key. Top up from ₹10 with GPay, PhonePe or Paytm, with no international card needed.
Create a free Velona account, then make a budget-capped key for your MCP agent.
Disclosure: Velona publishes this measurement and sells access to these models. If your card already works with a provider, paying them directly avoids Velona's 7% platform fee.
Last measured: 12 November 2026.
References
- Code execution with MCP: building more efficient agents, Anthropic Engineering
- Introducing advanced tool use, Anthropic Engineering
- Technology Radar, Volume 34: Techniques (Agent Skills), Thoughtworks, April 2026
- Technology Radar, Volume 34: Techniques (context engineering and dynamic retrieval), Thoughtworks, April 2026
- DeepSeek V4 Flash price, Velona, refreshed 12 November 2026
- Cheapest models, Velona, 12 November 2026
- Velona API documentation: key budgets, prompt caching and tool calling, Velona
- GitHub MCP exploited: accessing private repositories via MCP, Invariant Labs, 26 May 2025
- AI GitHub agents: how an issue leaked private repos, UpGuard
- Pulling on the thread of MCP risks, Formal
- DPDP Rules, 2025 notified, Press Information Bureau, 17 November 2025
- Digital Personal Data Protection Rules, 2025, Vikaspedia
- github-mcp-server, GitHub (v2.1.0 measured)
- @modelcontextprotocol/server-filesystem, npm
- @modelcontextprotocol/server-postgres, npm (0.6.2, archived)
- @playwright/mcp, npm (0.0.85 measured)
- gpt-tokenizer, npm
Related: Context engineering for AI coding agents, what an AI coding agent really costs in India and Cline vs Aider vs OpenCode vs OpenClaw.