CCXT for Python A comprehensive guide to using CCXT in Python projects for cryptocurrency exchange integration. Installation REST API (Standard) pip install ccxt WebSocket API (Real-time, ccxt.pro) pip install ccxt Optional Performance Enhancements pip install orjson

Faster JSON parsing

pip install coincurve

Faster ECDSA signing (45ms → 0.05ms)

Both REST and WebSocket APIs are included in the same package. Quick Start REST API - Synchronous import ccxt exchange = ccxt . binance ( ) exchange . load_markets ( ) ticker = exchange . fetch_ticker ( 'BTC/USDT' ) print ( ticker ) REST API - Asynchronous import asyncio import ccxt . async_support as ccxt async def main ( ) : exchange = ccxt . binance ( ) await exchange . load_markets ( ) ticker = await exchange . fetch_ticker ( 'BTC/USDT' ) print ( ticker ) await exchange . close ( )

Important!

asyncio . run ( main ( ) ) WebSocket API - Real-time Updates import asyncio import ccxt . pro as ccxtpro async def main ( ) : exchange = ccxtpro . binance ( ) while True : ticker = await exchange . watch_ticker ( 'BTC/USDT' ) print ( ticker )

Live updates!

await exchange . close ( ) asyncio . run ( main ( ) ) REST vs WebSocket Import For REST For WebSocket Sync import ccxt (WebSocket requires async) Async import ccxt.async_support as ccxt import ccxt.pro as ccxtpro Feature REST API WebSocket API Use for One-time queries, placing orders Real-time monitoring, live price feeds Method prefix fetch_ (fetch_ticker, fetch_order_book) watch_ (watch_ticker, watch_order_book) Speed Slower (HTTP request/response) Faster (persistent connection) Rate limits Strict (1-2 req/sec) More lenient (continuous stream) Best for Trading, account management Price monitoring, arbitrage detection When to use REST: Placing orders Fetching account balance One-time data queries Order management (cancel, fetch orders) When to use WebSocket: Real-time price monitoring Live orderbook updates Arbitrage detection Portfolio tracking with live updates Creating Exchange Instance REST API - Synchronous import ccxt

Public API (no authentication)

exchange

ccxt . binance ( { 'enableRateLimit' : True

Recommended!

} )

Private API (with authentication)

exchange

ccxt . binance ( { 'apiKey' : 'YOUR_API_KEY' , 'secret' : 'YOUR_SECRET' , 'enableRateLimit' : True } ) REST API - Asynchronous import ccxt . async_support as ccxt exchange = ccxt . binance ( { 'apiKey' : 'YOUR_API_KEY' , 'secret' : 'YOUR_SECRET' , 'enableRateLimit' : True } )

Always close when done

await exchange . close ( ) WebSocket API import ccxt . pro as ccxtpro

Public WebSocket

exchange

ccxtpro . binance ( )

Private WebSocket (with authentication)

exchange

ccxtpro . binance ( { 'apiKey' : 'YOUR_API_KEY' , 'secret' : 'YOUR_SECRET' } )

Always close when done

await exchange . close ( ) Common REST Operations Loading Markets

Load all available trading pairs

exchange . load_markets ( )

Access market information

btc_market

exchange . market ( 'BTC/USDT' ) print ( btc_market [ 'limits' ] [ 'amount' ] [ 'min' ] )

Minimum order amount

Fetching Ticker

Single ticker

ticker

exchange . fetch_ticker ( 'BTC/USDT' ) print ( ticker [ 'last' ] )

Last price

print ( ticker [ 'bid' ] )

Best bid

print ( ticker [ 'ask' ] )

Best ask

print ( ticker [ 'volume' ] )

24h volume

Multiple tickers (if supported)

tickers

exchange . fetch_tickers ( [ 'BTC/USDT' , 'ETH/USDT' ] ) Fetching Order Book

Full orderbook

orderbook

exchange . fetch_order_book ( 'BTC/USDT' ) print ( orderbook [ 'bids' ] [ 0 ] )

[price, amount]

print ( orderbook [ 'asks' ] [ 0 ] )

[price, amount]

Limited depth

orderbook

exchange . fetch_order_book ( 'BTC/USDT' , 5 )

Top 5 levels

Creating Orders Limit Order

Buy limit order

order

exchange . create_limit_buy_order ( 'BTC/USDT' , 0.01 , 50000 ) print ( order [ 'id' ] )

Sell limit order

order

exchange . create_limit_sell_order ( 'BTC/USDT' , 0.01 , 60000 )

Generic limit order

order

exchange . create_order ( 'BTC/USDT' , 'limit' , 'buy' , 0.01 , 50000 ) Market Order

Buy market order

order

exchange . create_market_buy_order ( 'BTC/USDT' , 0.01 )

Sell market order

order

exchange . create_market_sell_order ( 'BTC/USDT' , 0.01 )

Generic market order

order

exchange . create_order ( 'BTC/USDT' , 'market' , 'sell' , 0.01 ) Fetching Balance balance = exchange . fetch_balance ( ) print ( balance [ 'BTC' ] [ 'free' ] )

Available balance

print ( balance [ 'BTC' ] [ 'used' ] )

Balance in orders

print ( balance [ 'BTC' ] [ 'total' ] )

Total balance

Fetching Orders

Open orders

open_orders

exchange . fetch_open_orders ( 'BTC/USDT' )

Closed orders

closed_orders

exchange . fetch_closed_orders ( 'BTC/USDT' )

All orders (open + closed)

all_orders

exchange . fetch_orders ( 'BTC/USDT' )

Single order by ID

order

exchange . fetch_order ( order_id , 'BTC/USDT' ) Fetching Trades

Recent public trades

trades

exchange . fetch_trades ( 'BTC/USDT' , limit = 10 )

Your trades (requires authentication)

my_trades

exchange . fetch_my_trades ( 'BTC/USDT' ) Canceling Orders

Cancel single order

exchange . cancel_order ( order_id , 'BTC/USDT' )

Cancel all orders for a symbol

exchange . cancel_all_orders ( 'BTC/USDT' ) WebSocket Operations (Real-time) Watching Ticker (Live Price Updates) import asyncio import ccxt . pro as ccxtpro async def main ( ) : exchange = ccxtpro . binance ( ) while True : ticker = await exchange . watch_ticker ( 'BTC/USDT' ) print ( ticker [ 'last' ] , ticker [ 'timestamp' ] ) await exchange . close ( ) asyncio . run ( main ( ) ) Watching Order Book (Live Depth Updates) async def main ( ) : exchange = ccxtpro . binance ( ) while True : orderbook = await exchange . watch_order_book ( 'BTC/USDT' ) print ( 'Best bid:' , orderbook [ 'bids' ] [ 0 ] ) print ( 'Best ask:' , orderbook [ 'asks' ] [ 0 ] ) await exchange . close ( ) asyncio . run ( main ( ) ) Watching Trades (Live Trade Stream) async def main ( ) : exchange = ccxtpro . binance ( ) while True : trades = await exchange . watch_trades ( 'BTC/USDT' ) for trade in trades : print ( trade [ 'price' ] , trade [ 'amount' ] , trade [ 'side' ] ) await exchange . close ( ) asyncio . run ( main ( ) ) Watching Your Orders (Live Order Updates) async def main ( ) : exchange = ccxtpro . binance ( { 'apiKey' : 'YOUR_API_KEY' , 'secret' : 'YOUR_SECRET' } ) while True : orders = await exchange . watch_orders ( 'BTC/USDT' ) for order in orders : print ( order [ 'id' ] , order [ 'status' ] , order [ 'filled' ] ) await exchange . close ( ) asyncio . run ( main ( ) ) Watching Balance (Live Balance Updates) async def main ( ) : exchange = ccxtpro . binance ( { 'apiKey' : 'YOUR_API_KEY' , 'secret' : 'YOUR_SECRET' } ) while True : balance = await exchange . watch_balance ( ) print ( 'BTC:' , balance [ 'BTC' ] ) print ( 'USDT:' , balance [ 'USDT' ] ) await exchange . close ( ) asyncio . run ( main ( ) ) Watching Multiple Symbols async def main ( ) : exchange = ccxtpro . binance ( ) symbols = [ 'BTC/USDT' , 'ETH/USDT' , 'SOL/USDT' ] while True :

Watch all symbols concurrently

tickers

await exchange . watch_tickers ( symbols ) for symbol , ticker in tickers . items ( ) : print ( symbol , ticker [ 'last' ] ) await exchange . close ( ) asyncio . run ( main ( ) ) Complete Method Reference Market Data Methods Tickers & Prices fetchTicker(symbol) - Fetch ticker for one symbol fetchTickers([symbols]) - Fetch multiple tickers at once fetchBidsAsks([symbols]) - Fetch best bid/ask for multiple symbols fetchLastPrices([symbols]) - Fetch last prices fetchMarkPrices([symbols]) - Fetch mark prices (derivatives) Order Books fetchOrderBook(symbol, limit) - Fetch order book fetchOrderBooks([symbols]) - Fetch multiple order books fetchL2OrderBook(symbol) - Fetch level 2 order book fetchL3OrderBook(symbol) - Fetch level 3 order book (if supported) Trades fetchTrades(symbol, since, limit) - Fetch public trades fetchMyTrades(symbol, since, limit) - Fetch your trades (auth required) fetchOrderTrades(orderId, symbol) - Fetch trades for specific order OHLCV (Candlesticks) fetchOHLCV(symbol, timeframe, since, limit) - Fetch candlestick data fetchIndexOHLCV(symbol, timeframe) - Fetch index price OHLCV fetchMarkOHLCV(symbol, timeframe) - Fetch mark price OHLCV fetchPremiumIndexOHLCV(symbol, timeframe) - Fetch premium index OHLCV Account & Balance fetchBalance() - Fetch account balance (auth required) fetchAccounts() - Fetch sub-accounts fetchLedger(code, since, limit) - Fetch ledger history fetchLedgerEntry(id, code) - Fetch specific ledger entry fetchTransactions(code, since, limit) - Fetch transactions fetchDeposits(code, since, limit) - Fetch deposit history fetchWithdrawals(code, since, limit) - Fetch withdrawal history fetchDepositsWithdrawals(code, since, limit) - Fetch both deposits and withdrawals Trading Methods Creating Orders createOrder(symbol, type, side, amount, price, params) - Create order (generic) createLimitOrder(symbol, side, amount, price) - Create limit order createMarketOrder(symbol, side, amount) - Create market order createLimitBuyOrder(symbol, amount, price) - Buy limit order createLimitSellOrder(symbol, amount, price) - Sell limit order createMarketBuyOrder(symbol, amount) - Buy market order createMarketSellOrder(symbol, amount) - Sell market order createMarketBuyOrderWithCost(symbol, cost) - Buy with specific cost createStopLimitOrder(symbol, side, amount, price, stopPrice) - Stop-limit order createStopMarketOrder(symbol, side, amount, stopPrice) - Stop-market order createStopLossOrder(symbol, side, amount, stopPrice) - Stop-loss order createTakeProfitOrder(symbol, side, amount, takeProfitPrice) - Take-profit order createTrailingAmountOrder(symbol, side, amount, trailingAmount) - Trailing stop createTrailingPercentOrder(symbol, side, amount, trailingPercent) - Trailing stop % createTriggerOrder(symbol, side, amount, triggerPrice) - Trigger order createPostOnlyOrder(symbol, side, amount, price) - Post-only order createReduceOnlyOrder(symbol, side, amount, price) - Reduce-only order createOrders([orders]) - Create multiple orders at once createOrderWithTakeProfitAndStopLoss(symbol, type, side, amount, price, tpPrice, slPrice) - OCO order Managing Orders fetchOrder(orderId, symbol) - Fetch single order fetchOrders(symbol, since, limit) - Fetch all orders fetchOpenOrders(symbol, since, limit) - Fetch open orders fetchClosedOrders(symbol, since, limit) - Fetch closed orders fetchCanceledOrders(symbol, since, limit) - Fetch canceled orders fetchOpenOrder(orderId, symbol) - Fetch specific open order fetchOrdersByStatus(status, symbol) - Fetch orders by status cancelOrder(orderId, symbol) - Cancel single order cancelOrders([orderIds], symbol) - Cancel multiple orders cancelAllOrders(symbol) - Cancel all orders for symbol editOrder(orderId, symbol, type, side, amount, price) - Modify order Margin & Leverage fetchBorrowRate(code) - Fetch borrow rate for margin fetchBorrowRates([codes]) - Fetch multiple borrow rates fetchBorrowRateHistory(code, since, limit) - Historical borrow rates fetchCrossBorrowRate(code) - Cross margin borrow rate fetchIsolatedBorrowRate(symbol, code) - Isolated margin borrow rate borrowMargin(code, amount, symbol) - Borrow margin repayMargin(code, amount, symbol) - Repay margin fetchLeverage(symbol) - Fetch leverage setLeverage(leverage, symbol) - Set leverage fetchLeverageTiers(symbols) - Fetch leverage tiers fetchMarketLeverageTiers(symbol) - Leverage tiers for market setMarginMode(marginMode, symbol) - Set margin mode (cross/isolated) fetchMarginMode(symbol) - Fetch margin mode Derivatives & Futures Positions fetchPosition(symbol) - Fetch single position fetchPositions([symbols]) - Fetch all positions fetchPositionsForSymbol(symbol) - Fetch positions for symbol fetchPositionHistory(symbol, since, limit) - Position history fetchPositionsHistory(symbols, since, limit) - Multiple position history fetchPositionMode(symbol) - Fetch position mode (one-way/hedge) setPositionMode(hedged, symbol) - Set position mode closePosition(symbol, side) - Close position closeAllPositions() - Close all positions Funding & Settlement fetchFundingRate(symbol) - Current funding rate fetchFundingRates([symbols]) - Multiple funding rates fetchFundingRateHistory(symbol, since, limit) - Funding rate history fetchFundingHistory(symbol, since, limit) - Your funding payments fetchFundingInterval(symbol) - Funding interval fetchSettlementHistory(symbol, since, limit) - Settlement history fetchMySettlementHistory(symbol, since, limit) - Your settlement history Open Interest & Liquidations fetchOpenInterest(symbol) - Open interest for symbol fetchOpenInterests([symbols]) - Multiple open interests fetchOpenInterestHistory(symbol, timeframe, since, limit) - OI history fetchLiquidations(symbol, since, limit) - Public liquidations fetchMyLiquidations(symbol, since, limit) - Your liquidations Options fetchOption(symbol) - Fetch option info fetchOptionChain(code) - Fetch option chain fetchGreeks(symbol) - Fetch option greeks fetchVolatilityHistory(code, since, limit) - Volatility history fetchUnderlyingAssets() - Fetch underlying assets Fees & Limits fetchTradingFee(symbol) - Trading fee for symbol fetchTradingFees([symbols]) - Trading fees for multiple symbols fetchTradingLimits([symbols]) - Trading limits fetchTransactionFee(code) - Transaction/withdrawal fee fetchTransactionFees([codes]) - Multiple transaction fees fetchDepositWithdrawFee(code) - Deposit/withdrawal fee fetchDepositWithdrawFees([codes]) - Multiple deposit/withdraw fees Deposits & Withdrawals fetchDepositAddress(code, params) - Get deposit address fetchDepositAddresses([codes]) - Multiple deposit addresses fetchDepositAddressesByNetwork(code) - Addresses by network createDepositAddress(code, params) - Create new deposit address fetchDeposit(id, code) - Fetch single deposit fetchWithdrawal(id, code) - Fetch single withdrawal fetchWithdrawAddresses(code) - Fetch withdrawal addresses fetchWithdrawalWhitelist(code) - Fetch whitelist withdraw(code, amount, address, tag, params) - Withdraw funds deposit(code, amount, params) - Deposit funds (if supported) Transfer & Convert transfer(code, amount, fromAccount, toAccount) - Internal transfer fetchTransfer(id, code) - Fetch transfer info fetchTransfers(code, since, limit) - Fetch transfer history fetchConvertCurrencies() - Currencies available for convert fetchConvertQuote(fromCode, toCode, amount) - Get conversion quote createConvertTrade(fromCode, toCode, amount) - Execute conversion fetchConvertTrade(id) - Fetch convert trade fetchConvertTradeHistory(code, since, limit) - Convert history Market Info fetchMarkets() - Fetch all markets fetchCurrencies() - Fetch all currencies fetchTime() - Fetch exchange server time fetchStatus() - Fetch exchange status fetchBorrowInterest(code, symbol, since, limit) - Borrow interest paid fetchLongShortRatio(symbol, timeframe, since, limit) - Long/short ratio fetchLongShortRatioHistory(symbol, timeframe, since, limit) - L/S ratio history WebSocket Methods (ccxt.pro) All REST methods have WebSocket equivalents with watch prefix: Real-time Market Data watchTicker(symbol) - Watch single ticker watchTickers([symbols]) - Watch multiple tickers watchOrderBook(symbol) - Watch order book updates watchOrderBookForSymbols([symbols]) - Watch multiple order books watchTrades(symbol) - Watch public trades watchOHLCV(symbol, timeframe) - Watch candlestick updates watchBidsAsks([symbols]) - Watch best bid/ask Real-time Account Data (Auth Required) watchBalance() - Watch balance updates watchOrders(symbol) - Watch your order updates watchMyTrades(symbol) - Watch your trade updates watchPositions([symbols]) - Watch position updates watchPositionsForSymbol(symbol) - Watch positions for symbol Authentication Required Methods marked with 🔒 require API credentials: All create methods (creating orders, addresses) All cancel methods (canceling orders) All edit methods (modifying orders) All fetchMy methods (your trades, orders) fetchBalance , fetchLedger , fetchAccounts withdraw , transfer , deposit Margin/leverage methods Position methods watchBalance , watchOrders , watchMyTrades , watchPositions Checking Method Availability Not all exchanges support all methods. Check before using: // Check if method is supported if (exchange.has['fetchOHLCV']) { const candles = await exchange.fetchOHLCV('BTC/USDT', '1h') } // Check multiple capabilities console.log(exchange.has) // { // fetchTicker: true, // fetchOHLCV: true, // fetchMyTrades: true, // fetchPositions: false, // ... // } Method Naming Convention fetch - REST API methods (HTTP requests) watch - WebSocket methods (real-time streams) create - Create new resources (orders, addresses) cancel - Cancel existing resources edit - Modify existing resources set - Configure settings (leverage, margin mode) Ws suffix - WebSocket variant (some exchanges) Proxy Configuration CCXT supports HTTP, HTTPS, and SOCKS proxies for both REST and WebSocket connections. Setting Proxy // HTTP Proxy exchange.httpProxy = 'http://your-proxy-host:port' // HTTPS Proxy exchange.httpsProxy = 'https://your-proxy-host:port' // SOCKS Proxy exchange.socksProxy = 'socks://your-proxy-host:port' // Proxy with authentication exchange.httpProxy = 'http://user:pass@proxy-host:port' Proxy for WebSocket WebSocket connections also respect proxy settings: exchange.httpsProxy = 'https://proxy:8080' // WebSocket connections will use this proxy Testing Proxy Connection exchange.httpProxy = 'http://localhost:8080' try { await exchange.fetchTicker('BTC/USDT') console.log('Proxy working!') } catch (error) { console.error('Proxy connection failed:', error) } WebSocket-Specific Methods Some exchanges provide WebSocket variants of REST methods for faster order placement and management. These use the Ws suffix: Trading via WebSocket Creating Orders: createOrderWs - Create order via WebSocket (faster than REST) createLimitOrderWs - Create limit order via WebSocket createMarketOrderWs - Create market order via WebSocket createLimitBuyOrderWs - Buy limit order via WebSocket createLimitSellOrderWs - Sell limit order via WebSocket createMarketBuyOrderWs - Buy market order via WebSocket createMarketSellOrderWs - Sell market order via WebSocket createStopLimitOrderWs - Stop-limit order via WebSocket createStopMarketOrderWs - Stop-market order via WebSocket createStopLossOrderWs - Stop-loss order via WebSocket createTakeProfitOrderWs - Take-profit order via WebSocket createTrailingAmountOrderWs - Trailing stop via WebSocket createTrailingPercentOrderWs - Trailing stop % via WebSocket createPostOnlyOrderWs - Post-only order via WebSocket createReduceOnlyOrderWs - Reduce-only order via WebSocket Managing Orders: editOrderWs - Edit order via WebSocket cancelOrderWs - Cancel order via WebSocket (faster than REST) cancelOrdersWs - Cancel multiple orders via WebSocket cancelAllOrdersWs - Cancel all orders via WebSocket Fetching Data: fetchOrderWs - Fetch order via WebSocket fetchOrdersWs - Fetch orders via WebSocket fetchOpenOrdersWs - Fetch open orders via WebSocket fetchClosedOrdersWs - Fetch closed orders via WebSocket fetchMyTradesWs - Fetch your trades via WebSocket fetchBalanceWs - Fetch balance via WebSocket fetchPositionWs - Fetch position via WebSocket fetchPositionsWs - Fetch positions via WebSocket fetchPositionsForSymbolWs - Fetch positions for symbol via WebSocket fetchTradingFeesWs - Fetch trading fees via WebSocket When to Use WebSocket Methods Use Ws methods when: You need faster order placement (lower latency) You're already connected via WebSocket You want to reduce REST API rate limit usage Trading strategies require sub-100ms latency Use REST methods when: You need guaranteed execution confirmation You're making one-off requests The exchange doesn't support the WebSocket variant You need detailed error responses Example: Order Placement Comparison REST API (slower, more reliable): const order = await exchange.createOrder('BTC/USDT', 'limit', 'buy', 0.01, 50000) WebSocket API (faster, lower latency): const order = await exchange.createOrderWs('BTC/USDT', 'limit', 'buy', 0.01, 50000) Checking WebSocket Method Availability Not all exchanges support WebSocket trading methods: if (exchange.has['createOrderWs']) { // Exchange supports WebSocket order creation const order = await exchange.createOrderWs('BTC/USDT', 'limit', 'buy', 0.01, 50000) } else { // Fall back to REST const order = await exchange.createOrder('BTC/USDT', 'limit', 'buy', 0.01, 50000) } Authentication Setting API Keys import os

During instantiation (recommended)

exchange

ccxt . binance ( { 'apiKey' : os . environ . get ( 'BINANCE_API_KEY' ) , 'secret' : os . environ . get ( 'BINANCE_SECRET' ) , 'enableRateLimit' : True } )

After instantiation

exchange . apiKey = os . environ . get ( 'BINANCE_API_KEY' ) exchange . secret = os . environ . get ( 'BINANCE_SECRET' ) Testing Authentication try : balance = exchange . fetch_balance ( ) print ( 'Authentication successful!' ) except ccxt . AuthenticationError : print ( 'Invalid API credentials' ) Error Handling Exception Hierarchy BaseError ├─ NetworkError (recoverable - retry) │ ├─ RequestTimeout │ ├─ ExchangeNotAvailable │ ├─ RateLimitExceeded │ └─ DDoSProtection └─ ExchangeError (non-recoverable - don't retry) ├─ AuthenticationError ├─ InsufficientFunds ├─ InvalidOrder └─ NotSupported Basic Error Handling import ccxt try : ticker = exchange . fetch_ticker ( 'BTC/USDT' ) except ccxt . NetworkError as e : print ( 'Network error - retry:' , str ( e ) ) except ccxt . ExchangeError as e : print ( 'Exchange error - do not retry:' , str ( e ) ) except Exception as e : print ( 'Unknown error:' , str ( e ) ) Specific Exception Handling try : order = exchange . create_order ( 'BTC/USDT' , 'limit' , 'buy' , 0.01 , 50000 ) except ccxt . InsufficientFunds : print ( 'Not enough balance' ) except ccxt . InvalidOrder : print ( 'Invalid order parameters' ) except ccxt . RateLimitExceeded : print ( 'Rate limit hit - wait before retrying' ) exchange . sleep ( 1000 )

Wait 1 second

except ccxt . AuthenticationError : print ( 'Check your API credentials' ) Retry Logic for Network Errors def fetch_with_retry ( max_retries = 3 ) : for i in range ( max_retries ) : try : return exchange . fetch_ticker ( 'BTC/USDT' ) except ccxt . NetworkError : if i < max_retries - 1 : print ( f'Retry { i + 1 } / { max_retries } ' ) exchange . sleep ( 1000 * ( i + 1 ) )

Exponential backoff

else : raise Async vs Sync When to Use Sync Simple scripts Single exchange operations Jupyter notebooks Quick testing When to Use Async Multiple concurrent operations WebSocket connections (required) High-performance trading bots Multiple exchange monitoring Sync Example import ccxt exchange = ccxt . binance ( { 'enableRateLimit' : True } ) ticker = exchange . fetch_ticker ( 'BTC/USDT' ) print ( ticker [ 'last' ] ) Async Example import asyncio import ccxt . async_support as ccxt async def main ( ) : exchange = ccxt . binance ( { 'enableRateLimit' : True } ) ticker = await exchange . fetch_ticker ( 'BTC/USDT' ) print ( ticker [ 'last' ] ) await exchange . close ( ) asyncio . run ( main ( ) ) Multiple Exchanges Async async def fetch_all ( ) : exchanges = [ ccxt . binance ( { 'enableRateLimit' : True } ) , ccxt . coinbase ( { 'enableRateLimit' : True } ) , ccxt . kraken ( { 'enableRateLimit' : True } ) ]

Fetch concurrently

tasks

[

ex

.

fetch_ticker

(

'BTC/USDT'

)

for

ex

in

exchanges

]

tickers

=

await

asyncio

.

gather

(

*

tasks

,

return_exceptions

=

True

)

for

ex

,

ticker

in

zip

(

exchanges

,

tickers

)

:

if

isinstance

(

ticker

,

Exception

)

:

print

(

f'

{

ex

.

id

}

ERROR -

{

ticker

}

'

)

else

:

print

(

f'

{

ex

.

id

}

$ { ticker [ "last" ] } ' ) await ex . close ( ) asyncio . run ( fetch_all ( ) ) Rate Limiting Built-in Rate Limiter (Recommended) exchange = ccxt . binance ( { 'enableRateLimit' : True

Automatically throttles requests

} ) Manual Delays exchange . fetch_ticker ( 'BTC/USDT' ) exchange . sleep ( 1000 )

Wait 1 second (milliseconds)

exchange . fetch_ticker ( 'ETH/USDT' ) Checking Rate Limit print ( exchange . rateLimit )

Milliseconds between requests

Common Pitfalls Forgetting await in Async Mode

Wrong - returns coroutine, not data

async def wrong ( ) : ticker = exchange . fetch_ticker ( 'BTC/USDT' )

Missing await!

print ( ticker [ 'last' ] )

ERROR

Correct

async def correct ( ) : ticker = await exchange . fetch_ticker ( 'BTC/USDT' ) print ( ticker [ 'last' ] )

Works!

Using Sync for WebSocket

Wrong - WebSocket requires async

import ccxt . pro as ccxtpro exchange = ccxtpro . binance ( ) ticker = exchange . watch_ticker ( 'BTC/USDT' )

ERROR: Need await!

Correct

import asyncio import ccxt . pro as ccxtpro async def main ( ) : exchange = ccxtpro . binance ( ) ticker = await exchange . watch_ticker ( 'BTC/USDT' ) await exchange . close ( ) asyncio . run ( main ( ) ) Not Closing Async Exchange

Wrong - resource leak

async def wrong ( ) : exchange = ccxt . binance ( ) await exchange . fetch_ticker ( 'BTC/USDT' )

Forgot to close!

Correct

async def correct ( ) : exchange = ccxt . binance ( ) try : await exchange . fetch_ticker ( 'BTC/USDT' ) finally : await exchange . close ( ) Using Sync in Async Code

Wrong - blocks event loop

async def wrong ( ) : exchange = ccxt . binance ( )

Sync import!

ticker

exchange . fetch_ticker ( 'BTC/USDT' )

Blocking!

Correct

import ccxt . async_support as ccxt async def correct ( ) : exchange = ccxt . binance ( ) ticker = await exchange . fetch_ticker ( 'BTC/USDT' ) await exchange . close ( ) Using REST for Real-time Monitoring

Wrong - wastes rate limits

while True : ticker = exchange . fetch_ticker ( 'BTC/USDT' )

REST

print ( ticker [ 'last' ] ) exchange . sleep ( 1000 )

Correct - use WebSocket

import ccxt . pro as ccxtpro async def correct ( ) : exchange = ccxtpro . binance ( ) while True : ticker = await exchange . watch_ticker ( 'BTC/USDT' )

WebSocket

print ( ticker [ 'last' ] ) await exchange . close ( ) Troubleshooting Common Issues 1. "ModuleNotFoundError: No module named 'ccxt'" Solution: Run pip install ccxt 2. "RateLimitExceeded" Solution: Enable rate limiter: 'enableRateLimit': True Or add manual delays between requests 3. "AuthenticationError" Solution: Check API key and secret Verify API key permissions on exchange Check system clock is synced (use NTP) 4. "InvalidNonce" Solution: Sync system clock Use only one exchange instance per API key 5. "InsufficientFunds" Solution: Check available balance ( balance['BTC']['free'] ) Account for trading fees 6. "ExchangeNotAvailable" Solution: Check exchange status/maintenance Retry after a delay 7. SSL/Certificate errors Solution: Update certifi: pip install --upgrade certifi 8. Slow performance Solution: Install performance enhancements: pip install orjson (faster JSON) pip install coincurve (faster signing) Debugging

Enable verbose logging

exchange . verbose = True

Check exchange capabilities

print ( exchange . has )

{

'fetchTicker': True,

'fetchOrderBook': True,

'createOrder': True,

...

}

Check market information

print ( exchange . markets [ 'BTC/USDT' ] )

Check last request/response

print ( exchange . last_http_response ) print ( exchange . last_json_response ) Learn More CCXT Manual CCXT Pro Documentation Supported Exchanges GitHub Repository