Live-Krypto-Daten für deinen KI-Assistenten

Der Bitculator-MCP-Server stellt die Data API als 19 kuratierte, schreibgeschützte Tools über das offene Model Context Protocol bereit. Einmal verbinden - und dein Assistent antwortet mit Live-Kursen, Historie, Sentiment und Börsen-Intelligenz.

MCP (Model Context Protocol) ist der offene Standard, über den KI-Clients externe Tools erreichen. Jeder Client, der Remote-Server über Streamable HTTP unterstützt, kann Bitculator nutzen - die Abschnitte unten behandeln die gängigsten. Alle Preise, Kurse, Marktkapitalisierungen und Umlaufmengen werden als Dezimal-Strings zurückgegeben, um die Präzision zu erhalten - genau wie bei der REST API.

Authentifizierung

Der Server authentifiziert mit denselben Keys wie die Data API: Erstelle einen Key mit der data-api-Berechtigung in der Entwicklerkonsole (der Free-Plan genügt - keine Karte nötig) und sende ihn als Bearer-Header bei jeder Anfrage. Embed-Keys werden abgelehnt.

Authorization: Bearer YOUR_API_KEY

Anfragen ohne gültigen Key erhalten 401 unauthenticated. Keys sind Geheimnisse - hinterlege sie in den Einstellungen deines Clients oder einer Umgebungsvariable, niemals in geteilten Dateien, die du committest.

Claude Code

Ein einziger Befehl registriert den Server für dein Projekt (oder ergänze --scope user, um ihn überall verfügbar zu machen). Claude wählt automatisch das richtige Tool, wenn du nach dem Markt fragst.

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

Cursor

Trage den Server in ~/.cursor/mcp.json (global) oder .cursor/mcp.json in einem Projekt ein. Die Tools erscheinen in Cursors Agent, sobald die Datei gespeichert ist.

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

VS Code

Trage den Server in .vscode/mcp.json deines Workspace ein. Der Agent-Modus von GitHub Copilot listet die Bitculator-Tools automatisch auf.

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

Claude API

Du baust deine eigene App auf der Anthropic API? Der MCP-Connector erreicht den Server direkt aus einem Messages-API-Aufruf - übergib deinen Bitculator-Key als 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 verbindet sich mit Remote-MCP-Servern über den Entwicklermodus:

1. Aktiviere den Entwicklermodus in den ChatGPT-Einstellungen (Apps & Connectors → Advanced).
2. Füge einen Connector mit der Server-URL https://bitculator.com/mcp hinzu.
3. Die Connector-Authentifizierung von ChatGPT ist OAuth-basiert - API-Key-Header werden dort noch nicht unterstützt. Nutze für Key-basierten Zugriff daher einen Client, der ohne Auth auskommt, oder die Claude-Oberflächen.

Ein OAuth-Flow (und damit volle Unterstützung der ChatGPT- und Claude-Verzeichnisse) steht auf der Roadmap. Key-basierte Clients - Claude Code, Cursor, VS Code, die Claude API - funktionieren schon heute.

Kontingent & Limits

MCP ist eine Konsum-Oberfläche der Data API - es gibt keine separate MCP-Rechnung und keinen separaten Pool.

• Jeder Tool-Aufruf zählt als eine Data-API-Anfrage gegen das Monatskontingent deines Plans.
• Das Pro-Minute-Burst-Limit deines Plans gilt pro Tool-Aufruf (Free 30, Starter 60, Pro 120).
• Über dem Kontingent liefern die Tools einen rate_limited-Fehler, der dem Assistenten mitteilt, wann sich der Pool zurücksetzt. Plan-beschränkte Endpunkte liefern plan_required.
• Der Protokoll-Handshake (initialize, tools/list) ist kostenlos - nur Tool-Aufrufe schöpfen aus dem Pool.

Agent-Frameworks

Du baust deinen eigenen Agenten? Jedes große Framework bringt einen MCP-Client mit, der sich per Streamable HTTP mit Bearer-Header verbindet - die Snippets unten laden alle 19 Tools wie native Funktionen.

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

Alle 19 Tools sind schreibgeschützt. Die Parameter spiegeln die entsprechenden Data-API-Endpunkte - gleiche Validierung, gleiche Plan-Schranken, gleiche Dezimal-String-Präzision.