CCXT vs the alternatives: every crypto library and exchange SDK, compared

Every crypto integration starts with the same decision: call the exchange's API directly, use its official SDK, reach for a specialist library — or build on CCXT, which speaks all of them behind one API.

This is the index of that comparison, done one alternative at a time. There is a page for every single exchange CCXT supports, plus pages for the multi-exchange libraries people weigh CCXT against.

They are written to be useful rather than promotional. Each one puts the same task side by side in both libraries, tables the concrete differences, and carries a section on what the alternative does better. Where a venue has no maintained SDK at all — which turned out to be true for a surprising number — the page says so and compares against the raw REST API instead of inventing a rival to knock down.

How to choose, in three questions

1. Will you ever add a second venue? If yes, the cost of an exchange-specific integration is not the first one — it is the translation layer you write when the second arrives, and maintain forever after. That layer is what CCXT already is, across 104 exchanges.

2. Do you need to trade, or only to read? Several excellent libraries normalise market data and stop there. If your system places, edits and cancels orders, manages positions or moves funds, the set of real alternatives narrows sharply.

3. What does your licence review allow? CCXT is MIT. Some alternatives are AGPL, which for commercial and SaaS work is a legal question before it is an engineering one.

What CCXT brings to every one of these comparisons

Every comparison

Two kinds of page. Multi-exchange libraries are the tools people genuinely weigh CCXT against when choosing an architecture. Exchange APIs and official SDKs is one page per venue, comparing CCXT with whatever that exchange actually publishes. Regional entities and product lines covers the eleven classes that inherit a parent exchange's implementation.

Multi-exchange libraries and frameworks

• CCXT vs Cryptofeed — Both normalise market data across venues. Cryptofeed is an AGPL Python feed handler with storage backends; CCXT is an MIT trading API in seven languages.

Exchange APIs and official SDKs

• CCXT vs the Binance API and official Binance SDKs — Binance ships 27 separate SDK packages. CCXT covers spot, margin, futures, options and portfolio margin from one client — and still exposes all 808 raw endpoints.
• CCXT vs the Bybit API and pybit — Bybit publishes official connectors in eight languages, but their traction varies from 671 stars to zero. CCXT covers spot, linear, inverse and options from one client and still exposes all 404 raw V5 endpoints.
• CCXT vs the Coinbase APIs and coinbase-advanced-py — Coinbase's trading API is not one API. Advanced Trade, Exchange and International each have their own base URL, their own auth scheme and their own SDK — CCXT covers all three with the same method names.
• CCXT vs the Coinbase Exchange API — Coinbase's own Exchange clients are labelled sample libraries, exist only in Go and TypeScript, and are REST-only. CCXT gives the same API 42 unified capabilities, 10 streaming methods and the sandbox behind one flag.
• CCXT vs the Coinbase International Exchange API — Coinbase International's five first-party SDKs are all labelled samples, are REST-only, and see 13 PyPI and 15 npm installs a month between them. CCXT covers the same API with 47 unified capabilities and 7 streaming methods.
• CCXT vs the OKX API and python-okx — python-okx splits OKX's v5 API into fifteen domain modules you import separately. CCXT gives you one client for spot, margin, futures, swaps and options, with demo trading behind one flag and all 446 raw endpoints still reachable.
• CCXT vs the Kraken Spot and Futures APIs — Kraken Spot and Kraken Futures are two different APIs with two sets of credentials and no official SDK between them. CCXT ships them as kraken and krakenfutures, with the same unified method names on both.
• CCXT vs the HTX API — HTX ships separate spot and contract SDKs in five languages, installed by copying source. CCXT covers spot, margin, futures and swaps from one certified client and still exposes all 460 raw endpoints.
• CCXT vs the Alpaca API and alpaca-py — Alpaca-py is a broker SDK in which crypto is one asset class beside stocks and options, and it speaks to Alpaca only. CCXT covers Alpaca's 38 crypto capabilities with the same method names it uses for 103 other venues.
• CCXT vs the ApeX Omni API and apexpro-openapi — ApeX's official connector is Python-only and handles account onboarding and zk key derivation. CCXT signs Omni orders with the same zk keys in seven languages, behind the API it uses for 103 other venues.
• CCXT vs the Aster API and aster-connector-python — Aster's official connector is Python-only and signs with a v1 API key and secret. CCXT signs Aster v3 requests with EIP-712 typed data from your wallet key, in seven languages, across spot and perps in one client.
• CCXT vs the Backpack Exchange API and its SDKs — Backpack ships one official client, in Rust; every other language is community-built and unendorsed. CCXT covers Backpack's spot, margin and perpetual markets with 69 unified capabilities in seven languages.
• CCXT vs the BingX API — BingX's GitHub organisation publishes documentation repositories, not an SDK. CCXT is a certified BingX integration with 84 unified capabilities, 12 streaming methods and all 188 raw endpoints across eleven API sections.
• CCXT vs the bitbank API and python_bitbankcc — bitbank maintains its own clients in four languages, documented in Japanese and installed from Git. CCXT covers 15 unified capabilities and all 28 endpoints in seven languages — but implements no WebSocket support for this venue.
• CCXT vs the Bitbns API and official Bitbns SDKs — Bitbns addresses markets by bare coin ticker and uses different endpoint names for INR and USDT pairs. CCXT hides both behind unified symbols, but has no WebSocket support for Bitbns — the official Python SDK does.
• CCXT vs the Bitfinex API and official Bitfinex SDKs — Bitfinex v2 returns positional arrays with no field names and splits its official connectors across five separate repositories. CCXT gives you named unified structures, spot, margin and derivatives in one client, and 136 raw endpoints when you need them.
• CCXT vs the bitFlyer API — bitFlyer's Lightning documentation lists no official client libraries, so the real comparison is CCXT against hand-written HTTP. CCXT covers 16 capabilities and 35 endpoints — but has no WebSocket support for bitFlyer.
• CCXT vs the Bitget API and the official Bitget SDK — Bitget's official Python SDK is a signed HTTP client you vendor from the repository. CCXT gives you the same raw reach — 637 Bitget endpoints as named methods — plus 94 unified capabilities in seven languages.
• CCXT vs the Bithumb API — Bithumb's developer docs are Korean-language and ship no SDK: the official onboarding path is "install a JWT library and build the request". CCXT gives you 37 unified capabilities, 67 endpoints and 6 WebSocket methods instead.
• CCXT vs the BitMEX API and official BitMEX connectors — BitMEX's connectors are generated from its Swagger spec, so they hand you the raw shape: one /instrument namespace with a typ code, satoshi-denominated balances and id-keyed order-book deltas. CCXT resolves all three into unified structures.
• CCXT vs the BitoPro API and official BitoPro SDKs — BitoPro's official wrappers mirror its v3 REST API one call at a time, with per-language repositories that move at different speeds. CCXT wraps the same 26 endpoints behind 32 unified capabilities that also work on 103 other venues.
• CCXT vs the Bitrue API — Bitrue publishes API docs and two demo repositories, and says in writing that the SDKs listed are not officially produced. CCXT covers spot and futures with 40 unified capabilities, 65 endpoints and 6 WebSocket methods.
• CCXT vs the Bitso API — Bitso maintains one official SDK — a Java wrapper for REST v3, last released in July 2024. CCXT reaches the same 40 endpoints from seven languages, though neither side streams Bitso's WebSocket.
• CCXT vs the Blockchain.com Exchange API — Blockchain.com's lib-exchange-client covers 13 languages but was archived in January 2026 and ships no WebSocket client. CCXT implements 34 unified capabilities and 6 streaming methods for the venue.
• CCXT vs the BloFin API and official SDK — BloFin's official Python SDK installs from source and was last updated in January 2025. CCXT covers the same venue with 54 unified capabilities, 13 streaming methods and 79 raw endpoints in seven languages.
• CCXT vs the BTC Markets API — BTC Markets' official clients are one small repository per language, most last touched between 2019 and 2024, and the Node SDK is archived. CCXT covers the same v3 API from a maintained dependency in seven languages — but has no WebSocket support for this venue.
• CCXT vs the BTSE API and the official BTSE Python SDK — BTSE publishes an official Python SDK that streams. CCXT gives you 59 unified capabilities and all 128 BTSE endpoints in seven languages, but implements zero watch methods for BTSE.
• CCXT vs the Bullish API — Bullish's own Python client is archived and what remains is a folder of example scripts, so most integrations hand-roll the login-token flow. CCXT implements it — 51 unified capabilities, 7 streaming methods, and the simnext sandbox behind one flag.
• CCXT vs the CEX.IO API and cexio-spot-trading — CEX.IO's official client is a Node.js RPC passthrough — you still name endpoints and parse raw payloads. CCXT gives the same Spot Trading API 43 unified capabilities and 8 streaming methods, in seven languages.
• CCXT vs the Coincheck API and the coincheckjp libraries — Coincheck's official libraries cover seven languages but only the Ruby one has been touched recently. CCXT is maintained across seven languages and adds streaming — while covering fewer Coincheck markets than the venue lists.
• CCXT vs the CoinEx API — CoinEx publishes example scripts in five languages but no installable client library, so the real comparison is CCXT against the raw v2 API. CCXT covers 72 unified capabilities, 10 streaming methods and all 251 raw endpoints.
• CCXT vs the Coinmate API — Coinmate's official clients are example code you vendor into your project, not published packages. CCXT ships Coinmate as an installable dependency with 18 unified capabilities and all 64 raw endpoints.
• CCXT vs the Coinone API — Coinone's developer centre documents the API but ships no official SDK, so the comparison is CCXT against your own HTTP client. CCXT covers 18 unified capabilities, 3 streaming methods and all 63 raw endpoints.
• CCXT vs the Coins.ph API and its official connectors — Coins.ph maintains four official connectors, one per language, with uneven distribution and coverage. CCXT ships 30 unified capabilities and all 78 raw endpoints in seven languages — but has no WebSocket support for this venue.
• CCXT vs the CoinSpot API — CoinSpot's official Node SDK predates its v2 API, so the real comparison is CCXT against the raw REST API. CCXT covers 9 unified capabilities and all 69 raw v1 and v2 endpoints — a deliberately small surface for a small API.
• CCXT vs the Crypto.com Exchange API — Crypto.com publishes documentation and a Rust CLI but no official client library, so integrations are hand-rolled against the v1 API. CCXT covers 58 unified capabilities, 12 streaming methods, order entry over WebSocket and all 129 raw endpoints.
• CCXT vs the Cryptomus API — Cryptomus's official PHP SDK covers payments and payouts, not trading — so its exchange API has no official client. CCXT covers the trading side with 13 unified capabilities and all 16 raw endpoints, but no WebSocket.
• CCXT vs the DeepCoin API — DeepCoin ships Python and Go example scripts but no installable SDK; the only maintained library besides CCXT is a third-party .NET one. CCXT covers 64 unified capabilities, 11 streaming methods and all 53 raw endpoints.
• CCXT vs the Delta Exchange API and delta-rest-client — Delta's official client is one Python package covering REST only. CCXT covers Delta's spot, perpetuals and options in seven languages with 43 unified capabilities — but neither side ships WebSocket support for Delta.
• CCXT vs the Derive API and the official Derive SDKs — Derive ships maintained Python, TypeScript and Rust clients generated from its own specs. CCXT does the same on-chain action signing in seven languages, with 32 unified capabilities and 113 raw endpoints — but not RFQs or vaults.
• CCXT vs the dYdX v4 clients — dYdX v4 orders are signed Cosmos transactions, and the official clients make you drive a node client and an indexer client separately. CCXT builds and broadcasts the same transaction behind one create_order, in seven languages.
• CCXT vs the Extended (x10) Python SDK — Extended's official SDK is Python-only and leans on a Rust library for Stark signing. CCXT does the same Poseidon hashing and Stark signature in seven languages, with 53 unified capabilities and 10 streaming methods.
• CCXT vs the Foxbit API and the official Foxbit SDK — Foxbit's official SDK is a JavaScript and TypeScript REST client. CCXT covers the same REST v3 surface in seven languages with 37 unified capabilities — neither ships WebSocket support beyond Foxbit's own JS sample.
• CCXT vs the Gate API and gateapi-python — Gate's official clients are generated from its OpenAPI spec, so coverage is exhaustive but machine-shaped, and WebSockets live in a second package. CCXT is a curated unified API in seven languages with REST and streaming in one install.
• CCXT vs the Gemini API — Gemini publishes official SDKs for TypeScript and Go only — Python and everything else gets raw HTTP samples. CCXT gives the same venue one API in seven languages, with all 82 raw endpoints still reachable.
• CCXT vs the GRVT API — GRVT's own SDK is Python-only and ships CCXT-shaped classes on purpose. CCXT gives you that same API in seven languages, with all 50 raw GRVT endpoints still reachable.
• CCXT vs the Hibachi API — Hibachi's own SDK is Python 3.13+ only but does include WebSockets, which CCXT's Hibachi integration does not yet. CCXT covers the REST API in seven languages with 33 unified capabilities.
• CCXT vs the HitBTC API — HitBTC ships documentation, not an SDK, so the real comparison is CCXT against raw HTTP. CCXT unifies HitBTC's three parallel spot / margin / futures endpoint families — and the same class drives Bequant and FMFW.io.
• CCXT vs the HollaEx API — HollaEx Kit powers many exchanges that share one v2 API. HollaEx's maintained client library is Node-only and its Python library is archived; CCXT covers the same API in seven languages.
• CCXT vs the Hyperliquid API and the official Hyperliquid SDK — Hyperliquid's whole API is two POST endpoints plus an EIP-712 signature. The official SDK covers it in Python and Rust; CCXT does the same signing in seven languages, behind the API it uses for 103 other venues.
• CCXT vs the Independent Reserve API — Independent Reserve's only official client library is for .NET. CCXT covers the same API in seven languages, handles its unusual comma-joined HMAC signing, and adds order-book and trade streaming.
• CCXT vs the Kraken Futures API — Kraken spot and Kraken Futures are two different APIs, and CCXT ships them as two exchange ids. Kraken's own futures clients are example scripts, last updated between 2019 and 2023; CCXT gives krakenfutures 53 unified capabilities and 12 watch* methods.
• CCXT vs the KuCoin API and the KuCoin Universal SDK — KuCoin archived its per-language SDKs and replaced them with a generated Universal SDK whose PHP and Java builds are still alpha. CCXT's kucoin class did not change shape through any of it, and covers spot, margin and futures from one client.
• CCXT vs the LATOKEN API — LATOKEN addresses markets by pairs of currency UUIDs; CCXT resolves them to 'BTC/USDT' and gives you 22 unified capabilities. LATOKEN's own client wins on one axis — CCXT has no WebSocket support for this venue.
• CCXT vs the LBank API and official LBank connectors — LBank's connectors pass raw endpoint paths through and leave parsing to you. CCXT's lbank class gives 39 unified capabilities, 6 watch* streams, and picks between LBank's HMAC and RSA signing automatically.
• CCXT vs the Lighter API and official Lighter SDK — Lighter orders are signed zk transactions, so both CCXT and the official SDK call the same native signer binary. CCXT adds 56 unified capabilities, 18 watch* methods and seven languages on top of it.
• CCXT vs the Luno API and official Luno SDKs — Luno's own SDKs cover Python, Go and PHP with one method per endpoint. CCXT gives Luno 25 unified capabilities in seven languages — but only two watch* methods, against Go's fuller streaming client.
• CCXT vs the MEXC API and official MEXC SDK — MEXC's official SDK is spot-only, has no WebSocket client, and is distributed by git clone. CCXT covers spot, margin and swap in one class, with 16 watch* methods that decode MEXC's protobuf streams.
• CCXT vs the Mode Trade API — Mode Trade ships no SDK. Its API is Orderly Network's EVM orderbook, for which Orderly publishes a Python connector and TypeScript SDKs. CCXT covers the same host with 56 unified capabilities and 10 watch* methods in seven languages.
• CCXT vs the Mudrex API and the official Mudrex Python SDK — mudrex-sdk is Python-only, wraps the futures trading API and states plainly that it does not throttle requests. CCXT covers the same API with 30 unified capabilities, three watch* methods and a rate limiter that is on by default, in seven languages.
• CCXT vs the Nado API and the official Nado SDKs — Nado's own SDKs expose the protocol as it really is — product ids, X18 fixed-point, EIP-712 payloads. CCXT hides all of that behind 63 unified capabilities and 24 streaming methods, in seven languages.
• CCXT vs the official Bitvavo SDKs — Bitvavo's Python and Node SDKs are maintained; its Java, Go and PHP wrappers are archived. CCXT covers Bitvavo in all seven of its languages with 74 unified capabilities and 17 streaming methods.
• CCXT vs the P2B API and the official PHP client — P2B's only official client is a four-commit PHP library from 2022 that requires PHP 7.2. CCXT covers the same v2 API in seven languages, with six streaming methods and a rate limiter tuned to P2B's documented 10 requests per second.
• CCXT vs the Pacifica API and the Pacifica Python examples — Pacifica's "Python SDK" is an examples repository, not an installable package. CCXT implements the same Ed25519 sorted-JSON signing as a library, with 59 unified capabilities, 13 watch*/unWatch* methods and credit-aware rate limiting.
• CCXT vs the Paradex API and the official Paradex SDKs — Paradex publishes Python and JavaScript SDKs; both do the L1-to-L2 onboarding and JWT dance. CCXT does the same derivation internally and adds 50 unified capabilities, options markets and seven languages.
• CCXT vs the Phemex API and Phemex sample clients — Phemex's API encodes prices and quantities as scaled integers (priceEp, valueEv). CCXT decodes them into decimals, covers spot and swap in one class, and exposes all 115 raw endpoints.
• CCXT vs the Poloniex API and official Poloniex SDKs — Poloniex's official spot and futures SDKs are separate repositories, and the futures one is archived. CCXT covers spot and v3 futures in one class, with 9 watch* methods and WebSocket order entry.
• CCXT vs the raw BigONE API — BigONE ships OpenAPI specifications and no SDK in any language. CCXT covers 29 unified capabilities and all 41 endpoints across the v3 spot and v2 contract APIs — but implements no WebSocket support for this venue.
• CCXT vs the raw BIT.TEAM API — BIT.TEAM has no client library in any language, and several of its REST endpoints are literally named /trade/api/ccxt/. CCXT is the integration path the venue points at, in seven languages.
• CCXT vs the raw Bit2C API — Bit2C has no client library in any language — the only wrappers are small community projects. CCXT covers 12 unified capabilities and all 23 endpoints on its four NIS markets, and implements no WebSocket support for this venue.
• CCXT vs the raw Bitstamp API — Bitstamp ships documentation, not an SDK — the most-used Python client is a community project whose last commit was in 2022. CCXT covers 263 Bitstamp endpoints plus three WebSocket streams in seven languages.
• CCXT vs the raw BitTrade API — BitTrade's only public GitHub repository is documentation — there is no SDK in any language. CCXT covers 31 unified methods, 110 raw endpoints and four WebSocket streams for the venue.
• CCXT vs the raw BtcBox API — BtcBox has no client library — the only first-party code is a four-commit demo script. Its API is small enough that the real question is whether you want portability, not whether you can write it.
• CCXT vs the raw BTCTurk API — BTCTurk's only first-party clients are a C# wrapper last pushed in 2021 and an Objective-C one from 2015, so most integrations are hand-written HTTP. CCXT covers 14 unified capabilities and all 16 endpoints — but implements no WebSocket support for this venue.
• CCXT vs the raw BYDFi API — BYDFi ships no SDK — there is no bydfi package on npm or PyPI, and its only GitHub repository is documentation. CCXT implements 60 unified capabilities and 10 streaming methods against its perpetual-futures API.
• CCXT vs the raw Deribit API — Deribit's GitHub organisation has no public repositories and its docs link no SDK, so integrating means hand-writing JSON-RPC. CCXT covers 64 unified capabilities, 12 streaming methods and all 122 endpoints, including options.
• CCXT vs the raw DigiFinex REST API — DigiFinex's GitHub repository is docs only and no SDK is published on npm or PyPI. CCXT gives its spot, margin and swap products 48 unified capabilities and all 88 endpoints — but no WebSocket support.
• CCXT vs the raw HashKey Global REST API — HashKey Global ships documentation, not an SDK, so the comparison is CCXT against raw HTTP. HashKey is a certified CCXT exchange with 59 unified capabilities, 7 streaming methods and a working sandbox.
• CCXT vs the raw INDODAX REST API — INDODAX ships documentation, not an SDK — the only repository on its GitHub organisation is the API docs. CCXT's indodax class gives you 19 unified capabilities and 22 signed endpoints, but no WebSocket support.
• CCXT vs the raw Mercado Bitcoin API — Mercado Bitcoin ships documentation and code samples, not a client library. CCXT's mercado class gives 15 unified capabilities over the v3 trade API and v4 candles — with no WebSocket support and no v4 trading endpoints.
• CCXT vs the raw NDAX API — NDAX ships documentation, not a client library. The comparison is CCXT's ndax class against writing the AlphaPoint auth handshake, OMS-id plumbing, 2FA sign-in and reconnect logic yourself.
• CCXT vs the raw One Trading API — The Bitpanda Pro SDK is gone and One Trading publishes no replacement. CCXT's onetrading class covers the spot API with 30 unified capabilities and seven watch* methods — but not One Trading's newer futures endpoints.
• CCXT vs the raw Paymium API — Paymium publishes no client library in any language CCXT covers, and its documentation's own examples use ccxt. CCXT implements 12 capabilities and all 24 endpoints for BTC/EUR — but has no WebSocket support for this venue.
• CCXT vs the raw Toobit API — Toobit ships code examples, not a maintained SDK. CCXT gives it 49 unified capabilities, 11 watch* streaming methods and all 87 raw endpoints behind one client.
• CCXT vs the raw WEEX API — WEEX ships documentation but no SDK. CCXT gives it 92 unified capabilities — its widest coverage of any venue in this group — 25 streaming methods and all 80 raw endpoints.
• CCXT vs the raw WOO X API — WOO X ships documentation and signing examples but no client library. CCXT is a certified integration for it — 79 unified capabilities, 16 watch* methods and all 133 raw endpoints.
• CCXT vs the raw Zaif REST API — Zaif has no maintained client library — the Python and Node wrappers stopped shipping releases in 2018 and 2017. CCXT's zaif class covers 11 unified capabilities and all 34 raw endpoints, including the leverage and futures groups.
• CCXT vs the Revolut X API — Revolut X's API is deliberately small — 16 REST endpoints, Ed25519 signing, no streaming. Its official client is TypeScript only; CCXT covers effectively the same surface in seven languages.
• CCXT vs the Tokocrypto API — Tokocrypto has no SDK of its own and names CCXT as its authorized SDK provider. Its API is Binance-shaped, and CCXT's class reflects that by routing market data through Binance's public endpoints.
• CCXT vs the Upbit API and official Upbit SDKs — Upbit's official SDKs are genuinely good and Upbit-shaped. CCXT trades that literalness for one API across 104 venues, unified KRW symbols, JWT signing and 9 watch* methods.
• CCXT vs the WhiteBIT API and official WhiteBIT SDKs — WhiteBIT has one of the broadest official SDK families of any mid-size venue — Python, Go, PHP, TypeScript and Rust. CCXT trades that literalness for 67 unified capabilities across 104 exchanges.
• CCXT vs the WOOFi Pro API and the Orderly Network connectors — WOOFi Pro is a broker on Orderly Network, so its API is the Orderly EVM API. Orderly's own connectors are Python and a React-oriented JS monorepo; CCXT does the same ed25519 signing in seven languages, and WOOFi's docs point at it.
• CCXT vs the XT.com API and pyxt — XT.com splits spot, USDT-M, COIN-M and user endpoints across four hosts with two different signing schemes, and ships one Python connector plus per-language demo repos. CCXT covers all of it from one client in seven languages.
• CCXT vs the ZebPay API and its reference clients — ZebPay's official clients live inside its API-reference repository rather than on npm or PyPI, cover futures only, and one of them is a CCXT wrapper. CCXT's zebpay class covers spot and futures, INR and USDT markets, from one install.

Regional entities and product lines

• CCXT vs the Bequant API — A white-label venue of HitBTC, shipped as its own CCXT class. Inherits 65 unified capabilities and 111 raw endpoints from hitbtc.
• CCXT vs the Binance COIN-M Futures API — A product line of Binance, shipped as its own CCXT class. Inherits 153 unified capabilities and 808 raw endpoints from binance.
• CCXT vs the Binance USDⓈ-M Futures API — A product line of Binance, shipped as its own CCXT class. Inherits 153 unified capabilities and 808 raw endpoints from binance.
• CCXT vs the Binance.US API — A regional entity of Binance, shipped as its own CCXT class. Inherits 103 unified capabilities and 860 raw endpoints from binance.
• CCXT vs the Bybit EU API — A regional entity of Bybit, shipped as its own CCXT class. Inherits 123 unified capabilities and 404 raw endpoints from bybit.
• CCXT vs the FMFW.io API — A white-label venue of HitBTC, shipped as its own CCXT class. Inherits 54 unified capabilities and 111 raw endpoints from hitbtc.
• CCXT vs the Gate EU API — A regional entity of Gate, shipped as its own CCXT class. Inherits 113 unified capabilities and 339 raw endpoints from gate.
• CCXT vs the KuCoin Futures API — A product line of KuCoin, shipped as its own CCXT class. Inherits 111 unified capabilities and 351 raw endpoints from kucoin.
• CCXT vs the MyOKX (EEA) API — A regional entity of OKX, shipped as its own CCXT class. Inherits 121 unified capabilities and 446 raw endpoints from okx.
• CCXT vs the OKX US API — A regional entity of OKX, shipped as its own CCXT class. Inherits 122 unified capabilities and 446 raw endpoints from okx.

Not sure where to start?

• Install CCXT — pick your language
• Manual — the unified API and its structures
• Supported exchanges — the full list
• CCXT Pro manual — WebSocket streaming
• FAQ

Spotted something inaccurate or out of date on one of these pages? Alternatives improve, and we would rather be corrected than wrong — open an issue or say so on Discord.