Crie uma ferramenta MCP para dados da web ao vivo

01O que acontece quando o assistente pede dados

• Seu app se conecta a https://api.everydata.io/mcp e pergunta quais ferramentas existem – por exemplo, amazon_product_by_asin, amazon_search, amazon_reviews, walmart_search, zalando_search, otto_search, youtube_video, youtube_comments e yahoo_quotes.
• Quando uma pergunta exige dados ao vivo, o modelo escolhe uma ferramenta e preenche as entradas, como um ASIN ou um ID de vídeo.
• A everydata.io carrega a página, retorna os dados e o modelo responde com eles.
• Sua chave de API acompanha cada requisição, então cada chamada de ferramenta conta no seu plano como uma requisição normal à API – com os mesmos pesos. Chamadas que falham do nosso lado não são cobradas.

Duas ferramentas cobrem todo o resto: list_endpoints lista cada endpoint de dados com suas entradas, e call_endpoint chama qualquer um deles. account_quota informa ao modelo quanto resta da sua cota mensal. A lista completa de ferramentas está na documentação do servidor MCP.

02Conecte o Claude Desktop

O jeito mais rápido: no Claude Desktop (ou no claude.ai), abra Settings → Connectors → Add custom connector e informe https://api.everydata.io/mcp. O Claude leva você à everydata.io, você entra pelo link enviado por e-mail e aprova o acesso – sem chave para copiar. Prefere usar uma chave de API? Conecte via mcp-remote, uma pequena ponte que o Claude Desktop inicia na sua máquina e que encaminha cada requisição – com sua chave – ao servidor hospedado, como mostrado abaixo.

Abra Settings → Developer → Edit config, adicione a entrada abaixo a claude_desktop_config.json, coloque sua chave depois de Bearer e reinicie o 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"
      }
    }
  }
}

A chave fica em env e o header não tem espaço depois dos dois-pontos de propósito: no Windows, o Claude Desktop não repassa corretamente espaços dentro de args, e o mcp-remote preenche ${EVERYDATA_AUTH} a partir de env. A mesma entrada funciona no macOS.

Depois de reiniciar, faça uma pergunta que exija dados ao vivo (veja o teste abaixo) – o Claude pede permissão para usar uma ferramenta da everydata. Se nenhuma ferramenta aparecer, Settings → Developer mostra se a ponte está rodando e o último erro. A causa mais comum é a falta do Node.js (npx não encontrado).

03Conecte o Claude Code

O Claude Code se comunica diretamente com servidores MCP remotos. Um único comando registra o servidor com sua chave:

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

Seu shell preenche $EVERYDATA_KEY quando você executa o comando, e o Claude Code salva o header nas configurações dele. Adicione --scope user para usar o servidor em todos os projetos, e não só no atual. Dentro do Claude Code, /mcp mostra a conexão e as ferramentas.

04Use pela API da OpenAI ou da Anthropic

Se você está criando seu próprio agente, as duas APIs podem chamar um servidor MCP remoto para você: você passa o endereço e a chave, e o provedor lista as ferramentas, chama-as e entrega os resultados ao modelo. Você não escreve nenhum código de ferramenta. Os dois exemplos leem sua chave da variável de ambiente EVERYDATA_KEY.

OpenAI Responses API – uma ferramenta mcp com a chave em 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 – o conector MCP recebe o servidor em mcp_servers, um mcp_toolset correspondente em tools e o header beta mcp-client-2025-11-20 (o SDK o define 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)

No app do ChatGPT, adicione um conector personalizado com a URL https://api.everydata.io/mcp (a opção depende do seu plano do ChatGPT). Você entra na everydata.io e aprova o acesso; é possível revogá-lo a qualquer momento no seu painel, em API keys.

05Teste: uma pergunta, uma chamada de ferramenta

Pergunte ao seu assistente “Quantas visualizações o vídeo Despacito tem no YouTube agora?”. O modelo escolhe youtube_video e envia o ID do vídeo:

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

A ferramenta retorna a mesma resposta que o endpoint REST, e o assistente responde com os números atuais. Exemplo documentado, abreviado:

{
  "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 chamada conta como uma requisição. Respostas muito longas – muitas avaliações ou resultados de busca – são encurtadas para o modelo, e a ferramenta o orienta a pedir menos, por exemplo uma página menor.

06Quando uma chamada de ferramenta falha

Os erros voltam ao modelo como uma chamada de ferramenta com falha, com o código de status no texto, então o assistente geralmente consegue dizer o que deu errado.

• 401 – a chave ou o login está ausente ou incorreto. Verifique se o header é Authorization: Bearer ds_… (ou envie a chave como x-api-key). Se você entrou por um conector, desconecte e conecte novamente.
• 429 – requisições demais ao mesmo tempo para o seu plano. Aguarde o número de segundos indicado na mensagem e tente novamente. Um 403 significa que a cota deste mês acabou; account_quota mostra quanto resta.
• 503 ou outro 5xx – o site não pôde ser carregado no momento. Essas chamadas não são cobradas; basta perguntar de novo um pouco mais tarde.
• Timeout – uma chamada de ferramenta tem 50 segundos. Páginas lentas (muitas avaliações, buscas grandes) podem demorar mais; a chamada então falha, não é cobrada, e uma requisição mais restrita costuma funcionar.

Os limites de cada plano estão em Limites e cota.

07Alternativa: rode seu próprio servidor MCP

Se você quer decidir exatamente quais endpoints e campos o modelo vê, pode escrever um pequeno servidor com o SDK oficial de MCP para Python (pip install "mcp[cli]>=2" requests, ou deixe o uv instalar os dois). Cada ferramenta é uma função: uma requisição à everydata.io e alguns campos selecionados. A docstring é o que o modelo lê.

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

O Claude Desktop inicia o script por conta própria. Use caminhos completos (which uv mostra onde está o uv), porque o Claude Desktop não é iniciado a partir do seu 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" }
    }
  }
}

No 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