Crypto Market Data MCP

Communauté Finance et paiements

Crypto market data from Bybit, Binance, OKX, Hyperliquid, Gate and KuCoin: prices, funding rates, open interest, order books, candles and funding arbitrage.

Installation

Les étapes d'installation sont dans la documentation ci-dessous. Documentation

Documentation

Tirée du README du projet sur GitHub, actualisée chaque semaine. Les liens ouvrent GitHub.

Sommaire
  1. Crypto Market Data MCP Server
  2. Connect via MCPize
  3. Tools (13)
  4. Robustness
  5. Run locally
  6. Authentication & billing (HTTP mode)
  7. Roadmap

Crypto Market Data MCP Server

A read-only Model Context Protocol server that gives any AI agent (Claude, Cursor, Cline, Windsurf…) live cryptocurrency market data across 100+ exchanges via CCXT. No API keys required — everything uses public endpoints.

Supported exchanges: bybit, binance, okx, hyperliquid, gate, kucoin (add more CCXT ids in SUPPORTED_EXCHANGES).

Connect via MCPize

Use this MCP server instantly with no local installation:

npx -y mcpize connect @eliasfire617/crypto-market-data --client claude

Or connect at: **https://mcpize.com/mcp/crypto-market-data**

Tools (13)

Discovery

ToolWhat it does
list_exchangesWhich exchanges are supported
get_capabilitiesMatrix of which exchange supports which data (no network)
search_symbolsFind the exact symbol format for a coin

Market data

ToolWhat it does
get_priceLast price + 24h stats
get_order_bookTop-of-book bids/asks
get_ohlcvRecent OHLCV candles
get_recent_tradesLatest public trades

Derivatives

ToolWhat it does
get_funding_rateCurrent perpetual funding rate
get_funding_rate_historyHistorical funding rates
compare_fundingFunding rate across many exchanges + arb spread
get_open_interestCurrent open interest
get_long_short_ratioGlobal long/short account ratio (Binance)
get_liquidationsRecent public liquidations (limited support)

compare_funding is the differentiator: it surfaces funding-rate arbitrage opportunities (which venue pays the most vs least) in one concurrent call. Rates are annualized (apr_pct) before comparing — venues fund at different cadences (Hyperliquid hourly vs 8h elsewhere), so raw rates aren't comparable.

Want the analysis, not just the data? The companion server **Crypto Derivatives Intelligence** builds on this data: funding-carry opportunities netted of fees (breakeven days, executable depth), OI-price divergence, liquidation zones, positioning extremes, and market-regime classification — one tool call each.

Robustness

Built for production, not a demo:

  • Retries with exponential backoff on transient network errors (3 attempts).
  • Per-request + overall timeouts (10s / 25s) so a hung exchange can't stall a call.
  • Capability guards: never calls a method an exchange lacks — returns a clean error listing which exchanges do support it (see get_capabilities).
  • Structured errors ({"error": {type, message, retryable, supported_exchanges}}) instead of crashes — agents always get a parseable response.
  • TTL response cache (~660x faster on repeat calls; eases rate limits).
  • Input validation and clamped limits on every tool.
  • Guaranteed exchange cleanup; logs to stderr only (safe for stdio transport).

Run locally

python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

# stdio transport (Claude Desktop, Cursor, Cline) — local, no auth:
python server.py

# OR streamable HTTP (hosted / remote) — API-key auth + rate limiting ON:
python server.py --http                 # binds :8000 (override with PORT=8799)

Authentication & billing (HTTP mode)

The hosted HTTP transport is gated — this is what makes it billable. Local stdio stays open for single-user dev.

  • Clients send Authorization: Bearer <api-key>.
  • Each key maps to a client_id and a tier; unknown/missing keys get 401.
  • Tiers (auth.py → TIERS) set per-minute rate + monthly quota:
    Tierreq/minmonthly quota
    free101,000
    pro120100,000
    ultra6002,000,000
  • Over the limit → a clean ToolError (Rate limit exceeded… / Monthly quota exceeded…), never a crash.

Configure keys (either source; file wins):

# inline
export CRYPTO_MCP_API_KEYS="sk_live_abc:acme:pro,sk_live_xyz:jane:free"
# or a file (see api_keys.example.json)
export CRYPTO_MCP_API_KEYS_FILE=./api_keys.json

If no keys are set in HTTP mode, a throwaway demo key (tier=pro) is generated and printed to stderr so you can test immediately.

Behind a gateway (e.g. MCPize)

If you deploy behind a platform that already authenticates and rate-limits subscribers, set CRYPTO_MCP_DISABLE_AUTH=1. The server then trusts the gateway and skips its own auth + rate limiting — no double authentication, no double throttling. Only do this when the container is reachable solely through that gateway.

Use with Claude Desktop

Copy claude_desktop_config.example.json into your Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json on macOS, %APPDATA%\Claude\claude_desktop_config.json on Windows), adjusting paths.

Symbols
  • Spot: BTC/USDT
  • Perpetual: BTC/USDT:USDT
  • Common shorthand is normalized automatically: btc, BTCUSDT, BTC-USDT all work (funding/OI tools land on the perp form).

Roadmap

  • Add more exchanges to SUPPORTED_EXCHANGES.
  • More aggressive caching of hot symbols to cut latency.
  • Optional websocket streaming for live order book / trades.

Questions fréquentes

Qu'est-ce que Crypto Market Data MCP ?

Crypto market data from Bybit, Binance, OKX, Hyperliquid, Gate and KuCoin: prices, funding rates, open interest, order books, candles and funding arbitrage.

Comment installer Crypto Market Data MCP ?

Suivez les étapes d'installation de sa documentation, affichée sur cette page et dans son dépôt.

Crypto Market Data MCP est-il open source ?

Oui. Son code est sur GitHub sous licence MIT.

Qui maintient Crypto Market Data MCP ?

Il est publié par eliasfire617. AI.tn le référence sans le maintenir ni le recommander.

Issu des listes communautaires awesome-mcp-servers et du dépôt GitHub du projet. Être listé n'est pas une recommandation : vérifiez le code et les permissions d'un serveur avant de lui donner accès à vos données.