Créer un outil MCP pour des données web en direct

01Ce qui se passe quand l'assistant demande des données

• Votre application se connecte à https://api.everydata.io/mcp et demande quels outils sont disponibles – par exemple amazon_product_by_asin, amazon_search, amazon_reviews, walmart_search, zalando_search, otto_search, youtube_video, youtube_comments et yahoo_quotes.
• Quand une question nécessite des données en direct, le modèle choisit un outil et renseigne ses entrées, comme un ASIN ou un ID de vidéo.
• everydata.io charge la page, renvoie les données, et le modèle s'en sert pour répondre.
• Votre clé API accompagne chaque requête : chaque appel d'outil est décompté de votre offre comme une requête API normale – avec les mêmes pondérations. Les appels qui échouent de notre côté ne sont pas facturés.

Deux outils couvrent tout le reste : list_endpoints liste chaque endpoint de données avec ses entrées, et call_endpoint appelle n'importe lequel d'entre eux. account_quota indique au modèle combien il reste de votre quota mensuel. La liste complète des outils se trouve dans la documentation du serveur MCP.

02Connecter Claude Desktop

Le plus rapide : dans Claude Desktop (ou claude.ai), ouvrez Paramètres → Connecteurs → Ajouter un connecteur personnalisé et saisissez https://api.everydata.io/mcp. Claude vous redirige vers everydata.io, vous vous connectez via le lien reçu par e-mail et approuvez l'accès – aucune clé à copier. Vous préférez utiliser une clé API ? Connectez-vous via mcp-remote, un petit pont que Claude Desktop lance sur votre machine et qui transmet chaque requête – avec votre clé – au serveur hébergé, comme ci-dessous.

Ouvrez Paramètres → Développeur → Modifier la configuration, ajoutez l'entrée ci-dessous à claude_desktop_config.json, placez votre clé après Bearer et redémarrez 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 clé se trouve dans env et l'en-tête n'a volontairement pas d'espace après les deux-points : sous Windows, Claude Desktop ne transmet pas correctement les espaces contenus dans args, et mcp-remote remplace ${EVERYDATA_AUTH} par la valeur de env. La même entrée fonctionne sous macOS.

Après le redémarrage, posez une question qui nécessite des données en direct (voir le test ci-dessous) – Claude vous demande l'autorisation d'utiliser un outil everydata. Si aucun outil n'apparaît, Paramètres → Développeur indique si le pont tourne et affiche sa dernière erreur. L'absence de Node.js (npx introuvable) est la cause la plus fréquente.

03Connecter Claude Code

Claude Code communique directement avec les serveurs MCP distants. Une seule commande enregistre le serveur avec votre clé :

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

Votre shell remplace $EVERYDATA_KEY lorsque vous lancez la commande, et Claude Code enregistre l'en-tête dans ses paramètres. Ajoutez --scope user pour utiliser le serveur dans tous vos projets, pas seulement le projet courant. Dans Claude Code, /mcp affiche la connexion et ses outils.

04L'utiliser depuis l'API OpenAI ou Anthropic

Si vous construisez votre propre agent, les deux API peuvent appeler un serveur MCP distant à votre place : vous passez l'adresse et la clé, et le fournisseur liste les outils, les appelle et transmet les résultats au modèle. Vous n'écrivez aucun code d'outil vous-même. Les deux exemples lisent votre clé dans la variable d'environnement EVERYDATA_KEY.

API Responses d'OpenAI – un outil mcp avec la clé dans 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)

API Messages d'Anthropic – le connecteur MCP prend le serveur dans mcp_servers, un mcp_toolset correspondant dans tools et l'en-tête bêta mcp-client-2025-11-20 (le SDK le définit à 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)

Dans l'application ChatGPT, ajoutez un connecteur personnalisé avec l'URL https://api.everydata.io/mcp (l'option dépend de votre abonnement ChatGPT). Vous vous connecterez à everydata.io et approuverez l'accès ; vous pouvez le révoquer à tout moment dans votre tableau de bord, sous Clés API.

05Essayez : une question, un appel d'outil

Demandez à votre assistant « Combien de vues la vidéo Despacito a-t-elle sur YouTube en ce moment ? ». Le modèle choisit youtube_video et envoie l'ID de la vidéo :

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

L'outil renvoie la même réponse que l'endpoint REST, et l'assistant répond avec les chiffres actuels. Exemple documenté abrégé :

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

Cet appel compte pour une requête. Les réponses très longues – beaucoup d'avis ou de résultats de recherche – sont raccourcies pour le modèle, et l'outil lui indique de demander moins, par exemple une page plus petite.

06Quand un appel d'outil échoue

Les erreurs reviennent au modèle sous forme d'appel d'outil échoué avec le code de statut dans le texte : l'assistant peut généralement vous dire ce qui n'a pas fonctionné.

• 401 – la clé ou la connexion est absente ou incorrecte. Vérifiez que l'en-tête est bien Authorization: Bearer ds_… (ou envoyez la clé dans x-api-key). Avec une connexion par connecteur, déconnectez-vous puis reconnectez-vous.
• 429 – trop de requêtes simultanées pour votre offre. Attendez le nombre de secondes indiqué dans le message et réessayez. Un 403 signifie que le quota du mois est épuisé ; account_quota indique ce qu'il reste.
• 503 ou un autre 5xx – le site n'a pas pu être chargé pour l'instant. Ces appels ne sont pas facturés ; reposez simplement la question un peu plus tard.
• Délai dépassé – un appel d'outil dispose de 50 secondes. Les pages lentes (beaucoup d'avis, grandes recherches) peuvent prendre plus de temps ; l'appel échoue alors sans être facturé, et une requête plus ciblée fonctionne généralement.

Les limites de chaque offre figurent dans Limites et quota.

07Alternative : faire tourner votre propre serveur MCP

Si vous voulez décider précisément quels endpoints et quels champs le modèle voit, vous pouvez écrire vous-même un petit serveur avec le SDK Python officiel de MCP (pip install "mcp[cli]>=2" requests, ou laissez uv installer les deux). Chaque outil est une fonction : une requête everydata.io, quelques champs sélectionnés. La docstring est ce que lit le modèle.

"""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 lance le script lui-même. Utilisez des chemins complets (which uv indique où se trouve uv), car Claude Desktop ne démarre pas depuis votre 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" }
    }
  }
}

Dans 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