Crea una herramienta MCP para datos web en directo

01Qué pasa cuando el asistente pide datos

• Tu app se conecta a https://api.everydata.io/mcp y pregunta qué herramientas hay, por ejemplo amazon_product_by_asin, amazon_search, amazon_reviews, walmart_search, zalando_search, otto_search, youtube_video, youtube_comments y yahoo_quotes.
• Cuando una pregunta necesita datos en directo, el modelo elige una herramienta y rellena sus entradas, como un ASIN o el ID de un vídeo.
• everydata.io carga la página, devuelve los datos y el modelo responde con ellos.
• Tu clave de API acompaña cada solicitud, así que cada llamada a una herramienta cuenta en tu plan como una solicitud normal a la API, con los mismos pesos. Las llamadas que fallan por nuestra parte no se cobran.

Dos herramientas cubren todo lo demás: list_endpoints lista todos los endpoints de datos con sus entradas y call_endpoint llama a cualquiera de ellos. account_quota le dice al modelo cuánto te queda de la cuota mensual. La lista completa de herramientas está en la documentación del servidor MCP.

02Conecta Claude Desktop

La forma más rápida: en Claude Desktop (o claude.ai) abre Settings → Connectors → Add custom connector e introduce https://api.everydata.io/mcp. Claude te lleva a everydata.io, inicias sesión con el enlace que recibes por e-mail y apruebas el acceso, sin copiar ninguna clave. ¿Prefieres usar una clave de API? Conéctate a través de mcp-remote, un pequeño puente que Claude Desktop inicia en tu equipo y que reenvía cada solicitud, con tu clave, al servidor alojado, como se muestra abajo.

Abre Settings → Developer → Edit config, añade la entrada de abajo a claude_desktop_config.json, pon tu clave después de Bearer y reinicia Claude Desktop.

{
  "mcpServers": {
    "everydata": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://api.everydata.io/mcp",
        "--header",
        "Authorization:${EVERYDATA_AUTH}"
      ],
      "env": {
        "EVERYDATA_AUTH": "Bearer ds_your_key"
      }
    }
  }
}

La clave está en env y la cabecera no lleva espacio después de los dos puntos a propósito: Claude Desktop en Windows no transmite bien los espacios dentro de args, y mcp-remote rellena ${EVERYDATA_AUTH} a partir de env. La misma entrada funciona en macOS.

Tras reiniciar, haz una pregunta que necesite datos en directo (consulta la prueba de abajo): Claude pedirá permiso para usar una herramienta de everydata. Si no aparece ninguna herramienta, Settings → Developer muestra si el puente se está ejecutando y su último error. La causa más habitual es que falte Node.js (npx no encontrado).

03Conecta Claude Code

Claude Code se comunica directamente con servidores MCP remotos. Un solo comando registra el servidor con tu clave:

export EVERYDATA_KEY="ds_your_key"
claude mcp add --transport http everydata https://api.everydata.io/mcp \
  --header "Authorization: Bearer $EVERYDATA_KEY"

# check that it is connected
claude mcp list

Tu shell rellena $EVERYDATA_KEY al ejecutar el comando, y Claude Code guarda la cabecera en su configuración. Añade --scope user para usar el servidor en todos los proyectos, no solo en el actual. Dentro de Claude Code, /mcp muestra la conexión y sus herramientas.

04Úsalo desde la API de OpenAI o de Anthropic

Si creas tu propio agente, ambas APIs pueden llamar por ti a un servidor MCP remoto: pasas la dirección y la clave, y el proveedor lista las herramientas, las llama y entrega los resultados al modelo. No escribes código de herramientas. Ambos ejemplos leen tu clave de la variable de entorno EVERYDATA_KEY.

OpenAI Responses API: una herramienta mcp con la clave en headers:

import os

from openai import OpenAI

client = OpenAI()

resp = client.responses.create(
    model="gpt-6-astra",
    input="How many views does the Despacito video on YouTube have right now?",
    tools=[{
        "type": "mcp",
        "server_label": "everydata",
        "server_url": "https://api.everydata.io/mcp",
        "headers": {"Authorization": f"Bearer {os.environ['EVERYDATA_KEY']}"},
        "require_approval": "never",
    }],
)
print(resp.output_text)

Anthropic Messages API: el conector MCP recibe el servidor en mcp_servers, un mcp_toolset correspondiente en tools y la cabecera beta mcp-client-2025-11-20 (el SDK la establece a partir de betas):

import os

import anthropic

client = anthropic.Anthropic()

resp = client.beta.messages.create(
    model="claude-opus-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "How many views does the Despacito video on YouTube have right now?"}],
    mcp_servers=[{
        "type": "url",
        "url": "https://api.everydata.io/mcp",
        "name": "everydata",
        "authorization_token": os.environ["EVERYDATA_KEY"],  # sent as "Authorization: Bearer …"
    }],
    tools=[{"type": "mcp_toolset", "mcp_server_name": "everydata"}],
    betas=["mcp-client-2025-11-20"],
)
print(resp.content[-1].text)

En la app de ChatGPT, añade un conector personalizado con la URL https://api.everydata.io/mcp (la opción depende de tu plan de ChatGPT). Iniciarás sesión en everydata.io y aprobarás el acceso; puedes revocarlo cuando quieras en tu panel, en la sección de claves de API.

05Pruébalo: una pregunta, una llamada a herramienta

Pregunta a tu asistente “¿Cuántas visualizaciones tiene ahora mismo el vídeo de Despacito en YouTube?”. El modelo elige youtube_video y envía el ID del vídeo:

{
  "name": "youtube_video",
  "arguments": { "id": "kJQP7kiw5Fk" }
}

La herramienta devuelve la misma respuesta que el endpoint REST y el asistente contesta con las cifras actuales. Ejemplo documentado, reducido:

{
  "responseStatus": "PAGE_FOUND",
  "responseMessage": "Page successfully found!",
  "videoId": "kJQP7kiw5Fk",
  "title": "Luis Fonsi - Despacito ft. Daddy Yankee",
  "channelName": "LuisFonsiVEVO",
  "viewCount": 9125159593,
  "likeCount": 56673581,
  "commentCount": 4300000,
  "publishedAt": "2017-01-12T21:00:02-08:00"
}

Esta llamada cuenta como una solicitud. Las respuestas muy largas (muchas reseñas o resultados de búsqueda) se acortan para el modelo, y la herramienta le indica que pida menos, por ejemplo una página más pequeña.

06Cuando falla una llamada a una herramienta

Los errores llegan al modelo como una llamada a herramienta fallida con el código de estado en el texto, así que el asistente normalmente puede decirte qué ha fallado.

• 401: falta la clave o el inicio de sesión, o son incorrectos. Comprueba que la cabecera sea Authorization: Bearer ds_… (o envía la clave como x-api-key). Si usas un conector con inicio de sesión, desconéctalo y vuelve a conectarlo.
• 429: demasiadas solicitudes a la vez para tu plan. Espera los segundos que indica el mensaje y vuelve a intentarlo. Un 403 significa que la cuota de este mes se ha agotado; account_quota muestra lo que queda.
• 503 u otro 5xx: no se ha podido cargar el sitio en este momento. Estas llamadas no se cobran; simplemente vuelve a preguntar un poco más tarde.
• Timeout: una llamada a herramienta dispone de 50 segundos. Las páginas lentas (muchas reseñas, búsquedas grandes) pueden tardar más; la llamada falla entonces, no se cobra y una solicitud más acotada suele funcionar.

Los límites de cada plan están en Límites y cuota.

07Alternativa: ejecuta tu propio servidor MCP

Si quieres decidir exactamente qué endpoints y campos ve el modelo, puedes escribir tú mismo un pequeño servidor con el SDK oficial de MCP para Python (pip install "mcp[cli]>=2" requests, o deja que uv instale ambos). Cada herramienta es una función: una solicitud a everydata.io y unos pocos campos seleccionados. El docstring es lo que lee el modelo.

"""A minimal MCP server that gives AI assistants live product and video data from everydata.io."""
import os

import requests
from mcp.server.mcpserver import MCPServer

API = "https://api.everydata.io"
KEY = os.environ["EVERYDATA_API_KEY"]

mcp = MCPServer("everydata")


def _get(path: str, params: dict) -> dict:
    """One everydata.io request. Errors come back as data, so the assistant can explain them."""
    try:
        resp = requests.get(f"{API}{path}", params=params, headers={"x-api-key": KEY}, timeout=60)
    except requests.RequestException as exc:
        return {"error": "network", "detail": str(exc)[:300]}
    if resp.status_code >= 400:  # e.g. 429 = too many requests at once, 5xx = page could not be loaded
        return {"error": resp.status_code, "detail": resp.text[:300]}
    return resp.json()


def _pick(data: dict, keys: tuple) -> dict:
    return data if "error" in data else {k: data.get(k) for k in keys}


@mcp.tool()
def amazon_product(asin: str, domainCode: str = "com") -> dict:
    """Live title, price, list price, availability and rating of an Amazon product.
    asin is the 10-character product ID; domainCode is the marketplace (com, de, co.uk …).
    A price of 0 means the page shows no price right now."""
    data = _get("/amz/amazon-lookup-product-by-asin", {"asin": asin, "domainCode": domainCode})
    return _pick(data, ("productTitle", "asin", "price", "retailPrice", "currency",
                        "productRating", "countReview", "warehouseAvailability"))


@mcp.tool()
def zalando_search(keyword: str, page: int = 1) -> dict:
    """Search the Zalando shop (zalando.de by default) and return up to 10 products with price and link."""
    data = _get("/zal/zalando-search-by-keyword", {"keyword": keyword, "page": page})
    if "error" in data:
        return data
    keep = ("productDescription", "manufacturer", "price", "retailPrice", "currency", "dpUrl")
    return {"results": [{k: p.get(k) for k in keep} for p in data.get("searchProductDetails", [])[:10]]}


@mcp.tool()
def youtube_video(video: str) -> dict:
    """Current view, like and comment counts of a YouTube video. video is the video ID or its URL."""
    data = _get("/ytb/youtube-video-details", {"id": video})
    return _pick(data, ("videoId", "title", "channelName", "viewCount", "likeCount", "commentCount", "publishedAt"))


if __name__ == "__main__":
    mcp.run()  # the assistant app starts this script and talks to it directly

Claude Desktop inicia el script por su cuenta. Usa rutas completas (which uv muestra dónde está uv), porque Claude Desktop no se inicia desde tu terminal:

{
  "mcpServers": {
    "everydata-local": {
      "command": "/Users/you/.local/bin/uv",
      "args": ["run", "--with", "mcp[cli]>=2", "--with", "requests",
               "python", "/Users/you/everydata-mcp/server.py"],
      "env": { "EVERYDATA_API_KEY": "ds_your_key" }
    }
  }
}

En Claude Code:

claude mcp add everydata-local --env EVERYDATA_API_KEY=ds_your_key -- uv run --with "mcp[cli]>=2" --with requests python /absolute/path/to/server.py