ccxt-python

SKILL.md

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