# CCXT (npm · ccxt-mcp)

Official CCXT MCP server - Market data and trading across 100+ exchanges and prediction markets

- Trust score: 85/100 (high trust)
- Change this week: +6
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-20

## Components

- npm · `ccxt-mcp`: 85/100 (this document), [markdown](https://verifymcp.io/servers/ccxt-ccxt-mcp/ccxt-mcp.md), [page](https://verifymcp.io/servers/ccxt-ccxt-mcp/ccxt-mcp)

## Channel facts

- Registry: `npm`
- Package: `ccxt-mcp`
- Version: `0.1.3`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-09-20.

- **Supply Chain Security**: 98/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 31 of 106 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 97/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to ccxt/ccxt).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 12 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 68/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 7034 tokens (~219/item across 32 items; 32 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 43/100
  - Stability observed for 13 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 98/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 95% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 2 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 33 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the CCXT MCP server?

CCXT runs locally as an npm package, launched with npx -y ccxt-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add ccxt-ccxt-mcp -- npx -y ccxt-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "ccxt-ccxt-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "ccxt-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "ccxt-ccxt-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "ccxt-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add ccxt-ccxt-mcp -- npx -y ccxt-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "ccxt-ccxt-mcp": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "ccxt-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add ccxt-ccxt-mcp --command npx --arg -y --arg ccxt-mcp
```

### Hermes

```yaml
mcp_servers:
  ccxt-ccxt-mcp:
    command: "npx"
    args: ["-y", "ccxt-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "ccxt-ccxt-mcp": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "ccxt-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add ccxt-ccxt-mcp -t stdio -c npx -a -y ccxt-mcp
```

### Other

```json
{
  "mcpServers": {
    "ccxt-ccxt-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "ccxt-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-09-20 (score 85, +1)

No change was recorded against any check on this day. Stability & Change Management went from 40 to 43. That category is still filling its 30-day observation window: 12 days of observed history at the previous scan, 13 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-17 (score 84, +1)

No change was recorded against any check on this day. Stability & Change Management went from 30 to 33. That category is still filling its 30-day observation window: 9 days of observed history at the previous scan, 10 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-15 (score 83, +4)

- [functional improvement] Stability: unverified → 0.27

### 2026-09-08 (score 79, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-09-07 (score 64)

First indexed and scored.

## MCP tools (32)

### `list_exchanges` (~106 tokens)

List supported exchanges

List 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.

Input parameters:

- `prediction` (boolean): true: only prediction-market exchanges; false: exclude them
- `query` (string): case-insensitive substring match on the exchange id or name
- `supports` (string): keep only exchanges supporting this unified method, e.g. "fetchOHLCV"

### `describe_exchange` (~101 tokens)

Describe an exchange's capabilities

One exchange's supported unified methods, market types, timeframes, required credential fields, sandbox availability and documentation URLs. Per-method detail lives in describe_method.

Input parameters:

- `exchange` (string, required): exchange id, e.g. "binance" — validated against ccxt.exchanges; discover ids with list_exchanges
- `prediction` (boolean): set true to use the prediction-markets variant of an exchange that exists in both namespaces (e.g. hyperliquid)

### `describe_method` (~213 tokens)

Search or describe unified ccxt methods

Search 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/

Input parameters:

- `exchange` (string): exchange id for per-exchange docs, feature support and implicit endpoints; when omitted a reference exchange (binance) is used, so implicit-endpoint results are binance-specific — pass "exchange" to…
- `method` (string): exact method name to describe, e.g. "fetchOHLCV" (or an implicit endpoint name when "exchange" is set)
- `prediction` (boolean): set true to use the prediction-markets variant of an exchange that exists in both namespaces (e.g. hyperliquid)
- `query` (string): keyword search over method names, e.g. "funding"

### `search_markets` (~260 tokens)

Search markets on an exchange

Search 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.

Input parameters:

- `activeOnly` (boolean): only active markets (default true)
- `base` (string): base currency filter, e.g. "BTC"
- `exchange` (string, required): exchange id, e.g. "binance" — validated against ccxt.exchanges; discover ids with list_exchanges
- `limit` (integer): max results (default 50, max 200)
- `offset` (integer): pagination offset
- `prediction` (boolean): set true to use the prediction-markets variant of an exchange that exists in both namespaces (e.g. hyperliquid)
- `query` (string): case-insensitive substring match on the symbol or market id
- `quote` (string): quote currency filter, e.g. "USDT"
- `reload` (boolean): force-refresh the markets cache
- `settle` (string): settle currency filter (derivatives)
- `type` (string): market type filter: "spot", "swap", "future", "option", …

### `get_tickers` (~214 tokens)

Get price tickers

24h price tickers for one or more unified symbols on an exchange (outcome handles on prediction exchanges).

Input parameters:

- `exchange` (string, required): exchange id, e.g. "binance" — validated against ccxt.exchanges; discover ids with list_exchanges
- `includeInfo` (boolean): include the raw exchange payload (single symbol only)
- `marketType` (string): market type routing for exchanges with several (e.g. "spot", "swap", "future", "option") — sets options.defaultType on a dedicated instance
- `params` (object): extra exchange-specific parameters passed through to ccxt unchanged (e.g. {"until": 1673000000000}) — discover supported keys with describe_method
- `prediction` (boolean): set true to use the prediction-markets variant of an exchange that exists in both namespaces (e.g. hyperliquid)
- `symbols` (array, required): unified symbols, e.g. ["BTC/USDT"] — resolve with search_markets

### `get_orderbook` (~212 tokens)

Get order book

Current order book (bids and asks) for one unified symbol.

Input parameters:

- `depth` (integer): alias for limit (price levels per side)
- `exchange` (string, required): exchange id, e.g. "binance" — validated against ccxt.exchanges; discover ids with list_exchanges
- `limit` (integer): price levels per side (default 20, max 100)
- `marketType` (string): market type routing for exchanges with several (e.g. "spot", "swap", "future", "option") — sets options.defaultType on a dedicated instance
- `params` (object): extra exchange-specific parameters passed through to ccxt unchanged (e.g. {"until": 1673000000000}) — discover supported keys with describe_method
- `prediction` (boolean): set true to use the prediction-markets variant of an exchange that exists in both namespaces (e.g. hyperliquid)
- `symbol` (string, required): unified symbol — resolve with search_markets

### `get_ohlcv` (~283 tokens)

Get OHLCV candles

Historical 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.

Input parameters:

- `exchange` (string, required): exchange id, e.g. "binance" — validated against ccxt.exchanges; discover ids with list_exchanges
- `limit` (integer): number of candles (default 100, max 500)
- `marketType` (string): market type routing for exchanges with several (e.g. "spot", "swap", "future", "option") — sets options.defaultType on a dedicated instance
- `params` (object): extra exchange-specific parameters passed through to ccxt unchanged (e.g. {"until": 1673000000000}) — discover supported keys with describe_method
- `prediction` (boolean): set true to use the prediction-markets variant of an exchange that exists in both namespaces (e.g. hyperliquid)
- `since` (number|string): earliest entry to fetch: timestamp in ms, or an ISO8601 string like "2024-01-01T00:00:00Z"
- `symbol` (string, required): unified symbol
- `timeframe` (string): candle interval (default "1h") — valid values come from describe_exchange .timeframes

### `get_trades` (~222 tokens)

Get recent public trades

Recent public trades for one unified symbol.

Input parameters:

- `exchange` (string, required): exchange id, e.g. "binance" — validated against ccxt.exchanges; discover ids with list_exchanges
- `limit` (integer): number of trades (default 50, max 200)
- `marketType` (string): market type routing for exchanges with several (e.g. "spot", "swap", "future", "option") — sets options.defaultType on a dedicated instance
- `params` (object): extra exchange-specific parameters passed through to ccxt unchanged (e.g. {"until": 1673000000000}) — discover supported keys with describe_method
- `prediction` (boolean): set true to use the prediction-markets variant of an exchange that exists in both namespaces (e.g. hyperliquid)
- `since` (number|string): earliest entry to fetch: timestamp in ms, or an ISO8601 string like "2024-01-01T00:00:00Z"
- `symbol` (string, required): unified symbol

### `search_events` (~250 tokens)

Search prediction-market events

Search 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.

Input parameters:

- `exchange` (string, required): exchange id, e.g. "binance" — validated against ccxt.exchanges; discover ids with list_exchanges
- `limit` (integer): max events (default 25, max 100)
- `offset` (integer): pagination offset
- `params` (object): extra exchange-specific parameters passed through to ccxt unchanged (e.g. {"until": 1673000000000}) — discover supported keys with describe_method
- `query` (string): keyword search (required unless tags or params.eventId/params.slug are given)
- `sort` (string): "volume", "liquidity" or "newest"
- `status` (string): "active" (default), "closed" or "all"
- `tags` (array): filter by tags/categories

### `call_read_method` (~306 tokens)

Call any read-only unified ccxt method

Escape 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/

Input parameters:

- `account` (string): configured account name — required for private reads like fetchLedger
- `args` (array): positional arguments per the describe_method usage line; ISO8601 strings become ms timestamps; null skips an optional argument
- `exchange` (string, required): exchange id, e.g. "binance" — validated against ccxt.exchanges; discover ids with list_exchanges
- `includeInfo` (boolean): keep the raw exchange payload inside unified structures
- `marketType` (string): market type routing for exchanges with several (e.g. "spot", "swap", "future", "option") — sets options.defaultType on a dedicated instance
- `method` (string, required): unified method name matching ^(fetch|load), e.g. "fetchFundingRate"
- `params` (object): extra exchange-specific parameters passed through to ccxt unchanged (e.g. {"until": 1673000000000}) — discover supported keys with describe_method
- `prediction` (boolean): set true to use the prediction-markets variant of an exchange that exists in both namespaces (e.g. hyperliquid)

### `call_implicit_get` (~261 tokens)

Call a raw GET endpoint (implicit API)

Call 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/

Input parameters:

- `account` (string): configured account name for authenticated (private/signed) GET endpoints
- `exchange` (string, required): exchange id, e.g. "binance" — validated against ccxt.exchanges; discover ids with list_exchanges
- `method` (string, required): implicit method name whose HTTP verb is GET, e.g. "publicGetTickerPrice" (from describe_method)
- `params` (object): extra exchange-specific parameters passed through to ccxt unchanged (e.g. {"until": 1673000000000}) — discover supported keys with describe_method
- `prediction` (boolean): set true to use the prediction-markets variant of an exchange that exists in both namespaces (e.g. hyperliquid)

### `get_safety_status` (~50 tokens)

Show safety and configuration status

What 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.

### `watch_subscribe` (~592 tokens)

Start a live WebSocket stream

Open 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.

Input parameters:

- `account` (string): configured account name — required for private streams (watchOrders, watchMyTrades, watchBalance, watchPositions, watchMyLiquidations)
- `args` (array): positional arguments — they differ per method (get the exact signature with describe_method): e.g. watchTicker ["BTC/USDT"], watchOHLCV ["BTC/USDT","1m"], watchOrderBook ["BTC/USDT", depthLimit], wat…
- `exchange` (string, required): exchange id, e.g. "binance" — validated against ccxt.exchanges; discover ids with list_exchanges
- `marketType` (string): market type routing for exchanges with several (e.g. "spot", "swap")
- `method` (string, required): a ccxt.pro watch* method, e.g. "watchOHLCV", "watchTicker", "watchOrderBook", "watchTrades"
- `params` (object): extra exchange-specific parameters passed through to ccxt unchanged (e.g. {"until": 1673000000000}) — discover supported keys with describe_method
- `prediction` (boolean): set true to use the prediction-markets variant of an exchange that exists in both namespaces (e.g. hyperliquid)
- `symbol` (string): convenience alias for a single-symbol stream (watchTicker/watchOrderBook/watchTrades/watchOHLCV) — equivalent to passing it as args[0]; ignored if args is given
- `symbols` (array): convenience alias for a multi-symbol stream (watchTickers/watchOrderBookForSymbols/…) — equivalent to passing the list as args[0]; ignored if args is given

### `watch_read` (~570 tokens)

Read from a live stream

Get 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).

Input parameters:

- `cursor` (integer): EVENT streams only: the nextCursor from your previous watch_read (omit on the first read). Ignored for state streams.
- `depth` (integer): order-book streams only: levels per side to return in "latest" (default 20, max 100). Use depth:1 for just top-of-book (best bid/ask) — much cheaper when comparing many venues.
- `subscriptionId` (string, required): id from watch_subscribe
- `timeoutMs` (integer): max time to block when waitForChange is set (default 25000, clamped to 1000–55000 — sub-second values are raised to ~1s, larger stay under host tool-call timeouts)
- `waitForChange` (boolean): block until the next update lands (or timeoutMs elapses) instead of returning right away — use to wait for a fill/position change without polling. If something new is already available it returns imm…

### `watch_unsubscribe` (~40 tokens)

Stop a live stream

Stop a WebSocket subscription and release its socket. Always stop streams you no longer need.

Input parameters:

- `subscriptionId` (string, required): id from watch_subscribe

### `watch_list` (~51 tokens)

List active streams

List 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_accounts` (~31 tokens)

List configured accounts

Locally configured named exchange accounts. Returns aliases and capability flags only — credential values are never exposed by any tool.

### `get_balance` (~150 tokens)

Get account balance

Balances for a named account. Returns non-zero balances by default (exchanges report every listed currency — hundreds of zero rows).

Input parameters:

- `account` (string, required): configured account name — discover with list_accounts; credentials are never tool parameters
- `marketType` (string): wallet/market type to query when the exchange has several (e.g. "spot", "swap", "future", "funding") — overrides the account default
- `nonzeroOnly` (boolean): default true; false returns every currency
- `params` (object): extra exchange-specific parameters passed through to ccxt unchanged (e.g. {"until": 1673000000000}) — discover supported keys with describe_method

### `get_orders` (~235 tokens)

Get orders

Orders 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.

Input parameters:

- `account` (string, required): configured account name — discover with list_accounts; credentials are never tool parameters
- `id` (string): order id — fetches that single order
- `includeInfo` (boolean): include the raw exchange payload (single order only)
- `limit` (integer): max orders (default 50, max 200)
- `params` (object): extra exchange-specific parameters passed through to ccxt unchanged (e.g. {"until": 1673000000000}) — discover supported keys with describe_method
- `since` (number|string): earliest entry to fetch: timestamp in ms, or an ISO8601 string like "2024-01-01T00:00:00Z"
- `status` (string): "open" (default), "closed", "canceled" or "all"
- `symbol` (string): unified symbol (required by many exchanges for list queries)

### `get_my_trades` (~148 tokens)

Get account trade history

The account's own executed trades (fills). Many exchanges require a symbol.

Input parameters:

- `account` (string, required): configured account name — discover with list_accounts; credentials are never tool parameters
- `limit` (integer): max trades (default 50, max 200)
- `params` (object): extra exchange-specific parameters passed through to ccxt unchanged (e.g. {"until": 1673000000000}) — discover supported keys with describe_method
- `since` (number|string): earliest entry to fetch: timestamp in ms, or an ISO8601 string like "2024-01-01T00:00:00Z"
- `symbol` (string): unified symbol

### `get_positions` (~126 tokens)

Get open positions

Open derivatives positions for a named account (prediction-market positions on prediction exchanges).

Input parameters:

- `account` (string, required): configured account name — discover with list_accounts; credentials are never tool parameters
- `marketType` (string): derivatives type to query when the exchange has several (e.g. "swap", "future") — overrides the account default
- `params` (object): extra exchange-specific parameters passed through to ccxt unchanged (e.g. {"until": 1673000000000}) — discover supported keys with describe_method
- `symbols` (array): restrict to these unified symbols

### `create_order` (~387 tokens)

Place an order

Place 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": ...}.

Input parameters:

- `account` (string, required): configured account name — discover with list_accounts; credentials are never tool parameters
- `amount` (number): amount in base currency / contracts / shares
- `confirm` (string): confirmation token from the preview response — repeat the identical call with this token to execute
- `cost` (number): spend this quote-currency value instead of specifying an amount (market buy/sell by cost, where the exchange supports it)
- `params` (object): extra exchange-specific parameters passed through to ccxt unchanged (e.g. {"until": 1673000000000}) — discover supported keys with describe_method
- `price` (number): limit price — required for limit orders
- `side` (string, required)
- `symbol` (string, required): unified symbol (outcome handle on prediction exchanges)
- `type` (string, required): order type — usually "limit" or "market"; exchange-specific types pass through

### `edit_order` (~190 tokens)

Modify an open order

Modify 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.

Input parameters:

- `account` (string, required): configured account name — discover with list_accounts; credentials are never tool parameters
- `amount` (number)
- `confirm` (string): confirmation token from the preview response — repeat the identical call with this token to execute
- `id` (string, required): order id to modify
- `params` (object): extra exchange-specific parameters passed through to ccxt unchanged (e.g. {"until": 1673000000000}) — discover supported keys with describe_method
- `price` (number)
- `side` (string)
- `symbol` (string, required): unified symbol of the order
- `type` (string)

### `cancel_order` (~111 tokens)

Cancel an order

Cancel one open order by id. No confirmation step — canceling reduces risk and must never be blocked.

Input parameters:

- `account` (string, required): configured account name — discover with list_accounts; credentials are never tool parameters
- `id` (string, required): order id
- `params` (object): extra exchange-specific parameters passed through to ccxt unchanged (e.g. {"until": 1673000000000}) — discover supported keys with describe_method
- `symbol` (string): unified symbol (required by many exchanges)

### `cancel_all_orders` (~129 tokens)

Cancel all open orders

Cancel every open order on an account, optionally restricted to one symbol. The preview lists the orders that would be canceled.

Input parameters:

- `account` (string, required): configured account name — discover with list_accounts; credentials are never tool parameters
- `confirm` (string): confirmation token from the preview response — repeat the identical call with this token to execute
- `params` (object): extra exchange-specific parameters passed through to ccxt unchanged (e.g. {"until": 1673000000000}) — discover supported keys with describe_method
- `symbol` (string): only cancel orders on this unified symbol

### `set_leverage` (~143 tokens)

Set leverage

Set the leverage multiplier for a derivatives symbol on a trading-enabled account. Changing leverage changes the risk of existing positions.

Input parameters:

- `account` (string, required): configured account name — discover with list_accounts; credentials are never tool parameters
- `confirm` (string): confirmation token from the preview response — repeat the identical call with this token to execute
- `leverage` (number, required): leverage multiplier, e.g. 5
- `params` (object): extra exchange-specific parameters passed through to ccxt unchanged (e.g. {"until": 1673000000000}) — discover supported keys with describe_method
- `symbol` (string): unified symbol (required by most exchanges)

### `set_margin_mode` (~129 tokens)

Set margin mode

Set cross or isolated margin mode for a derivatives symbol on a trading-enabled account.

Input parameters:

- `account` (string, required): configured account name — discover with list_accounts; credentials are never tool parameters
- `confirm` (string): confirmation token from the preview response — repeat the identical call with this token to execute
- `marginMode` (string, required)
- `params` (object): extra exchange-specific parameters passed through to ccxt unchanged (e.g. {"until": 1673000000000}) — discover supported keys with describe_method
- `symbol` (string): unified symbol (required by most exchanges)

### `call_write_method` (~217 tokens)

Call an allowlisted unified write method

Dispatch 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.

Input parameters:

- `account` (string, required): configured account name — discover with list_accounts; credentials are never tool parameters
- `args` (array): positional arguments per describe_method; null skips an optional argument
- `confirm` (string): confirmation token from the preview response — repeat the identical call with this token to execute
- `method` (string, required): one of the allowlisted method names
- `params` (object): extra exchange-specific parameters passed through to ccxt unchanged (e.g. {"until": 1673000000000}) — discover supported keys with describe_method

### `withdraw` (~202 tokens)

Withdraw funds

Withdraw 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.

Input parameters:

- `account` (string, required): configured account name — discover with list_accounts; credentials are never tool parameters
- `address` (string, required): destination address
- `amount` (number, required)
- `code` (string, required): unified currency code, e.g. "USDT"
- `confirm` (string): confirmation token from the preview response — repeat the identical call with this token to execute
- `network` (string): unified network code, e.g. "TRC20" — check describe_method {"method": "withdraw", "exchange": ...}
- `params` (object): extra exchange-specific parameters passed through to ccxt unchanged (e.g. {"until": 1673000000000}) — discover supported keys with describe_method
- `tag` (string): memo/tag where the network needs one

### `transfer` (~187 tokens)

Transfer between account wallets

Move 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": ...}.

Input parameters:

- `account` (string, required): configured account name — discover with list_accounts; credentials are never tool parameters
- `amount` (number, required)
- `code` (string, required): unified currency code
- `confirm` (string): confirmation token from the preview response — repeat the identical call with this token to execute
- `fromAccount` (string, required): source wallet, e.g. "spot"
- `params` (object): extra exchange-specific parameters passed through to ccxt unchanged (e.g. {"until": 1673000000000}) — discover supported keys with describe_method
- `toAccount` (string, required): destination wallet, e.g. "swap"

### `get_deposit_address` (~135 tokens)

Get a deposit address

Deposit 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.

Input parameters:

- `account` (string, required): configured account name — discover with list_accounts; credentials are never tool parameters
- `code` (string, required): unified currency code
- `network` (string): unified network code
- `params` (object): extra exchange-specific parameters passed through to ccxt unchanged (e.g. {"until": 1673000000000}) — discover supported keys with describe_method

### `call_implicit_write` (~204 tokens)

Call a raw non-GET endpoint (implicit API)

Call 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).

Input parameters:

- `account` (string, required): configured account name — discover with list_accounts; credentials are never tool parameters
- `confirm` (string): confirmation token from the preview response — repeat the identical call with this token to execute
- `method` (string, required): implicit method name with a non-GET verb, e.g. "privatePostMarginOrder"
- `params` (object): extra exchange-specific parameters passed through to ccxt unchanged (e.g. {"until": 1673000000000}) — discover supported keys with describe_method

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/ccxt-ccxt-mcp/ccxt-mcp#diagnostics

## Score history

- 2026-09-20: 85
- 2026-09-19: 84
- 2026-09-18: 84
- 2026-09-17: 84
- 2026-09-16: 83
- 2026-09-15: 83
- 2026-09-14: 79
- 2026-09-13: 79
- 2026-09-12: 79
- 2026-09-11: 79
- 2026-09-10: 79
- 2026-09-09: 79
- 2026-09-08: 79
- 2026-09-07: 64

## Common questions

### What is the CCXT MCP server?

CCXT is an MCP server listed in the public MCP registry as io.github.ccxt/ccxt-mcp. Official CCXT MCP server - Market data and trading across 100+ exchanges and prediction markets. This page covers its npm package (ccxt-mcp).

### Is the CCXT MCP server safe to use?

CCXT scores 85 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 20 September 2026. It declares no install or post-install scripts. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the CCXT MCP server expose?

CCXT exposes 32 tools: list_exchanges, describe_exchange, describe_method, search_markets, get_tickers, and 27 more. Their descriptions and schemas cost roughly 6,455 tokens of context every time the server is loaded.

### Is the CCXT MCP server still maintained?

CCXT is still listed as active in the MCP registry. We last reached this channel on 20 September 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the CCXT MCP server under?

CCXT declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- npm package: https://www.npmjs.com/package/ccxt-mcp
- Socket report: https://socket.dev/npm/package/ccxt-mcp
- Repository: https://github.com/ccxt/ccxt
- Website: https://ccxt.com/
- Changelog RSS feed: https://verifymcp.io/servers/ccxt-ccxt-mcp/ccxt-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/ccxt-ccxt-mcp/ccxt-mcp.json
- HTML version of this page: https://verifymcp.io/servers/ccxt-ccxt-mcp/ccxt-mcp