Dados cripto ao vivo para o seu assistente de IA

O servidor MCP da Bitculator expõe a Data API 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. 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 as mesmas chaves da Data API: crie uma chave com a capacidade data-api no console de desenvolvedor (o plano gratuito funciona — sem cartão) e envie-a como cabeçalho Bearer em cada solicitação. Chaves de embed são rejeitadas.

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 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 é uma superfície de consumo da Data API — não há fatura nem pool separados para o MCP.

• Cada chamada de ferramenta conta como uma solicitação à Data API na cota mensal do seu plano.
• O limite de rajada por minuto do seu plano se aplica por chamada de ferramenta (Free 30, Starter 60, Pro 120).
• Acima da cota, as ferramentas retornam um erro rate_limited que informa ao assistente quando o pool é redefinido. Endpoints restritos a planos retornam plan_required.
• O handshake do protocolo (initialize, tools/list) é gratuito — apenas chamadas de ferramentas consomem do pool.

Frameworks de agentes

Construindo o seu próprio agente? Todos os grandes frameworks trazem um cliente MCP que se conecta via Streamable HTTP com um cabeçalho 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, mesmas restrições de plano, mesma precisão em strings decimais.