dcex - DEX & CEX trading library

English | 繁體中文

dcex is a Rust-backed crypto exchange API library with synchronous and asynchronous Python clients and a standalone Rust crate. It covers market data, account queries, order APIs, and public and private WebSocket streams for centralized exchanges (Binance, Bybit, OKX, Bitget, Kraken, MEXC, BingX) and decentralized perpetual exchanges (Hyperliquid, Lighter, Backpack, Aster, Extended, Ondo, Arcus).

Broker codes: dcex does not set or attach a broker code or broker tag by default. You can specify one explicitly when the exchange API supports it.

Forked from krex, a simplified version of the ccxt Python library.

Installation

Python:

pip install dcex
# or, in a uv-managed project:
uv add dcex

Rust:

cargo add dcex

Key features

• Synchronous and asynchronous Python HTTP clients, plus public and private WebSocket clients.
• HTTP, WebSocket, and signing APIs for direct use from Rust.
• A Product Table Manager (PTM) that normalizes exchange symbols and trading specifications.
• Support for multiple CEX and DEX platforms; available endpoints vary by exchange.

Compared with ccxt

ccxt offers one unified API across 100+ exchanges. dcex covers fewer exchanges and keeps each exchange's own endpoints instead:

• Exchange-native methods and parameters, with coverage tracked endpoint by endpoint against the official docs.
• Signing, serialization and response validation run in Rust, including DEX signing for Hyperliquid, Lighter and Extended.
• The same core is available from Python (sync and async) and Rust.
• Normalized symbols (BTC-USDT-SWAP) and trading specifications through the Product Table Manager.

Documented withdrawal, market-maker and partner endpoints are in scope; current coverage and specification gaps are recorded in the endpoint ledger. API withdrawals have no second confirmation; they execute on submit. Trading API keys should not have withdrawal permission. PTM includes listed options from Binance, Bybit, and OKX; option trading remains exchange-specific.

Supported exchanges

Bitget began migrating accounts to UTA on 2026-09-15. Classic-account private endpoints that Bitget rejects for UTA accounts (error 40085) have been removed; public market-data, tax and institutional-loan endpoints that still work remain. Use a UTA account for trading. See the official UTA upgrade guide and account settings.

Private WebSocket support includes authenticated or address-scoped user-data streams. Trading WebSocket APIs are available for Binance, Bybit, Bitget, OKX and Kraken Spot; Hyperliquid and Lighter accept signed actions, and Arcus provides signed request construction. Lighter Mainnet and Robinhood use separate credential profiles; select the network per client (Mainnet is the default); see .env.example and the Lighter examples. Ondo spot currently supports only public market data (depth, trades, symbol_info, history and WS spot channels); Ondo has not published its spot trading API, so private operations such as placing or cancelling orders with a -SPOT symbol fail locally without sending a request.

Endpoint coverage, limitations and verification.

Python quick start

Synchronous HTTP:

import dcex

client = dcex.binance()
print(client.get_klines(product_symbol="BTC-USDT-SWAP", interval="1m"))

Asynchronous HTTP:

import asyncio
import dcex.async_support as dcex

async def main():
    client = await dcex.binance()
    try:
        print(await client.get_klines(product_symbol="BTC-USDT-SWAP", interval="1m"))
    finally:
        await client.close()

asyncio.run(main())

Additional profiles cover Binance Alpha, Aster Prediction and Kraken Spot V1. Bitget SBE returns raw binary frames for caller-side decoding.

Public WebSocket:

import asyncio
from dcex.ws import binance

async def main():
    async with binance.public() as ws:
        await ws.subscribe_agg_trades("BTC-USDT-SPOT")
        print(await ws.recv())

asyncio.run(main())

Product Table Manager

PTM maps normalized product_symbol values, such as BTC-USDT-SWAP, to exchange-native exchange_symbol values and exposes trading metadata. Clients use this mapping where applicable.

Binance and BingX coin-margined contracts sit in their own exchange namespaces, binance_coinm and bingx_coinm (for example BTC-USD-SWAP), so they never collide with USDT-margined products; their coin-margined methods resolve symbols there.

from dcex.product_table.manager import ProductTableManager

table = ProductTableManager.get_instance("binance")
print(table.get_exchange_symbol("binance", "BTC-USDT-SWAP"))
print(table.get_product_symbol("binance", "BTCUSDT", product_type="swap"))
print(table.rows()[0])

Hyperliquid loads its first perp DEX, spot and every builder-deployed (HIP-3) perp DEX by default. Pass perp_dexs to load only the builder DEXs you trade; names come from get_perp_dexs, unknown names are rejected, and asset ids stay the same as with the full table:

from dcex.hyperliquid import Client

client = Client(perp_dexs=["xyz"])
table = ProductTableManager.get_instance("hyperliquid", perp_dexs=["xyz"])

Lighter nonces

Every Lighter transaction method accepts nonce. Without it, dcex asks the exchange for the next nonce, which costs one request per transaction. Trading systems usually keep the nonce themselves:

• Read the starting value once per API key with get_next_nonce(api_key_index=...).
• Increment it locally and pass nonce= with each transaction, holding a lock if several tasks share the key.
• After a failed transaction or a nonce error, read get_next_nonce again; a rejected transaction may not consume its nonce.
• Give each process its own api_key_index so their nonces never collide.

More examples and development

Runnable examples are in Python sync, Python async and WebSocket, and Rust. They focus on public data or read-only account queries. Private HTTP examples require credentials; private stream examples require credentials or a user address.

uv run python examples/sync/binance_public.py
uv run python examples/async/binance_ws_public.py
cargo run -p dcex --example binance_ws_public

For direct Rust usage, see the crate README. The default test suite runs offline with uv run pytest; live suites are opt-in. See the contributing guide for development and testing details.

This project uses the MIT License; see the third-party notices for additional licenses.