Dados cripto ao vivo para o seu assistente de IA

O servidor MCP da Bitculator expõe o mercado cripto como 19 ferramentas curadas e somente leitura sobre o Model Context Protocol, um padrão aberto. Conecte uma vez e seu assistente responde com preços ao vivo, histórico, sentimento e inteligência de exchanges.

MCP (Model Context Protocol) é o padrão aberto que os clientes de IA usam para alcançar ferramentas externas. Qualquer cliente que suporte servidores remotos via Streamable HTTP pode usar a Bitculator - as seções abaixo cobrem os mais populares. O MCP é um produto próprio: é cobrado no seu próprio plano, com as suas próprias chaves e a sua própria franquia mensal de chamadas de ferramentas. Todos os preços, taxas, capitalizações de mercado e supplies são retornados como decimal strings para preservar a precisão, exatamente como na REST API.

Autenticação

O servidor autentica com chaves MCP: crie uma chave com a capacidade mcp no console MCP (o plano MCP gratuito funciona - sem cartão) e envie-a como cabeçalho Bearer em cada solicitação. Chaves da Data API e de widget são rejeitadas com 401 unauthenticated.

Authorization: Bearer YOUR_API_KEY

Solicitações sem uma chave válida recebem 401 unauthenticated. Chaves são segredos - configure-as nas configurações do seu cliente ou em uma variável de ambiente, nunca em arquivos compartilhados que você comita.

Claude Code

Um único comando registra o servidor para o seu projeto (ou adicione --scope user para deixá-lo disponível em todo lugar). O Claude escolhe a ferramenta certa automaticamente quando você pergunta sobre o mercado.

claude mcp add --transport http bitculator \
    https://bitculator.com/mcp \
    --header "Authorization: Bearer YOUR_API_KEY"

Cursor

Adicione o servidor a ~/.cursor/mcp.json (global) ou a .cursor/mcp.json em um projeto. As ferramentas aparecem no agente do Cursor assim que o arquivo é salvo.

{
  "mcpServers": {
    "bitculator": {
      "url": "https://bitculator.com/mcp",
      "headers": { "Authorization": "Bearer YOUR_API_KEY" }
    }
  }
}

VS Code

Adicione o servidor a .vscode/mcp.json no seu workspace. O modo agente do GitHub Copilot lista as ferramentas da Bitculator automaticamente.

{
  "servers": {
    "bitculator": {
      "type": "http",
      "url": "https://bitculator.com/mcp",
      "headers": { "Authorization": "Bearer YOUR_API_KEY" }
    }
  }
}

Claude API

Construindo seu próprio app na API da Anthropic? O conector MCP alcança o servidor diretamente de uma chamada à Messages API - passe sua chave MCP da Bitculator como o authorization_token.

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: mcp-client-2025-11-20" \
  -d '{
    "model": "claude-opus-4-8",
    "max_tokens": 1024,
    "mcp_servers": [{
      "type": "url",
      "url": "https://bitculator.com/mcp",
      "name": "bitculator",
      "authorization_token": "YOUR_API_KEY"
    }],
    "tools": [{ "type": "mcp_toolset", "mcp_server_name": "bitculator" }],
    "messages": [{ "role": "user", "content": "How is the crypto market today?" }]
  }'

ChatGPT

O ChatGPT se conecta a servidores MCP remotos pelo developer mode:

1. Ative o developer mode nas configurações do ChatGPT (Apps & Connectors → Advanced).
2. Adicione um conector com a URL do servidor https://bitculator.com/mcp.
3. A autenticação de conectores do ChatGPT é baseada em OAuth - cabeçalhos de chave de API ainda não são suportados lá, então use um cliente que aceite acesso sem autenticação ou as superfícies do Claude para acesso baseado em chave.

Um fluxo OAuth (e com ele o suporte completo aos diretórios do ChatGPT e do Claude) está no roadmap. Clientes baseados em chave - Claude Code, Cursor, VS Code, a Claude API - já funcionam hoje.

Cota e limites

O MCP é um produto autônomo com plano próprio, franquia mensal própria e slots de chave próprios - ele nunca consome a cota da sua Data API nem a de widgets.

• Cada chamada de ferramenta gasta uma chamada da franquia mensal do seu plano MCP (Free 2.500, Starter 50.000, Pro 250.000).
• O limite de rajada por minuto do seu plano MCP (Free 30, Starter 60, Pro 120) é aplicado ao endpoint inteiro, não apenas às chamadas de ferramentas - initialize, notifications/initialized, tools/list, resources/*, prompts/* e ping ocupam um slot cada. Uma chamada de ferramenta continua custando exatamente um: o pedido interno à Data API que ela dispara está isento da própria rajada.
• Acima da franquia, as ferramentas retornam um erro rate_limited que informa ao assistente quando o período é redefinido. Ferramentas acima do seu nível retornam plan_required.
• O handshake e as chamadas de descoberta não consomem nada da sua franquia mensal - só as chamadas de ferramentas consomem - mas gastam slots de rajada. Uma rejeição por rajada é um HTTP 429 no próprio pedido JSON-RPC, por isso o seu cliente reporta um erro de transporte e não um erro de ferramenta.

Frameworks de agentes

Construindo o seu próprio agente? Todos os grandes frameworks trazem um cliente MCP que se conecta via Streamable HTTP com uma chave MCP Bearer - os trechos abaixo carregam as 19 ferramentas como funções nativas.

from agents.mcp import MCPServerStreamableHttp

async with MCPServerStreamableHttp(
    name="Bitculator",
    params={"url": "https://bitculator.com/mcp",
            "headers": {"Authorization": "Bearer YOUR_API_KEY"}},
) as server:
    agent = Agent(name="analyst", mcp_servers=[server])

import { createMCPClient } from '@ai-sdk/mcp';

const mcp = await createMCPClient({
  transport: {
    type: 'http',
    url: 'https://bitculator.com/mcp',
    headers: { Authorization: 'Bearer YOUR_API_KEY' },
  },
});
const tools = await mcp.tools();

from langchain_mcp_adapters.client import MultiServerMCPClient

client = MultiServerMCPClient({"bitculator": {
    "transport": "http",
    "url": "https://bitculator.com/mcp",
    "headers": {"Authorization": "Bearer YOUR_API_KEY"},
}})
tools = await client.get_tools()

from llama_index.tools.mcp import BasicMCPClient, McpToolSpec

client = BasicMCPClient("https://bitculator.com/mcp",
                        headers={"Authorization": "Bearer YOUR_API_KEY"})
tools = await McpToolSpec(client=client).to_tool_list_async()

import { MCPClient } from '@mastra/mcp';

const mcp = new MCPClient({ servers: { bitculator: {
    url: new URL('https://bitculator.com/mcp'),
    requestInit: { headers: { Authorization: 'Bearer YOUR_API_KEY' } },
}}});
const tools = await mcp.getTools();

from semantic_kernel.connectors.mcp import MCPStreamableHttpPlugin

async with MCPStreamableHttpPlugin(
    name="Bitculator",
    url="https://bitculator.com/mcp",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
) as plugin:
    kernel.add_plugin(plugin)

Referência de ferramentas

Todas as 19 ferramentas são somente leitura. Os parâmetros espelham os endpoints correspondentes da Data API - mesma validação, mesma precisão em strings decimais - mas a restrição de plano de cada ferramenta vem do seu plano MCP.