Ein MCP-Tool für Live-Webdaten bauen

01Was passiert, wenn der Assistent Daten anfordert

• Ihre App verbindet sich mit https://api.everydata.io/mcp und fragt, welche Tools es gibt – zum Beispiel amazon_product_by_asin, amazon_search, amazon_reviews, walmart_search, zalando_search, otto_search, youtube_video, youtube_comments und yahoo_quotes.
• Braucht eine Frage Live-Daten, wählt das Modell ein Tool und füllt dessen Eingaben aus, etwa eine ASIN oder eine Video-ID.
• everydata.io lädt die Seite und liefert die Daten, und das Modell antwortet damit.
• Ihr API-Schlüssel wird mit jeder Anfrage gesendet, jeder Tool-Aufruf zählt also wie eine normale API-Anfrage gegen Ihren Tarif – mit denselben Gewichtungen. Aufrufe, die auf unserer Seite fehlschlagen, werden nicht berechnet.

Zwei Tools decken alles Weitere ab: list_endpoints listet jeden Daten-Endpoint mit seinen Eingaben, und call_endpoint ruft jeden davon auf. account_quota sagt dem Modell, wie viel von Ihrem Monatskontingent noch übrig ist. Die vollständige Tool-Liste steht in der Dokumentation zum MCP-Server.

02Claude Desktop verbinden

Der schnellste Weg: Öffnen Sie in Claude Desktop (oder auf claude.ai) Settings → Connectors → Add custom connector und geben Sie https://api.everydata.io/mcp ein. Claude leitet Sie zu everydata.io weiter, Sie melden sich per E-Mail-Link an und genehmigen den Zugriff – kein Schlüssel zum Kopieren. Sie möchten lieber einen API-Schlüssel verwenden? Verbinden Sie sich über mcp-remote, eine kleine Brücke, die Claude Desktop auf Ihrem Rechner startet und die jede Anfrage – mit Ihrem Schlüssel – an den gehosteten Server weiterleitet, wie unten gezeigt.

Öffnen Sie Settings → Developer → Edit config, fügen Sie den Eintrag unten in claude_desktop_config.json ein, setzen Sie Ihren Schlüssel hinter Bearer und starten Sie Claude Desktop neu.

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

Der Schlüssel steht in env, und im Header folgt dem Doppelpunkt absichtlich kein Leerzeichen: Claude Desktop unter Windows reicht Leerzeichen innerhalb von args nicht korrekt weiter, und mcp-remote setzt ${EVERYDATA_AUTH} aus env ein. Derselbe Eintrag funktioniert unter macOS.

Stellen Sie nach dem Neustart eine Frage, die Live-Daten braucht (siehe Test unten) – Claude bittet um Erlaubnis, ein everydata-Tool zu verwenden. Erscheinen keine Tools, zeigt Settings → Developer, ob die Brücke läuft und welchen Fehler sie zuletzt gemeldet hat. Die häufigste Ursache ist ein fehlendes Node.js (npx nicht gefunden).

03Claude Code verbinden

Claude Code spricht direkt mit Remote-MCP-Servern. Ein einziger Befehl registriert den Server mit Ihrem Schlüssel:

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

Ihre Shell setzt $EVERYDATA_KEY beim Ausführen des Befehls ein, und Claude Code speichert den Header in seinen Einstellungen. Ergänzen Sie --scope user, um den Server in jedem Projekt statt nur im aktuellen zu nutzen. In Claude Code zeigt /mcp die Verbindung und ihre Tools.

04Über die API von OpenAI oder Anthropic nutzen

Wenn Sie einen eigenen Agenten bauen, können beide APIs einen Remote-MCP-Server für Sie aufrufen: Sie übergeben Adresse und Schlüssel, und der Anbieter listet die Tools, ruft sie auf und übergibt die Ergebnisse an das Modell. Eigenen Tool-Code schreiben Sie nicht. Beide Beispiele lesen Ihren Schlüssel aus der Umgebungsvariablen EVERYDATA_KEY.

OpenAI Responses API – ein mcp-Tool mit dem Schlüssel in 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 – der MCP-Connector erwartet den Server in mcp_servers, ein passendes mcp_toolset in tools und den Beta-Header mcp-client-2025-11-20 (das SDK setzt ihn aus 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)

Fügen Sie in der ChatGPT-App einen benutzerdefinierten Connector mit der URL https://api.everydata.io/mcp hinzu (die Option hängt von Ihrem ChatGPT-Tarif ab). Sie melden sich bei everydata.io an und genehmigen den Zugriff; widerrufen können Sie ihn jederzeit in Ihrem Dashboard unter API-Schlüssel.

05Ausprobieren: eine Frage, ein Tool-Aufruf

Fragen Sie Ihren Assistenten: „Wie viele Aufrufe hat das Despacito-Video auf YouTube gerade?“ Das Modell wählt youtube_video und sendet die Video-ID:

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

Das Tool liefert dieselbe Antwort wie der REST-Endpoint, und der Assistent antwortet mit den aktuellen Zahlen. Gekürztes dokumentiertes Beispiel:

{
  "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"
}

Dieser Aufruf zählt als eine Anfrage. Sehr lange Antworten – viele Rezensionen oder Suchergebnisse – werden für das Modell gekürzt, und das Tool fordert es auf, weniger anzufragen, zum Beispiel eine kleinere Seite.

06Wenn ein Tool-Aufruf fehlschlägt

Fehler gehen als fehlgeschlagener Tool-Aufruf mit dem Statuscode im Text an das Modell zurück, sodass der Assistent Ihnen meist sagen kann, was schiefgelaufen ist.

• 401 – der Schlüssel oder die Anmeldung fehlt oder ist falsch. Prüfen Sie, ob der Header Authorization: Bearer ds_… lautet (oder senden Sie den Schlüssel als x-api-key). Bei einer Connector-Anmeldung trennen Sie die Verbindung und verbinden sich neu.
• 429 – zu viele gleichzeitige Anfragen für Ihren Tarif. Warten Sie die in der Meldung genannte Anzahl Sekunden und versuchen Sie es erneut. Ein 403 bedeutet, dass das Kontingent dieses Monats aufgebraucht ist; account_quota zeigt, was übrig ist.
• 503 oder ein anderer 5xx – die Seite konnte gerade nicht geladen werden. Diese Aufrufe werden nicht berechnet; fragen Sie einfach etwas später noch einmal.
• Timeout – ein Tool-Aufruf hat 50 Sekunden Zeit. Langsame Seiten (viele Rezensionen, große Suchen) können länger brauchen; der Aufruf schlägt dann fehl, wird nicht berechnet, und eine enger gefasste Anfrage funktioniert meist.

Die Grenzen pro Tarif stehen unter Limits & Kontingent.

07Alternative: einen eigenen MCP-Server betreiben

Wenn Sie genau festlegen möchten, welche Endpoints und Felder das Modell sieht, können Sie mit dem offiziellen MCP Python SDK selbst einen kleinen Server schreiben (pip install "mcp[cli]>=2" requests, oder lassen Sie uv beides installieren). Jedes Tool ist eine Funktion: eine everydata.io-Anfrage, ein paar ausgewählte Felder. Den Docstring liest das Modell.

"""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 startet das Skript selbst. Verwenden Sie vollständige Pfade (which uv zeigt, wo uv liegt), weil Claude Desktop nicht aus Ihrem Terminal heraus startet:

{
  "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" }
    }
  }
}

In 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