MCP Pricing & Token Economics: servidores gratis vs. de pago, el costo real de las integraciones

Tiempo: unos 25 min de lectura + 20 min de cálculos

Lo esencial

Que un MCP sea "gratis" en papel es media verdad. El protocolo en sí es abierto, los servidores se descargan por $0 y la configuración se escribe en .mcp.json sin suscripción. Pero debajo de cada MCP hay un servicio real, y a ese servicio le pagas tú, no a Anthropic.

El MCP de Stripe es gratis. Stripe cobra 2.9% + $0.30 por cada transacción (EE. UU., tarjeta en línea; en otros países la tarifa es distinta). El MCP de Notion es gratis. Notion AI completo viene en el plan Business, que se paga por miembro (precio en su página de planes). El MCP de Slack es gratis. Slack Pro se paga por usuario al mes (precio en su página de planes).

Las cifras de esta lección son a octubre de 2026 y solo aparecen donde están verificadas en la página Lo vigente; para los demás servicios, abre su página de precios antes de decidir. Los montos de los stacks de ejemplo son una ilustración del cálculo, no una lista de precios.

Esta lección trata del costo real de un stack de MCP. En 25 minutos vas a poder ver la etiqueta de precio escondida en cada "Install MCP", y no te van a sorprender las facturas a fin de mes.

🎨 Imagínalo así: un MCP es como un adaptador para el enchufe. El adaptador cuesta poco: lo compraste en la tienda por un par de dólares. Pero la electricidad que pasa por él la pagas a la tarifa completa de la compañía de luz. El adaptador es gratis; el recibo de luz va a llegar. No todo lo que se descarga gratis se usa gratis.

🎯 Árbol de decisión: ¿conecto este MCP?

La pregunta principal de la lección no es "qué MCP es mejor", sino "¿vale la pena conectar este MCP concreto, tomando en cuenta su precio escondido?".

Conecta un MCP si:

• ✓ Te da una función que no existe en Claude Code tal cual
• ✓ Lo vas a usar más de 3 veces por semana (si no, el gasto de contexto no se paga)
• ✓ El plan gratis cubre tu uso real (o el servicio de pago vale lo que cuesta)
• ✓ En total no tienes más de 7 MCP activos en el stack (disciplina de contexto)
• ✓ Entiendes cómo cobra el servicio por dentro (nada de cobros sorpresa)

NO lo conectes si:

• ✗ Lo conectas "por si acaso": context rot garantizado
• ✗ El servicio de pago de fondo cuesta más de lo que vas a ahorrar
• ✗ Vas a rebasar el límite del plan gratis en una semana
• ✗ Lo vas a usar poco (una vez al mes no justifica el gasto)

Por defecto, un stack minimalista. Agregas algo solo cuando de verdad chocaste con el límite de Claude Code.

🎨 Imagínalo así: el refrigerador de un departamento rentado. Puedes llenarlo con todo lo de la tienda "por si acaso". La mitad se echa a perder y lo demás lo olvidas. Mejor 7 a 10 productos que sí vas a comer esta semana. Con los MCP pasa igual.

Conceptos clave

• Servidor MCP: un programa que implementa el Model Context Protocol y le da a Claude Code acceso a un servicio externo
• Categoría A, totalmente gratis: el MCP trabaja con recursos locales o de código abierto, sin suscripciones externas
• Categoría B, envoltura gratis / servicio de pago: el MCP es gratis, pero el servicio que envuelve cuesta dinero (Stripe, Notion)
• Categoría C, MCP de pago: el propio MCP requiere la clave de API de un servicio de pago (Tavily, Firecrawl, Context7)
• Token economics: cada servidor MCP "se come" tokens del contexto: las descripciones de sus herramientas (en las versiones nuevas de Claude Code se cargan bajo demanda) y los resultados de cada llamada
• Context rot: la degradación de la calidad del razonamiento del LLM cuando el contexto está lleno (mira la lección Context Rot y 28 técnicas contra la degradación)
• Free tier: el límite gratis de un servicio (por ejemplo, Brave Search da créditos gratis cada mes); al rebasarlo, empieza el cobro
• Costo oculto: los gastos que no se ven en la página del MCP (tiempo de configuración, mantenimiento, depuración)

Teoría

Las 3 categorías de MCP según cómo cobran

Todos los servidores MCP de 2026 caen en tres grupos claros. Entender la categoría es el primer filtro antes de conectar.

Categoría A: totalmente gratis

El MCP trabaja con recursos locales o con infraestructura de código abierto. Sin suscripciones, sin claves de API, sin más límite que la potencia de tu computadora.

Los 6 MCP gratis principales:

Uso: scripts personales, desarrollo local, notas. No sale de tu computadora; por eso es gratis.

🎨 Imagínalo así: las herramientas de tu taller. Martillo, desarmador, serrucho. Los compraste una vez y los usas toda la vida. Nadie te cobra por cada clavo que metes.

Categoría B: MCP gratis + servicio de pago de fondo

La categoría más peligrosa en cuanto a cobros sorpresa. El MCP se descarga gratis y se conecta a Claude Code sin suscripción. Pero cada llamada va a un servicio de pago, y la factura llega de ahí.

Los 8 MCP principales de esta categoría:

Los precios y límites vigentes están en la página de precios de cada servicio (enlaces al final de la lección).

La regla principal: lee los precios del servicio de fondo antes de conectar el MCP. Instalar el MCP no te muestra la factura: esa te llega aparte, de Stripe, Notion o Slack.

🎨 Imagínalo así: un coche compartido por app. La app se descarga gratis. El registro es gratis. El coche está en la calle. Te subes, arrancas y el taxímetro empieza a correr. Pagas los minutos que manejaste.

Categoría C: MCP totalmente de pago

El propio MCP requiere la clave de API de un servicio de pago. Sin suscripción o sin cuenta, el MCP no funciona en absoluto, ni siquiera como cliente.

Los 6 MCP de pago principales:

Los precios y límites vigentes de los demás están en la página de precios de cada servicio.

Caso de uso: integraciones profesionales para un negocio. Si armas una cadena de contenido con Tavily, calcula el gasto con tu número real de consultas y compáralo con el tiempo que te ahorra.

🎨 Imagínalo así: una suscripción profesional a Adobe Creative Cloud. Sin suscripción, Photoshop ni abre. Cuesta lo suyo cada mes. Si el diseño es tu trabajo, la suscripción se justifica. Si dibujas una vez al año, estás comprando algo que no necesitas.

Los 15 MCP principales con su costo real (acordeón)

Token economics de los MCP

Este es el segundo costo oculto que nadie ve: los MCP se comen tokens del contexto.

Cómo funciona:

• Si las descripciones de las herramientas se cargan completas, cada servidor MCP agrega unos 500-3000 tokens al contexto (la descripción de las herramientas y sus esquemas). En las versiones nuevas de Claude Code, la búsqueda de herramientas (tool search) viene activada por defecto: en el contexto quedan los nombres y las descripciones completas se cargan bajo demanda
• Cada llamada a un MCP agrega unos 200-1000 tokens (solicitud + respuesta)
• 20 MCP con carga completa = unos 30K tokens en el contexto antes de tu primer mensaje

Las cifras de tokens son aproximadas: un orden de magnitud, no una medición.

El costo en dinero de una llamada a un MCP (precios de la API de Claude a octubre de 2026, por 1 millón de tokens):

Ejemplo: 100 llamadas MCP al día × 30 días con Sonnet 5.5 = unos $18 al mes solo en tokens de MCP (sin contar la conversación principal). Con Haiku 4.5 = $9 al mes. Esto es lo que pagas si usas Claude por la API; con una suscripción Pro o Max no pagas por token, pero los tokens de MCP igual consumen los límites de tu plan.

Fuente: la plataforma de Claude: precios, revisado en octubre de 2026. El resumen vigente: Lo vigente.

La relación con el context rot (mira la lección Context Rot y 28 técnicas contra la degradación):

• Hasta cerca del 50% de la ventana: Claude trabaja a toda su capacidad
• Del 50 al 65%: empieza a degradarse la calidad del razonamiento
• Más del 65%: errores notorios, instrucciones olvidadas, repeticiones

Regla práctica:

• 5-7 MCP activos: lo normal
• 10-15: te acercas a la zona roja
• 20 o más: sobreingeniería, context rot garantizado

🎨 Imagínalo así: otra vez el refrigerador. Puedes llenarlo a reventar, pero la puerta ya no cierra bien. Mejor tenerlo con espacio: la comida dura más.

La economía real de 3 stacks típicos

Calculamos dinero real, no teoría, para tres usuarios típicos. Donde abajo un precio dice «según su página» o «según su sitio», búscalo ahí y anota tú la cifra.

Stack A: automatización personal, $0 al mes

Conectados: filesystem + git + memory + sequential-thinking + time + brave-search (plan gratis)

Costo de contexto: aproximadamente 5K tokens para 6 MCP: limpio, sin context rot.

Caso de uso: scripts personales, notas, programar proyectos propios, búsqueda local, investigación sencilla.

Stack B: creador de contenido independiente, $6/mes + Notion Plus

Conectados: Stack A + Notion + GitHub (plan Free) + ElevenLabs Starter + Firecrawl gratis

Costo de contexto: aproximadamente 12K tokens para 10 MCP: zona cómoda.

Caso de uso: una cadena de contenido (lección La cadena de contenido completa), locución con voz, scraping web para investigar, documentación en Notion, repositorios privados en GitHub.

Stack C: agencia de IA, $11/mes + suscripciones por usuario

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

Costo de contexto: aproximadamente 20K tokens para 18 MCP: te acercas a la zona roja. Recomendación: repartirlos en perfiles y no activarlos todos a la vez.

Caso de uso: una agencia que atiende de 5 a 10 clientes (mira la lección Los primeros clientes). CRM, cobros, gestión de proyectos, investigación con varias fuentes, comunicación con clientes.

Los costos ocultos de 2026 (importante)

Además de las suscripciones visibles, hay gastos invisibles que suman bastante al costo total de propiedad.

1. Tiempo de configuración:

• El flujo OAuth de cada MCP: unos 30-60 minutos la primera vez
• Leer la documentación y configurar .mcp.json: unas 1-2 horas por un MCP complejo
• Probar que funciona: unos 30 minutos

2. Mantenimiento:

• Actualizar las versiones de los MCP: unos 30 minutos al mes
• Cambios incompatibles en la API del servicio: 1-2 horas cuando pasan
• Rotar tokens (seguridad): unos 15 minutos por trimestre

3. Depuración:

• Cuando un MCP no responde: 2-4 horas la primera vez
• Cuando topas con un rate limit: 30 minutos para entenderlo
• Cuando una actualización rompió la integración: hasta medio día

4. MCP autoalojado (si haces el tuyo):

• El plan gratis de Cloudflare Workers suele alcanzar
• Vercel Hobby: solo para proyectos personales no comerciales
• Si es de pago: Workers Paid desde $5/mes

El tiempo es dinero. Si tu hora vale $30, +20 horas para configurar todos los MCP = el equivalente a +$600 el primer mes. Después se amortiza.

Matices del cobro por uso

Varios MCP cobran con un modelo parecido al de los tokens: por cada solicitud. Eso se calcula aparte.

MCP con pago por llamada:

• Tavily: créditos gratis cada mes; después, pago por crédito o un plan con más créditos
• Firecrawl: créditos gratis cada mes; después, planes de pago
• Context7: plan gratis con un límite mensual de llamadas a la API
• Brave Search: créditos gratis cada mes; después, un cobro por cada 1,000 consultas

Los precios y los límites exactos están en las páginas de cada servicio; cambian seguido.

Cómo calcular tu uso real:

llamadas_al_mes = llamadas_al_día × 30
llamadas_de_pago = llamadas_al_mes − llamadas_gratis_del_plan
costo = llamadas_de_pago × precio_por_llamada

Un ejemplo con números inventados, solo para mostrar el cálculo: un servicio da 1,000 llamadas gratis al mes y luego cobra $0.01 por llamada.

Pon en la fórmula los precios reales del servicio antes de decidir.

Usa la caché con estrategia: las consultas repetidas se pueden guardar en caché local por 1 hora: un ahorro del 30-50% de las llamadas.

🎨 Imagínalo así: el taxímetro. El primer kilómetro tiene tarifa fija de arranque. Después, cobra cada kilómetro. Si te pones a dar vueltas por la ciudad, el taxímetro se dispara. Piensa la ruta antes.

Qué necesita cada nivel

No todos necesitan el Stack C. Elige según tu situación.

Principiante (Claude Pro $17-20):

• Conectados: filesystem + git + memory + brave-search gratis
• Costo de MCP: $0/mes
• Costo total: $17-20/mes de Claude
• Alcanza para: las primeras lecciones del curso, proyectos propios, desarrollo local

Intermedio (marketing de contenido):

• Conectados: + Notion Plus + ElevenLabs Starter + Firecrawl gratis + GitHub Free
• Costo de MCP: $6/mes + Notion Plus
• Total: Claude $17-20 + ElevenLabs $6 + Notion Plus
• Alcanza para: una cadena de contenido, publicar en varias plataformas (lección La cadena de contenido completa)

Profesional (agencia):

• Conectados: + Stripe + HubSpot + Cloudflare Paid + Context7 (gratis) + Tavily
• Costo de MCP: $11/mes + las suscripciones de los servicios + 2.9% de los ingresos
• Total: Claude Max desde $100 + la suma de tus MCP
• Alcanza para: operar con varios clientes, cobros (mira la lección Los primeros clientes)

Empresa:

• Conectados: + Composio + Linear + Slack Pro + servidores MCP privados
• Costo de MCP: la suma de las suscripciones por usuario + un porcentaje de los ingresos
• Total: Claude Max $200 o planes de equipo + los MCP + la infraestructura; calcúlalo con tus cifras
• Alcanza para: equipos de 5 o más personas, SaaS multicliente, automatización avanzada

Antipatrones (lo que no hay que hacer)

❌ Conectar todos los MCP disponibles "por si acaso": context rot garantizado, la calidad se degrada

❌ Pagar planes de Tavily o Firecrawl para uso personal: los planes gratis de Brave Search, Context7 y Firecrawl alcanzan para la mayoría de los casos personales

❌ Pagar Composio cuando necesitas 2 o 3 acciones: mejor un MCP directo por servicio, más barato y más fácil de depurar

❌ Conectar un MCP sin leer los precios de fondo: un cobro sorpresa de Stripe del 2.9% de tu facturación duele

❌ Olvidar los límites del plan gratis: rebasar los créditos gratis de Brave Search significa pagar cada mil consultas extra a su tarifa

❌ No contar el costo en tokens de los MCP en el contexto: 20 MCP conectados = una pérdida de calidad notable por context rot

❌ Autoalojar MCP sin necesidad: mientras existan planes gratis en la nube, tu propia infraestructura es solo mantenimiento extra

Cómo leer los precios de un MCP (metodología)

Antes de conectar cualquier MCP, sigues 5 pasos:

Paso 1: ¿Qué hace el MCP en papel?

• Lees el README del repositorio del MCP en GitHub
• Entiendes su función en una frase

Paso 2: ¿A qué servicio se conecta?

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

Paso 3: ¿Cuánto cuesta ese servicio?

• Vas a la página de precios del servicio
• Encuentras el plan que de verdad necesitas
• Anotas la cifra

Paso 4: ¿Hay plan gratis y con qué límites?

• El límite del plan gratis en meses, llamadas o usuarios
• Qué pasa al rebasarlo (cobro extra / corte / te obligan a subir de plan)

Paso 5: Calculas el costo real:

uso_típico_al_mes × precio = costo_real
+ gasto de contexto (5-15K tokens)
+ tiempo de configuración (1-2 horas)
+ mantenimiento (30 min/mes)
= costo_total_mensual_de_propiedad

🎨 Imagínalo así: comprar un coche. El precio en la agencia es solo el principio. Tenencia, seguro, gasolina, llantas, estacionamiento: ese es el costo real de tenerlo. Con los MCP pasa lo mismo.

Árbol de decisión "¿necesito este MCP?"

¿Este MCP da una función que no existe en Claude Code tal cual?
├─ No → NO CONECTAR (el gasto no se justifica)
└─ Sí → ¿Lo voy a usar más de 3 veces por semana?
        ├─ No → NO CONECTAR (una vez al mes = no se justifica)
        └─ Sí → ¿El plan gratis cubre mi uso real?
                ├─ Sí → ✅ CONECTAR
                └─ No → ¿El costo es menor que el valor que obtengo?
                         ├─ Sí → ✅ CONECTAR (plan de pago)
                         └─ No → NO CONECTAR (demasiado caro para mí)

Práctica

Paso 1: Audita tu stack de MCP actual

# Abrir el .mcp.json del proyecto actual
cat .mcp.json | jq '.mcpServers | keys'

# Contar cuántos MCP hay conectados
cat .mcp.json | jq '.mcpServers | length'

# Si son más de 7, toca limpiar

Paso 2: Calcula tu costo mensual real

Crea un archivo mcp-budget.md en cualquier proyecto:

## MCP Cost Audit — YYYY-MM-DD

### MCP conectados
| MCP | Cat (A/B/C) | Plan gratis | Uso real/mes | Costo |
|---|---|---|---|---|
| filesystem | A | ilimitado | diario | $0 |
| git | A | ilimitado | diario | $0 |
| github | B | plan Free | 3-5/semana | $0 |
| brave-search | B | créditos gratis/mes | ~800 consultas/mes | $0 |
| notion | B | Plus, por usuario | diario | $XX |
| ... | | | | |

### Total
- Fijo: $XX/mes
- Variable (% de Stripe, excedentes): $XX/mes
- Tokens de contexto usados: ~XXK
- Riesgo estimado de context rot: bajo / medio / alto

### Recomendaciones
- Poco usados (candidatos a retirar): <lista>
- Plan gratis cerca del límite: <lista>
- Considerar subir de plan: <lista>

Paso 3: Quita los MCP que casi no usas

# Abre .mcp.json en el editor
# Borra los MCP que no usaste en más de 2 semanas
# Guarda

# Vuelve a conectar los servidores con /mcp (o reinicia Claude Code)
# Ejecuta /context y revisa cuánto espacio se liberó

La regla 80/20: normalmente el 20% de los MCP hace el 80% del trabajo. Los demás son candidatos a eliminarse.

Paso 4: Configura avisos para los límites del plan gratis

# Para Brave Search: revisión una vez por semana
# Entras al panel https://api.search.brave.com/app/dashboard
# Miras el % usado

# Para Tavily: el contador de uso integrado
# https://app.tavily.com/usage

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

Regla del umbral: si el día 20 del mes ya usaste más del 80% del plan gratis, es momento de pensar en un plan de pago o en una estrategia de caché.

Paso 5: Agrega una capa de caché para los MCP con pago por llamada

La opción más simple para Tavily/Firecrawl: guardar en caché las consultas idénticas:

# cache_mcp.py: una caché sencilla para llamadas MCP repetidas
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 hora

def cache_key(mcp_name: str, params: dict) -> str:
    """Un hash estable de los parámetros de la consulta."""
    canonical = json.dumps(params, sort_keys=True)
    return f"{mcp_name}_{hashlib.sha256(canonical.encode()).hexdigest()[:16]}"

def get_cached(key: str):
    """Devuelve el resultado guardado si no ha caducado."""
    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()  # caducó: lo borramos
        return None

    return data["result"]

def set_cached(key: str, result):
    """Guarda el resultado con su marca de tiempo."""
    cache_file = CACHE_DIR / f"{key}.json"
    cache_file.write_text(json.dumps({
        "ts": time.time(),
        "result": result
    }, ensure_ascii=False))

# Uso (pseudocódigo)
key = cache_key("tavily", {"query": "AI trends 2026"})
cached = get_cached(key)
if cached:
    result = cached  # gratis
else:
    result = call_tavily_mcp(query="AI trends 2026")  # de pago
    set_cached(key, result)

Ahorro: del 30 al 50% de las llamadas en un workflow típico: las consultas de investigación que se repiten se sirven desde la caché.

Paso 6: Compara 3 stacks en papel

Haz tu propio cálculo para tu caso:

## My MCP Stack — comparison

### Opción A: Minimalista ($0/mes)
- filesystem, git, memory, sequential-thinking, brave-search gratis
- A favor: costo cero, poco gasto de contexto
- En contra: sin CRM, sin publicación automática

### Opción B: Creador de contenido ($6/mes + Notion Plus)
- + Notion Plus ($XX), Firecrawl gratis, GitHub Free, ElevenLabs Starter ($6)
- A favor: cubre la cadena de contenido
- En contra: sin CRM, sin cobros

### Opción C: Agencia ($11/mes + suscripciones por usuario)
- + HubSpot ($XX), Stripe (2.9% de los ingresos), Cloudflare ($5), Context7 (gratis), Tavily (según el uso), Linear ($XX), Slack Pro ($XX)
- A favor: nivel empresarial
- En contra: caro si tienes menos de 3 clientes

### Mi elección: Opción [A/B/C]
### Por qué: <una frase>

Lista de verificación de la lección

• Entiendo la diferencia: MCP gratis ≠ servicio de fondo gratis
• Conozco las 3 categorías de MCP (A/B/C) y puedo clasificar cualquiera nuevo
• Audité mi .mcp.json y sé su costo mensual real
• No tengo más de 7 MCP activos conectados (disciplina de contexto)
• Cuento el gasto de tokens de contexto de cada MCP conectado
• Conozco los límites del plan gratis de todos los MCP de categoría B y C de mi stack
• Tengo una capa de caché para los MCP con pago por llamada (Tavily, Firecrawl, Context7)
• Aplico la metodología de 5 pasos para leer los precios de cada MCP nuevo
• Entiendo mi stack (A/B/C) y por qué lo elegí

Herramientas y recursos

• Documentación oficial de MCP: la especificación del protocolo y la lista de servidores de referencia
• Catálogo de Anthropic: conectores y servidores MCP verificados
• Directorio de MCP de Glama: un catálogo alternativo con información de precios
• API de Claude: precios: Sonnet 5.5 $2/$10 por MTok, Haiku 4.5 $1/$5, Opus 5.5 $4/$20 (a octubre de 2026)
• Precios de Stripe: 2.9% + $0.30 por tarjeta en línea (EE. UU., a octubre de 2026)
• Planes de Notion: Free / Plus / Business (Notion AI completo) / Enterprise
• Precios de Slack: Free / Pro / Business+ / Enterprise+
• Precios de HubSpot: Free / Starter / Professional / Enterprise
• Brave Search API: créditos gratis cada mes, después un cobro por cada 1,000 consultas
• Tavily Search: créditos gratis cada mes, después pago por crédito
• Precios de Firecrawl: créditos gratis, después planes de pago
• Precios de Composio: plan gratis y plan Pro
• Context7: plan gratis con un límite mensual de llamadas a la API
• Precios de ElevenLabs: Starter $6/mes, Creator $22, Pro $99
• Precios de Linear: Free / Basic / Business / Enterprise
• DeepL: versión gratis y planes de pago

Ideas clave

MCP gratis ≠ uso gratis. El protocolo es abierto y los servidores se descargan por $0. Pero debajo hay servicios reales (Stripe, Notion, Slack) con sus propios precios. Lee el precio del servicio de fondo antes de conectar; si no, llegan los cobros sorpresa.

Las 3 categorías definen la estrategia: A (totalmente gratis, locales) para uso personal; B (MCP gratis + servicio de pago) para negocio; C (totalmente de pago) solo cuando el valor es claro. Cada categoría tiene su propia lógica de conexión y de presupuesto.

La disciplina de contexto importa más que el número de integraciones. 5-7 MCP activos es lo normal; 20 o más, context rot garantizado y calidad degradada. Mejor 6 MCP necesarios bien aprovechados que 20 "por si acaso" que frenan a Claude.

Siguiente lección

→ Despliegue 24/7: Cloudflare Workers: cómo trabaja un workflow mientras duermes. Sobre las revisiones y reglas automáticas, mira la lección Hooks: las reglas automáticas de Claude Code.