Live crypto data for your AI assistant

The Bitculator MCP server exposes the Data API as 19 curated, read-only tools over the open Model Context Protocol. Connect once and your assistant answers with live prices, history, sentiment, and exchange intelligence.

MCP (Model Context Protocol) is the open standard AI clients use to reach external tools. Any client that supports remote servers over Streamable HTTP can use Bitculator — the sections below cover the popular ones. All prices, rates, market caps, and supplies are returned as decimal strings to preserve precision, exactly like the REST API.

Authentication

The server authenticates with the same keys as the Data API: create a key with the data-api ability in the developer console (the free plan works — no card required) and send it as a Bearer header on every request. Embed keys are rejected.

Authorization: Bearer YOUR_API_KEY

Requests without a valid key receive 401 unauthenticated. Keys are secrets — configure them in your client's settings or an environment variable, never in shared files you commit.

Claude Code

One command registers the server for your project (or add --scope user to make it available everywhere). Claude picks the right tool automatically when you ask about the market.

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

Cursor

Add the server to ~/.cursor/mcp.json (global) or .cursor/mcp.json in a project. The tools appear in Cursor's agent once the file is saved.

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

VS Code

Add the server to .vscode/mcp.json in your workspace. GitHub Copilot's agent mode lists the Bitculator tools automatically.

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

Claude API

Building your own app on the Anthropic API? The MCP connector reaches the server directly from a Messages API call — pass your Bitculator key as the 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

ChatGPT connects to remote MCP servers through developer mode:

1. Enable developer mode in ChatGPT's settings (Apps & Connectors → Advanced).
2. Add a connector with the server URL https://bitculator.com/mcp.
3. ChatGPT's connector auth is OAuth-based — API-key headers are not supported there yet, so use a no-auth-capable client or the Claude surfaces for key-based access.

An OAuth flow (and with it full ChatGPT + Claude directory support) is on the roadmap. Key-based clients — Claude Code, Cursor, VS Code, the Claude API — work today.

Quota & limits

MCP is a consumption surface of the Data API — there is no separate MCP bill or pool.

• Every tool call counts as one Data API request against your plan's monthly quota.
• The per-minute burst limit of your plan applies per tool call (Free 30, Starter 60, Pro 120).
• Over quota, tools return a rate_limited error that tells the assistant when the pool resets. Plan-gated endpoints return plan_required.
• The protocol handshake (initialize, tools/list) is free — only tool calls draw from the pool.

Agent frameworks

Building your own agent? Every major framework ships an MCP client that connects over Streamable HTTP with a Bearer header - the snippets below load all 19 tools as native functions.

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)

Tool reference

All 19 tools are read-only. Parameters mirror the corresponding Data API endpoints — same validation, same plan gates, same decimal-string precision.