Connect AI agents to over 100 cryptocurrency exchanges and prediction markets for market data, account management, and trading.
Also known as ccxt/ccxt, ccxt-mcp
- Stars
- 44,888
- Tools
- 32
- Downloads, 30 days
- —
- Latest version
- 0.1.3
- Last commit
- Nov 13, 2026
- License
- MIT
What is CCXT MCP?
CCXT connects AI agents to over 100 cryptocurrency exchanges and prediction markets for market data, account management, and trading. It exposes 32 tools, such as list_exchanges, describe_exchange, describe_method.
Summary generated from the project's README
About CCXT MCP server
Connecting AI agents to over 100 cryptocurrency exchanges and prediction markets is what this server enables for developers using Claude Desktop, Cursor, or VS Code. It provides a unified interface to access market data, manage account balances, and execute trades through the CCXT API. The server runs locally over stdio, ensuring that your API keys remain on your machine and are never seen by the AI model.
Users can access public market data immediately without any configuration. For private data or trading, you must explicitly enable capability tiers like trading, funds, or implicitWrites within a local configuration file. This setup includes safety features such as per-order USD caps, symbol allowlists, and required manual confirmations for live trades. The server also supports WebSocket streams via watch_read to provide real-time updates on tickers, order books, and positions.
What you can do with it
- 1Stream live market updatesSubscribe to WebSocket streams to receive instant updates on price changes or trade executions.
Written from the project's README. Every use case is checked against a quote from it.
How to install CCXT MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall CCXT MCP in Claude Code
$ claude mcp add ccxt-mcp -- npx -y ccxt-mcpInstall CCXT MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"ccxt-mcp": {
"command": "npx",
"args": [
"-y",
"ccxt-mcp"
]
}
}
}Install CCXT MCP in VS Code
.vscode/mcp.json
{
"servers": {
"ccxt-mcp": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"ccxt-mcp"
]
}
}
}Install CCXT MCP in VS Code CLI
$ code --add-mcp '{"name":"ccxt-mcp","type":"stdio","command":"npx","args":["-y","ccxt-mcp"]}'Install CCXT MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"ccxt-mcp": {
"command": "npx",
"args": [
"-y",
"ccxt-mcp"
]
}
}
}Install CCXT MCP in Codex
$ codex mcp add ccxt-mcp -- npx -y ccxt-mcpInstall CCXT MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.ccxt-mcp] command = "npx" args = ["-y", "ccxt-mcp"]
Install CCXT MCP in Gemini CLI
$ gemini mcp add -s user ccxt-mcp npx -- -y ccxt-mcpInstall CCXT MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"ccxt-mcp": {
"command": "npx",
"args": [
"-y",
"ccxt-mcp"
]
}
}
}Started by HostedMCP on 16 Nov 2026
We ran this command for ccxt-mcp 0.1.3 in an isolated container with no network and no keys. It answered and listed 32 tools.
CCXT MCP tools 32
Read from the server with tools/listlist_exchangesRead-onlyList every exchange this server supports (built from ccxt.exchanges at runtime), with name, websocket and prediction-market availability. Filter by a name query or by support for a unified method.
describe_exchangeRead-onlyOne exchange's supported unified methods, market types, timeframes, required credential fields, sandbox availability and documentation URLs. Per-method detail lives in describe_method.
describe_methodRead-onlySearch unified method names by keyword, or get one method's signature and parameter documentation. With "exchange" it adds that exchange's own docs (including supported params.* keys and links to the exchange API reference), per-market-type feature support, and searches its implicit (exchange-specific) endpoints too. Full ccxt manual: https://docs.ccxt.com/
search_marketsRead-onlySearch and filter the markets of one exchange (by text, base, quote, settle currency, market type), paginated. Use this to resolve unified symbols — there is deliberately no list-all-markets tool. On prediction exchanges use search_events instead.
get_tickersRead-only24h price tickers for one or more unified symbols on an exchange (outcome handles on prediction exchanges).
get_orderbookRead-onlyCurrent order book (bids and asks) for one unified symbol.
get_ohlcvRead-onlyHistorical OHLCV candlestick data for a symbol and timeframe. Rows are [timestampMs, open, high, low, close, volume]. Page back with "since"; "params.until" bounds the end.
get_tradesRead-onlyRecent public trades for one unified symbol.
search_eventsRead-onlySearch events on a prediction-market exchange (polymarket, kalshi, limitless, myriad, hyperliquid with prediction=true). A scoping filter is required: query, tags, or params.eventId/params.slug. Returns events with their markets and outcome handles — outcome handles are what you pass as the symbol to get_tickers/get_orderbook/create_order on prediction exchanges.
call_read_methodRead-onlyEscape hatch covering every unified read method not served by a dedicated tool (fetchFundingRate, fetchLedger, fetchOpenInterest, fetchLiquidations, fetchEvent, fetchSettlements, …). Only fetch*/load* methods are accepted — writes are structurally rejected. Get the signature first with describe_method. Docs: https://docs.ccxt.com/
call_implicit_getRead-onlyCall an exchange-specific implicit REST endpoint over HTTP GET, for data the unified API does not cover. Pass the implicit method name in the "method" argument (e.g. "publicGetTickerPrice"); these are exchange-specific — find them with describe_method {"query": ..., "exchange": ...} (its results list the name to pass here). The response is the raw exchange payload. Consult the exchange API reference (describe_exchange .urls.doc) and the ccxt manual: https://docs.ccxt.com/
get_safety_statusRead-onlyWhat this server is currently allowed to do: configured accounts (names only — never credentials), enabled capability tiers, caps, sandbox/live environments, journal location, unresolved order intents, and any configuration problems.
Show all 32 toolsShow fewer tools
watch_subscribeRead-onlyOpen a background WebSocket subscription to a ccxt.pro watch* method so the agent can pull fresh data on demand. Returns a subscriptionId and a "streamKind". STATE streams are snapshots of "what is X right now" — watchTicker(s), watchOrderBook(ForSymbols), watchOHLCV(ForSymbols), watchBalance, watchPositions, watchBidsAsks, watchMarkPrice(s), watchFundingRate(s): watch_read returns the COMPLETE current set in "latest" (the server merges live updates into a full snapshot, so a multi-symbol stream always shows every subscribed symbol, not just the one that just ticked). EVENT streams are logs of discrete events — watchTrades and the private watchOrders/watchMyTrades/watch(My)Liquidations (private ones need an account): watch_read returns each new item oldest-first in "events" with a cursor. Call watch_unsubscribe to stop; streams auto-stop after 10 minutes with no read. Not every exchange streams every method — check describe_exchange.
watch_readRead-onlyGet the latest data from a stream. For a STATE stream (streamKind "state": ticker(s), order book(s), ohlcv, balance, positions, ...) it returns the COMPLETE current snapshot in "latest" — the full merged set, so call it whenever you need the current value; "updatesSinceRead" tells you how much changed since you last read. The shape of "latest" mirrors the fetch* method: a single object for watchTicker/watchOrderBook/watchBalance, keyed by symbol for watchTickers/watchBidsAsks ({"BTC/USDT": {...}}), an array for watchPositions, and nested by symbol then timeframe for watchOHLCV ("latest"["BTC/USDT"]["1m"] = [[ts,o,h,l,c,v], ...]). For an EVENT stream (streamKind "events": trades, orders, my trades, liquidations) it returns new updates oldest-first in "events" plus a "nextCursor" — thread that back as "cursor" on each poll so you do not re-receive (double-count) old items. Each "events" element is a wrapper {seq, timestamp, datetime, data} where "data" holds the record(s) for that tick (an array — ccxt delivers a batch per update, e.g. events[i].data is the trades from that tick). "moreBuffered": true means call again with nextCursor for more, and "missedBeforeBuffer" > 0 means older updates were evicted before you read them. Set waitForChange:true to BLOCK until the next update arrives (or timeout) instead of returning immediately — the efficient way to wait for a slow event like an order fill or a position change ("timedOut": true means the wait elapsed with nothing new).
watch_unsubscribeActionStop a WebSocket subscription and release its socket. Always stop streams you no longer need.
watch_listRead-onlyList the currently active WebSocket subscriptions (id, exchange, method, streamKind, account and environment for private streams, args, active flag, age, seconds since last read, update count, and last error).
list_accountsRead-onlyLocally configured named exchange accounts. Returns aliases and capability flags only — credential values are never exposed by any tool.
get_balanceRead-onlyBalances for a named account. Returns non-zero balances by default (exchanges report every listed currency — hundreds of zero rows).
get_ordersRead-onlyOrders for a named account: one order by id, or a list filtered by status ("open" default, "closed", "canceled", "all"). Many exchanges require a symbol for list queries.
get_my_tradesRead-onlyThe account's own executed trades (fills). Many exchanges require a symbol.
get_positionsRead-onlyOpen derivatives positions for a named account (prediction-market positions on prediction exchanges).
create_orderPlace an order on a trading-enabled account (works on prediction exchanges with outcome handles as the symbol). Validated against market precision/limits and the account's notional caps. Whether it returns a preview + confirmToken first depends on the account's "confirm" policy: always = every order is previewed; live (the default) = only orders on a LIVE account are previewed, sandbox/demo execute immediately; never = no preview. So on a sandbox/demo account under the default policy an order executes without a confirm step. A stop/trigger order also returns meta.note flagging that conditional orders may not appear in get_orders even when live — confirm before treating the stop as guaranteed protection. Use "cost" instead of "amount" to market-buy by quote value where supported. Exchange-specific order params (triggerPrice, timeInForce, postOnly, reduceOnly, …): describe_method {"method": "createOrder", "exchange": ...}.
edit_orderModify price/amount of an open order. On exchanges without native edit, ccxt emulates it as cancel-then-replace — queue position is lost and the cancel can succeed while the replace fails. Runs the full order validation and confirmation.
cancel_orderCancel one open order by id. No confirmation step — canceling reduces risk and must never be blocked.
cancel_all_ordersCancel every open order on an account, optionally restricted to one symbol. The preview lists the orders that would be canceled.
set_leverageSet the leverage multiplier for a derivatives symbol on a trading-enabled account. Changing leverage changes the risk of existing positions.
set_margin_modeSet cross or isolated margin mode for a derivatives symbol on a trading-enabled account.
call_write_methodDispatch the unified write long tail on a trading-enabled account: cancelOrders, cancelOrdersForSymbols, cancelAllOrdersAfter, setPositionMode, addMargin, reduceMargin, setMargin, borrowCrossMargin, borrowIsolatedMargin, repayCrossMargin, repayIsolatedMargin, closePosition, closeAllPositions. Always previews and requires confirmation. Batch order placement is deliberately excluded — use create_order per order so the notional caps apply. Signatures: describe_method.
withdrawWithdraw cryptocurrency from a funds-enabled account to an external address. Irreversible once dispatched. The preview echoes the exact destination address and network — verify them before confirming.
transferMove funds between wallets of the same exchange account (e.g. spot ↔ swap, main ↔ funding) on a funds-enabled account. Wallet names are exchange-specific — see describe_method {"method": "transfer", "exchange": ...}.
get_deposit_addressActionDeposit address for a currency on a funds-enabled account (creates one where none exists and the exchange supports creation). Gated behind the funds tier because transcript-visible addresses invite substitution scams — always verify addresses out-of-band before sending funds.
call_implicit_writeCall an exchange-specific implicit REST endpoint over POST/PUT/DELETE/PATCH on an account with "implicitWrites" enabled — covers exchange features the unified API does not (including account/key management). No unified validation exists for raw endpoints, so every call previews and requires confirmation, and is journaled. Endpoint names: describe_method {"query": ..., "exchange": ...}; payload per the exchange API reference (describe_exchange .urls.doc).
Configuration
BINANCE_APIKEYBINANCE_SECRET
Automated checks
Ran Nov 16, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work · What to fix for more points
- Source repository linked and reachableccxt/ccxt is public and reachablegithub.com/ccxt/ccxt ↗Pass
- Package names this repository as its sourceccxt-mcp names ccxt/ccxt as sourcenpmjs.com/package/ccxt-mcp ↗Pass
- Build provenance (Sigstore attestation)Sigstore attestation for ccxt-mcpnpmjs.com/package/ccxt-mcp/v/0.1.3#provenance ↗Pass
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-13github.com/ccxt/ccxt ↗Pass
- OpenSSF ScorecardOpenSSF Scorecard 5.0 / 10; weakest: CII-Best-Practices 0, Token-Permissions 0, Security-Policy 0scorecard.dev/viewer/?uri=github.com/ccxt/ccxt ↗Partial 8/15
- Package name not close to a popular packageNo popular package one edit away from ccxt-mcpPass
- No critical advisory in the package or its dependencies109 resolved dependencies checked; no critical advisoryosv.dev ↗Pass
- No hidden instructions to the model32 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNo tool named like delete, drop or execPass
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubccxt-mcp — official CCXT MCP server
Connect AI agents (Claude Desktop, Claude Code, Cursor, VS Code, Windsurf, and any MCP host) to 100+ cryptocurrency exchanges and prediction markets through the unified ccxt API: market data, account balances, order management, and — when you explicitly enable it — trading.
claude mcp add ccxt -- npx -y ccxt-mcp
Security model (read this first)
Your API keys stay on your machine, and the AI model never sees them:
- The server runs locally over stdio. Nothing is hosted; keys never transit any third-party service.
- Credentials are never tool parameters: no tool schema accepts a key, so neither the model nor a prompt-injected page can supply, request, or change them. Tools reference accounts by name ("binance-main").
- Keys leave the process only inside signed HTTPS requests to the exchange itself — the same as any trading bot.
- Every tool result, error, and log line passes a redaction filter holding your loaded secret values (some exchanges echo signed URLs in error bodies — that path is closed). Raw request URLs/headers/bodies are never emitted.
verboseis force-disabled. - Capability tiers are opt-in and file-owned. Out of the box the server does public market data only. Configuring an account enables private reads.
trading,funds(withdraw/transfer), andimplicitWrites(raw endpoints) must each be enabled per account in the config file — there is no tool that edits config, so a conversation can never grant itself permissions. Unregistered tiers do not even appear in the tool list. - Writes are previewed and confirmed (native confirmation form where the host supports elicitation, otherwise an explicit preview + confirm-token round-trip), validated against market limits and your notional caps, and journaled to an append-only audit log.
Recommended exchange-side backstops (they hold even if your machine is compromised): create API keys with withdrawal permission disabled and an IP allowlist.
One honest caveat: any local agent with filesystem access could read the config file with its own tools — that is governed by your MCP host's permission model, not by this server. Prefer your host's secret storage where available (see below), keep the file chmod 600, and consider a deny rule for the path in your host's settings.
Install
Requires Node.js ≥ 18. The npm package is ccxt-mcp; the server binary is npx -y ccxt-mcp.
Claude Code
claude mcp add ccxt -- npx -y ccxt-mcp
Or per-project via .mcp.json (safe to commit — no secrets):
{ "mcpServers": { "ccxt": { "command": "npx", "args": ["-y", "ccxt-mcp"] } } }
Claude Desktop
Add to claude_desktop_config.json (Settings → Developer → Edit Config):
{ "mcpServers": { "ccxt": { "command": "npx", "args": ["-y", "ccxt-mcp"] } } }
Cursor
~/.cursor/mcp.json (or .cursor/mcp.json per project):
{ "mcpServers": { "ccxt": { "command": "npx", "args": ["-y", "ccxt-mcp"] } } }
VS Code
.vscode/mcp.json — VS Code's inputs mechanism stores values in encrypted secret storage, the best option for keys among the JSON-config hosts:
{
"inputs": [
{ "id": "binance-key", "type": "promptString", "password": true, "description": "Binance API key" },
{ "id": "binance-secret", "type": "promptString", "password": true, "description": "Binance API secret" }
],
"servers": {
"ccxt": {
"command": "npx", "args": ["-y", "ccxt-mcp"],
"env": { "BINANCE_APIKEY": "${input:binance-key}", "BINANCE_SECRET": "${input:binance-secret}" }
}
}
}
Windsurf
~/.codeium/windsurf/mcp_config.json — same mcpServers shape as Claude Desktop; ${env:VAR} interpolation is supported.
Configuration
With no configuration the server serves public market data on all exchanges — that alone is a useful install.
To add accounts, create the config file (path shown by the get_safety_status tool):
- macOS:
~/Library/Application Support/ccxt-mcp/config.json - Linux:
~/.config/ccxt-mcp/config.json - Windows:
%APPDATA%\ccxt-mcp\config.json - Or point
CCXT_MCP_CONFIGat any path (a legacy per-exchangekeys.local.jsonshape also loads).
{
"accounts": {
"binance-testnet": {
"exchange": "binance",
"apiKey": "…",
"secret": "…",
"sandbox": true, // testnet — recommended first stop
"trading": true // true enables SANDBOX/DEMO trading only
},
"binance-main": {
"exchange": "binance",
"apiKey": "…",
"secret": "…",
"trading": "live", // live trading requires the explicit string "live"…
"maxOrderValue": 250, // …and a per-order USD cap you author (null = opt out)
"maxDailyValue": 1000, // optional rolling-24h cap
"allowedSymbols": ["BTC/USDT", "ETH/*"], // optional strict allowlist
"confirm": "live" // always | live (default) | never
},
"polymarket-main": {
"exchange": "polymarket",
"walletAddress": "0x…",
"privateKey": "0x…"
}
}
}
Account fields: any credential from the exchange's requiredCredentials (apiKey, secret, password, uid, walletAddress, privateKey, …), sandbox/demo, defaultType, options (ccxt constructor options), prediction: true (for exchanges that exist in both the crypto and prediction namespaces, e.g. hyperliquid), and the safety switches below. chmod 600 the file; the server warns otherwise (or refuses with "settings": {"strictPermissions": true}).
Environment variables work too: <EXCHANGEID>_<CREDENTIAL> (e.g. BINANCE_APIKEY, OKX_PASSWORD) fill missing credentials, and the CCXT_MCP_EXCHANGE/CCXT_MCP_APIKEY/CCXT_MCP_SECRET/CCXT_MCP_SANDBOX/CCXT_MCP_TRADING set defines a single account named default.
Claude Desktop (.mcpb bundle): the install form configures one exchange. To use several exchanges (or enable live trading/withdrawals), set the Config file field to a config.json with an accounts map like the one above — or just create it at the default path and leave the form fields blank.
Capability tiers
| Tier | Enables | Switch | Default |
|---|---|---|---|
| market | tickers, order books, OHLCV, trades, markets, prediction events, read-only raw GET endpoints | — | on |
| read | balances, orders, own trades, positions | an account with credentials exists | on when configured |
| trading | create/edit/cancel orders, leverage, margin, position ops | per-account "trading": true (sandbox/demo) or "live" |
off |
| funds | withdraw, internal transfer, deposit addresses | per-account "funds": true or "live" |
off |
| implicitWrites | raw POST/PUT/DELETE endpoints (anything exchange-specific, incl. key mgmt) | per-account "implicitWrites": true |
off |
"trading": true deliberately works only on sandbox/demo accounts; live trading requires typing "trading": "live" and deciding a maxOrderValue (a number, or explicitly null to opt out). The same pattern applies to funds with maxTransferValue. Activating a tier is your responsibility — the server's job is honest gates, confirmation, and the audit journal (<cache-dir>/ccxt-mcp/journal/).
Tools
market — list_exchanges, describe_exchange, describe_method (search/signatures/per-exchange params + docs links), search_markets, get_tickers, get_orderbook, get_ohlcv, get_trades, search_events (prediction markets), call_read_method (any unified fetch*/load* — structurally read-only), call_implicit_get (raw GET endpoints), get_safety_status, fetch_route (best execution route for converting an asset at a given size across ~50 exchanges, via the CCXT order router — a quote, no keys needed).
live (WebSocket) — watch_subscribe opens a background ccxt.pro stream; watch_read returns fresh data. State streams are snapshots of "what is X right now" — watchTicker(s), watchOrderBook(ForSymbols), watchOHLCV, watchBalance, watchPositions, watchBidsAsks, watchMarkPrice(s): the server merges live updates into the full current set, so watch_read always returns every subscribed symbol in latest (a multi-symbol stream never shows just the one that last ticked). Event streams are logs — watchTrades and the private watchOrders/watchMyTrades/watch(My)Liquidations (private need an account): watch_read returns new items oldest-first in events with a cursor. Pass waitForChange: true to watch_read to block until the next update (or timeout) instead of polling — the efficient way to wait for a fill or position change. watch_unsubscribe stops it; watch_list shows active streams. The long-lived server holds the socket so the agent always has fresh data; idle streams auto-stop after 10 minutes.
read — list_accounts, get_balance, get_orders, get_my_trades, get_positions.
search_markets returns full market rows (~450 characters each, max 100 per call) by default. Pass fields to get compact rows — ["symbol"] lists every okx USDT-settled swap (528) in one ~15k-character call instead of six calls and ~240k characters — and the max limit rises with how compact the rows are (up to 1000). meta always carries returned/available/offset/hasMore, plus nextOffset when there is more, limitClamped when the requested limit was reduced, and marketTypes (the types the exchange actually has) when nothing matched.
trading — create_order, edit_order, cancel_order, cancel_all_orders, set_leverage, set_margin_mode, call_write_method (allowlisted long tail: margin/position/batch-cancel ops), execute_route (executes a fetch_route result with ccxt's OrderRouter across your accounts — every order still bound by that account's caps, symbol lists and confirmation).
funds — withdraw, transfer, get_deposit_address. implicitWrites — call_implicit_write.
Every list result is capped and paginated to fit host context limits (with in-band truncation notices); the raw info payload is stripped by default. Prediction exchanges use the same tools with outcome handles (from search_events) in the symbol position.
Troubleshooting
- "Trading is not enabled for account …" — edit the config file (see tiers above); this is not something the conversation can change.
- AUTH_FAILED on a sandbox account — testnet keys come from the exchange's testnet portal, not your live account (and vice versa).
- HTTP 451 / geo-blocks — some exchanges block cloud/VPN/US IPs; set a proxy via account
optionsif needed. - Slow first call on a big exchange — the initial
loadMarkets()can take seconds; it is cached on disk for 24h afterwards. npx @modelcontextprotocol/inspector npx -y ccxt-mcpopens an interactive tool console.
Development (inside the ccxt monorepo)
npm run mcp.ts # run the server from live TypeScript sources (tsx)
cd mcp && npm test # unit + schema + integration tests
cd mcp && npm run build # tsc + regenerate js/data/method-docs.json
See DESIGN.md for the architecture, the prior-art analysis this server is built on, and the decision log.
CCXT MCP questions
How do I add CCXT MCP to Claude Code?
Run claude mcp add ccxt-mcp -- npx -y ccxt-mcp in your terminal. Add --scope user to make it available in every project.
How do I add CCXT MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
What tools does CCXT MCP provide?
It exposes 32 tools, including list_exchanges, describe_exchange, describe_method, search_markets, get_tickers.
Can the AI agent trade on my behalf automatically?
Trading is disabled by default. You must explicitly enable it per account in your local configuration file and set specific safety caps like max order value.
How do I enable live trading?
To enable live trading, you must set the trading field to 'live' in your config file and define a per-order USD cap using maxOrderValue.
What happens if I don't provide any configuration?
If no configuration is provided, the server will still function by serving public market data for all supported exchanges.