MCP Pricing & Token Economics: free vs paid servers, the real cost of integrations

Module: Technical tools | Time: ~25 min theory + 20 min calculations

The gist

Calling MCP "free" is only half the truth. The protocol itself is open, the servers download for $0, and the config goes into .mcp.json with no subscription. But under the hood of every MCP there's a real service, and you pay that service, not Anthropic.

The Stripe MCP is free. Stripe takes 2.9% + $0.30 on every transaction (US, online card; the rate is different in other countries). The Notion MCP is free. The full Notion AI comes with Notion's paid Business plan, billed per member. The Slack MCP is free. Slack Pro is a paid per-user subscription.

The numbers in this lesson are as of October 2026, from the services' official pages. Where a price isn't verified, the lesson points you to the service's pricing page instead. Prices change, so before you decide, open the pricing page; for a summary of Claude's models and plans, see What's current. The amounts in the stack examples are an illustration of how to do the math, not a price list.

This lesson is about the real cost of an MCP stack. In 25 minutes you'll be able to spot the hidden price tag behind every "Install MCP" button, and the bills at the end of the month won't surprise you.

🎨 Picture this: MCP is like a plug adapter. The adapter itself costs next to nothing, a couple of dollars at the hardware store. But for the electricity flowing through it, you pay the power company's full rate. The adapter is free; the electric bill still comes. Not everything that's free to download is free to use.

🎯 Decision tree: should you connect this MCP

The main question of this lesson is not "which MCP is best" but "is it worth connecting this particular MCP at all, once you count the hidden cost."

Connect an MCP if:

• ✓ It gives you a capability that base Claude Code doesn't have
• ✓ You'll use it more than 3 times a week (otherwise the context overhead doesn't pay off)
• ✓ The free tier covers your real usage (or the paid service is worth what it costs)
• ✓ Your stack has no more than 7 active MCPs in total (context discipline)
• ✓ You understand the pricing under the hood (no surprise bills)

DON'T connect it if:

• ✗ You're adding it "just in case": context rot guaranteed
• ✗ The paid service under the hood costs more than you'll save
• ✗ You'll blow through the free tier limit within a week
• ✗ You'll rarely use it (once a month doesn't justify the overhead)

Default to a minimal stack. Add something only when you've clearly hit the limits of what Claude Code can do on its own.

🎨 Picture this: the fridge in a rental apartment. You could stock it with everything in the grocery store "just in case." Half of it goes bad, and you forget about the rest. Better to keep 7–10 things you know you'll eat this week. Same with MCPs.

Key ideas

• MCP server: a program that implements the Model Context Protocol and gives Claude Code access to an outside service
• Category A, fully free: the MCP works with local resources or open source, no outside subscriptions
• Category B, free wrapper / paid service: the MCP is free, but the service it wraps costs money (Stripe, Notion)
• Category C, paid MCP: the MCP itself needs an API key for a paid service (Tavily, Firecrawl, Context7)
• Token economics: every MCP server "eats" context tokens: tool descriptions (in newer versions of Claude Code these load on demand) and the results of every call
• Context rot: the decline in an LLM's reasoning quality as its context fills up (see the lesson Context Rot and 28 techniques to fight degradation)
• Free tier: a service's free allowance (Brave Search, for example, gives a monthly free credit); once you go over, you get billed
• Hidden cost: costs you don't see on the MCP's page (time for setup, maintenance, debugging)

The theory

3 pricing categories of MCP

MCP servers in 2026 fall into three clear groups. Knowing the category is your first filter before connecting one.

Category A: Fully free

The MCP works either with local resources or with open source infrastructure. No subscriptions, no API keys, no limits other than the power of your computer.

Top 6 free MCPs:

Use: personal scripts, local development, notes. It never leaves your computer, and that's why it's free.

🎨 Picture this: the tools in your workshop. Hammer, screwdriver, hacksaw. You buy them once and use them for life. Nobody sends you a bill for every nail you drive.

Category B: Free MCP + paid service under the hood

The most dangerous category for surprise bills. You download the MCP for free and connect it to Claude Code with no subscription. But every call goes to a paid service, and the bill comes from there.

Top 8 MCPs in this category:

Current prices and limits: see each service's pricing page (links at the end of the lesson).

The main rule: read the pricing of the service under the hood before you connect the MCP. Installing an MCP doesn't show you a bill; the bill comes separately from Stripe / Notion / Slack.

🎨 Picture this: a car-sharing service. The app is free to download. Signing up is free. The car is parked on the street. You get in, start driving, and the meter starts running. You pay for as many minutes as you drive.

Category C: Fully paid MCP

The MCP itself needs an API key for a paid service. Without a subscription or an account with that service, the MCP doesn't work at all, not even as a client.

Top 6 paid MCPs:

Current prices and limits for the rest: see each service's pricing page.

Use case: professional integrations for business. If you're building a content pipeline with Tavily, estimate the cost from your real number of requests and compare it with the time you save.

🎨 Picture this: a professional Adobe Creative Cloud subscription. Without it, Photoshop won't even open. It's a noticeable monthly expense. If design is your job, the subscription pays for itself. If you draw once a year, you're paying for something you don't need.

Top 15 MCPs and what they actually cost you (cheat sheet)

MCP token economics

This is the second hidden cost nobody sees: MCPs eat context tokens.

How it works:

• If tool descriptions load in full, each MCP server adds ~500–3,000 tokens to the context (tool descriptions, schemas). In newer versions of Claude Code, tool search is on by default: only the names stay in context, and full descriptions load on demand
• Each MCP call adds ~200–1,000 tokens (request + response)
• 20 MCPs fully loaded = ~30K tokens in context right away, before your first message

The token numbers are rough, an order of magnitude, not a measurement.

What one MCP call costs in money (Claude API prices as of October 2026, per 1 million tokens):

Example: 100 MCP calls a day × 30 days on Sonnet 5.5 = ~$18/month just on MCP tokens (not counting the main conversation). On Haiku 4.5 = $9/month. This is what you pay if you use Claude through the API; on a Pro or Max subscription you don't pay per token, but MCP tokens still use up your plan's limits.

Source: Claude platform: pricing, checked October 2026. Latest summary: What's current.

How this connects to context rot (see the lesson Context Rot and 28 techniques to fight degradation):

• Up to ~50% of the window: Claude works at full strength
• 50–65%: reasoning quality starts to slip
• 65%+: noticeable mistakes, forgotten instructions, repetition

Rule of thumb:

• 5–7 active MCPs: normal
• 10–15: you're approaching the red zone
• 20+: overengineering, guaranteed context rot

🎨 Picture this: the fridge again. You can pack it to the brim, but then the door won't close properly. Better to keep it roomy, and the food lasts longer.

The real economics of 3 typical stacks

Let's skip the theory and count real money for three typical users. Where a price below says "pricing page", look it up and fill in the number yourself.

Stack A: Personal automation, $0/month

Connected: filesystem + git + memory + sequential-thinking + time + brave-search (free tier)

Context cost: roughly ~5K tokens for 6 MCPs. Clean, no context rot.

Use case: personal scripts, notes, coding pet projects, local search, simple research.

Stack B: Freelance content creator, $6/month + Notion Plus

Connected: Stack A + Notion + GitHub (Free plan) + ElevenLabs Starter + Firecrawl free

Context cost: roughly ~12K tokens for 10 MCPs. A comfortable zone.

Use case: a content pipeline (lesson The complete content pipeline), voiceovers, web scraping for research, documentation in Notion, private GitHub repos.

Stack C: AI agency, $11/month + per-user subscriptions

Connected: Stack B + HubSpot + Stripe + Cloudflare Workers + Context7 + Linear + Slack + Composio + Tavily

Context cost: roughly ~20K tokens for 18 MCPs. You're approaching the red zone. Recommendation: split them into profiles instead of turning everything on at once.

Use case: an agency serving 5–10 clients (see the lesson First clients). CRM, billing, project management, multi-source research, customer communication.

Hidden costs in 2026 (important)

Besides the obvious subscriptions, there are invisible costs that add noticeably to the total cost of ownership.

1. Setup time:

• OAuth flow for each MCP: ~30–60 minutes the first time
• Reading docs, configuring .mcp.json: ~1–2 hours for a complex MCP
• Testing that it works: ~30 minutes

2. Maintenance:

• Updating MCP versions: ~30 minutes/month
• Breaking changes in the service's API: ~1–2 hours when it happens
• Token rotation (security): ~15 minutes/quarter

3. Debugging:

• When an MCP doesn't respond: 2–4 hours for the first round of debugging
• When you hit a rate limit: 30 minutes to figure it out
• When an update breaks the integration: up to half a day

4. Self-hosted MCP (if you build your own):

• The Cloudflare Workers free tier is usually enough
• Vercel Hobby is only for personal, non-commercial projects
• If you need to pay: Workers Paid from $5/month

Time is money. If your time is worth $30/hour, an extra 20 hours setting up all your MCPs = the equivalent of an extra $600 in the first month. After that it pays itself off over time.

Pay-per-call pricing nuances

Several MCPs bill per request, a bit like tokens. Count these separately.

Pay-per-call MCPs:

• Tavily: pay per credit after the free monthly credits; there are also plans with a fixed number of credits
• Firecrawl: paid monthly plans after the free credits
• Context7: a free plan with a monthly cap on API calls
• Brave Search: pay per 1,000 requests after the free monthly credit

Current prices and limits: on each service's pricing page.

Estimating your real usage:

calls per month = calls per day × 30
paid calls      = calls per month − free calls
cost            = paid calls × price per call

A worked example with made-up numbers: a service gives 1,000 free calls a month, then charges $0.01 per call.

Cache strategically: repeated queries can be cached locally for 1 hour, which cuts 30–50% of calls.

🎨 Picture this: a taxi meter. There's a flat fee for getting in. After that, you pay for every mile. Drive in circles around the city and the meter runs away from you. Plan your route ahead.

Who needs what (by level)

Not everyone needs Stack C. Pick based on your own situation.

Beginner (Claude Pro, $17–20):

• Connected: filesystem + git + memory + brave-search free
• MCP cost: $0/month
• Total cost: Claude, $17–20/month
• Enough for: the first lessons of the course, pet projects, local development

Intermediate (content marketer):

• Connected: + Notion Plus + ElevenLabs Starter + Firecrawl free + GitHub Free
• MCP cost: Notion Plus + $6 ElevenLabs Starter
• Total: Claude $17–20 + Notion Plus + $6
• Enough for: a content pipeline, multi-platform publishing (lesson The complete content pipeline)

Professional (agency):

• Connected: + Stripe + HubSpot + Cloudflare Paid + Context7 (free) + Tavily
• MCP cost: $11/month + the services' subscriptions + 2.9% of revenue
• Total: Claude Max from $100 + your MCP services
• Enough for: multi-client operations, billing (see the lesson First clients)

Enterprise:

• Connected: + Composio + Linear + Slack Pro + private MCP servers
• MCP cost: the sum of the paid plans + % of revenue
• Total: Claude Max $200 or team plans + your MCP services + infrastructure
• Enough for: teams of 5+ people, multi-tenant SaaS, advanced automation

Anti-patterns (what not to do)

❌ Connecting every available MCP "just in case": guaranteed context rot and lower quality

❌ Paying for Tavily / Firecrawl paid plans for personal use: the free tiers of Brave Search, Context7 and Firecrawl are enough for most personal scenarios

❌ Paying for Composio when you need 2–3 actions: direct MCPs for each service are cheaper and easier to debug

❌ Connecting an MCP without reading the pricing under the hood: a surprise Stripe bill for 2.9% of your revenue hurts

❌ Forgetting about free tier limits: going over Brave Search's free credit means paying for every extra 1,000 requests

❌ Not counting the token cost of MCPs in your context: 20 MCPs connected = a noticeable drop in quality from context rot

❌ Self-hosting an MCP when you don't need to: as long as there are free cloud tiers, your own infrastructure is just extra maintenance

How to read an MCP's pricing (the method)

Before connecting any MCP, go through 5 steps:

Step 1: What does the MCP do on paper?

• Read the README in the MCP's GitHub repo
• Sum up what it does in one sentence

Step 2: Which service does it connect to?

• Stripe MCP → Stripe API
• Notion MCP → Notion API
• Tavily MCP → Tavily Search API

Step 3: How much does that service cost?

• Go to the service's pricing page
• Find the plan you actually need
• Write down the number

Step 4: Is there a free tier, and what are its limits?

• Free tier limits per month / calls / users
• What happens when you go over (overage charges / hard stop / forced upgrade)

Step 5: Calculate the real cost:

typical_usage_per_month × pricing = real_cost
+ context overhead (5-15K tokens)
+ setup time (1-2 hours)
+ maintenance (30 min/month)
= total_monthly_cost_of_ownership

🎨 Picture this: buying a car. The sticker price is just the beginning. Taxes, insurance, gas, tires, parking: that's the real cost of owning it. Same with MCPs.

Decision tree: "do I need this MCP"

Does this MCP give a capability that base Claude Code doesn't have?
├─ No → DON'T CONNECT (the overhead isn't worth it)
└─ Yes → Will I use it more than 3 times a week?
        ├─ No → DON'T CONNECT (once a month isn't worth it)
        └─ Yes → Does the free tier cover my real usage?
                ├─ Yes → ✅ CONNECT
                └─ No → Is the cost less than the value I get?
                         ├─ Yes → ✅ CONNECT (paid plan)
                         └─ No → DON'T CONNECT (overpriced for me)

Practice

Step 1: Audit your current MCP stack

# Open .mcp.json for the current project
cat .mcp.json | jq '.mcpServers | keys'

# Count how many MCPs are connected
cat .mcp.json | jq '.mcpServers | length'

# If the number is >7, time to clean up

Step 2: Calculate your real monthly cost

Create a file mcp-budget.md in any project:

## MCP Cost Audit — YYYY-MM-DD

### Connected MCPs
| MCP | Cat (A/B/C) | Free tier | Real usage/month | Cost |
|---|---|---|---|---|
| filesystem | A | unlimited | daily | $0 |
| git | A | unlimited | daily | $0 |
| github | B | Free plan | 3-5/week | $0 |
| brave-search | B | monthly free credit | ~800 requests/month | $0 |
| notion | B | Plus, per user | daily | $XX |
| ... | | | | |

### Total
- Fixed: $XX/month
- Variable (Stripe %, overages): $XX/month
- Context tokens used: ~XXK
- Estimated context rot risk: low / medium / high

### Recommendations
- Underused (sunset candidate): <list>
- Free tier near limit: <list>
- Consider upgrade: <list>

Step 3: Remove underused MCPs

# Open .mcp.json in your editor
# Delete any MCP you haven't used in more than 2 weeks
# Save

# Reconnect the servers with /mcp (or restart Claude Code)
# Run /context and check how much space you freed up

The 80/20 rule: usually 20% of your MCPs do 80% of the work. The rest are candidates for removal.

Step 4: Set up alerts for free tier limits

# For Brave Search, check once a week
# Go to the dashboard https://api.search.brave.com/app/dashboard
# Look at the % used

# For Tavily, the built-in usage tracker
# https://app.tavily.com/usage

# For Firecrawl, settings → usage
# https://www.firecrawl.dev/app/usage

Threshold rule: if by the 20th of the month you've used more than 80% of the free tier, it's time to think about a paid plan or a caching strategy.

Step 5: Add a cache layer for pay-per-call MCPs

The simplest option for Tavily/Firecrawl is to cache identical queries:

# cache_mcp.py — a simple file cache for repeated MCP calls
import hashlib
import json
import time
from pathlib import Path

CACHE_DIR = Path(".mcp-cache")
CACHE_DIR.mkdir(exist_ok=True)
TTL_SECONDS = 3600  # 1 hour

def cache_key(mcp_name: str, params: dict) -> str:
    """Stable hash of the request parameters."""
    canonical = json.dumps(params, sort_keys=True)
    return f"{mcp_name}_{hashlib.sha256(canonical.encode()).hexdigest()[:16]}"

def get_cached(key: str):
    """Returns the cached result if it hasn't expired."""
    cache_file = CACHE_DIR / f"{key}.json"
    if not cache_file.exists():
        return None

    data = json.loads(cache_file.read_text())
    if time.time() - data["ts"] > TTL_SECONDS:
        cache_file.unlink()  # expired, delete it
        return None

    return data["result"]

def set_cached(key: str, result):
    """Saves the result with a timestamp."""
    cache_file = CACHE_DIR / f"{key}.json"
    cache_file.write_text(json.dumps({
        "ts": time.time(),
        "result": result
    }, ensure_ascii=False))

# Usage (pseudocode)
key = cache_key("tavily", {"query": "AI trends 2026"})
cached = get_cached(key)
if cached:
    result = cached  # free
else:
    result = call_tavily_mcp(query="AI trends 2026")  # paid
    set_cached(key, result)

Savings: 30–50% of calls in a typical workflow, because repeated research queries get cached.

Step 6: Compare 3 stacks on paper

Do your own calculation for your own situation:

## My MCP Stack — comparison

### Option A: Minimalist ($0/month)
- filesystem, git, memory, sequential-thinking, brave-search free
- Pros: zero cost, low context overhead
- Cons: no CRM, no auto-posting

### Option B: Content creator ($6/month + Notion Plus)
- + Notion Plus ($XX), Firecrawl free, GitHub Free, ElevenLabs Starter ($6)
- Pros: covers a content pipeline
- Cons: no CRM, no billing

### Option C: Agency ($11/month + per-user subscriptions)
- + HubSpot ($XX), Stripe (2.9% rev), Cloudflare ($5), Context7 (free), Tavily (by usage), Linear ($XX), Slack Pro ($XX)
- Pros: enterprise-grade
- Cons: expensive if you have fewer than 3 clients

### My choice: Option [A/B/C]
### Reasoning: <one sentence>

Lesson checklist

• I understand the difference: a free MCP ≠ a free service under the hood
• I know the 3 MCP categories (A/B/C) and can classify any new one
• I've audited my .mcp.json and know its real monthly cost
• I have no more than 7 active MCPs connected (context discipline)
• I count the context token overhead of each connected MCP
• I know the free tier limits for every Category B/C MCP in my stack
• I have a cache layer for pay-per-call MCPs (Tavily, Firecrawl, Context7)
• I use the 5-step method for reading pricing on every new MCP
• I understand my stack (A/B/C) and why I chose it

Tools and resources

• MCP official documentation: the protocol specification and a list of reference servers
• Anthropic directory: vetted connectors and MCP servers
• Glama MCP directory: an alternative directory with pricing info
• Claude API: pricing: Sonnet 5.5 $2/$10 per MTok, Haiku 4.5 $1/$5, Opus 5.5 $4/$20 (as of October 2026)
• Stripe pricing: 2.9% + $0.30 per online card payment (US, as of October 2026)
• Notion plans: Free / Plus / Business (full Notion AI) / Enterprise
• Slack pricing: Free / Pro / Business+ / Enterprise+
• HubSpot pricing: Free / Starter / Professional / Enterprise
• Brave Search API: the monthly free credit and the price per 1,000 requests
• Tavily Search: free credits and pay-as-you-go
• Firecrawl pricing: free credits and paid plans
• Composio pricing: the free plan and Pro
• Context7: the free plan and its monthly cap on API calls
• ElevenLabs pricing: Starter $6/month, Creator $22, Pro $99
• Linear pricing: Free / Basic / Business / Enterprise
• DeepL: a free version and paid plans

Key takeaways

A free MCP ≠ free usage. The protocol itself is open, and the servers download for $0. But under the hood there are real services (Stripe, Notion, Slack) with their own pricing. Read the price of the service behind the MCP before you connect it, or you'll get a surprise bill.

The 3 categories set your strategy: A (fully free, local) for personal use, B (free MCP + paid service) for business, C (fully paid) only when the value is clear. Each category has its own logic for connecting and budget planning.

Context discipline matters more than the number of integrations. 5–7 active MCPs is normal; 20+ guarantees context rot and lower quality. Better 6 MCPs you actually use deeply than 20 "just in case" ones that slow Claude down.

Next lesson

→ 24/7 deployment: Cloudflare Workers: how a workflow keeps running while you sleep. For automatic checks and rules, see the lesson Hooks: automatic rules for Claude Code.