ccxt-python▌
ccxt/ccxt · updated Apr 8, 2026
A comprehensive guide to using CCXT in Python projects for cryptocurrency exchange integration.
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 symbolfetchTickers([symbols])- Fetch multiple tickers at oncefetchBidsAsks([symbols])- Fetch best bid/ask for multiple symbolsfetchLastPrices([symbols])- Fetch last pricesfetchMarkPrices([symbols])- Fetch mark prices (derivatives)
Order Books
fetchOrderBook(symbol, limit)- Fetch order bookfetchOrderBooks([symbols])- Fetch multiple order booksfetchL2OrderBook(symbol)- Fetch level 2 order bookfetchL3OrderBook(symbol)- Fetch level 3 order book (if supported)
Trades
fetchTrades(symbol, since, limit)- Fetch public tradesfetchMyTrades(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 datafetchIndexOHLCV(symbol, timeframe)- Fetch index price OHLCVfetchMarkOHLCV(symbol, timeframe)- Fetch mark price OHLCVfetchPremiumIndexOHLCV(symbol, timeframe)- Fetch premium index OHLCV
Account & Balance
fetchBalance()- Fetch account balance (auth required)fetchAccounts()- Fetch sub-accountsfetchLedger(code, since, limit)- Fetch ledger historyfetchLedgerEntry(id, code)- Fetch specific ledger entryfetchTransactions(code, since, limit)- Fetch transactionsfetchDeposits(code, since, limit)- Fetch deposit historyfetchWithdrawals(code, since, limit)- Fetch withdrawal historyfetchDepositsWithdrawals(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 ordercreateMarketOrder(symbol, side, amount)- Create market ordercreateLimitBuyOrder(symbol, amount, price)- Buy limit ordercreateLimitSellOrder(symbol, amount, price)- Sell limit ordercreateMarketBuyOrder(symbol, amount)- Buy market ordercreateMarketSellOrder(symbol, amount)- Sell market ordercreateMarketBuyOrderWithCost(symbol, cost)- Buy with specific costcreateStopLimitOrder(symbol, side, amount, price, stopPrice)- Stop-limit ordercreateStopMarketOrder(symbol, side, amount, stopPrice)- Stop-market ordercreateStopLossOrder(symbol, side, amount, stopPrice)- Stop-loss ordercreateTakeProfitOrder(symbol, side, amount, takeProfitPrice)- Take-profit ordercreateTrailingAmountOrder(symbol, side, amount, trailingAmount)- Trailing stopcreateTrailingPercentOrder(symbol, side, amount, trailingPercent)- Trailing stop %createTriggerOrder(symbol, side, amount, triggerPrice)- Trigger ordercreatePostOnlyOrder(symbol, side, amount, price)- Post-only ordercreateReduceOnlyOrder(symbol, side, amount, price)- Reduce-only ordercreateOrders([orders])- Create multiple orders at oncecreateOrderWithTakeProfitAndStopLoss(symbol, type, side, amount, price, tpPrice, slPrice)- OCO order
Managing Orders
fetchOrder(orderId, symbol)- Fetch single orderfetchOrders(symbol, since, limit)- Fetch all ordersfetchOpenOrders(symbol, since, limit)- Fetch open ordersfetchClosedOrders(symbol, since, limit)- Fetch closed ordersfetchCanceledOrders(symbol, since, limit)- Fetch canceled ordersfetchOpenOrder(orderId, symbol)- Fetch specific open orderfetchOrdersByStatus(status, symbol)- Fetch orders by statuscancelOrder(orderId, symbol)- Cancel single ordercancelOrders([orderIds], symbol)- Cancel multiple orderscancelAllOrders(symbol)- Cancel all orders for symboleditOrder(orderId, symbol, type, side, amount, price)- Modify order
Margin & Leverage
fetchBorrowRate(code)- Fetch borrow rate for marginfetchBorrowRates([codes])- Fetch multiple borrow ratesfetchBorrowRateHistory(code, since, limit)- Historical borrow ratesfetchCrossBorrowRate(code)- Cross margin borrow ratefetchIsolatedBorrowRate(symbol, code)- Isolated margin borrow rateborrowMargin(code, amount, symbol)- Borrow marginrepayMargin(code, amount, symbol)- Repay marginfetchLeverage(symbol)- Fetch leveragesetLeverage(leverage, symbol)- Set leveragefetchLeverageTiers(symbols)- Fetch leverage tiersfetchMarketLeverageTiers(symbol)- Leverage tiers for marketsetMarginMode(marginMode, symbol)- Set margin mode (cross/isolated)fetchMarginMode(symbol)- Fetch margin mode
Derivatives & Futures
Positions
fetchPosition(symbol)- Fetch single positionfetchPositions([symbols])- Fetch all positionsfetchPositionsForSymbol(symbol)- Fetch positions for symbolfetchPositionHistory(symbol, since, limit)- Position historyfetchPositionsHistory(symbols, since, limit)- Multiple position historyfetchPositionMode(symbol)- Fetch position mode (one-way/hedge)setPositionMode(hedged, symbol)- Set position modeclosePosition(symbol, side)- Close positioncloseAllPositions()- Close all positions
Funding & Settlement
fetchFundingRate(symbol)- Current funding ratefetchFundingRates([symbols])- Multiple funding ratesfetchFundingRateHistory(symbol, since, limit)- Funding rate historyfetchFundingHistory(symbol, since, limit)- Your funding paymentsfetchFundingInterval(symbol)- Funding intervalfetchSettlementHistory(symbol, since, limit)- Settlement historyfetchMySettlementHistory(symbol, since, limit)- Your settlement history
Open Interest & Liquidations
fetchOpenInterest(symbol)- Open interest for symbolfetchOpenInterests([symbols])- Multiple open interestsfetchOpenInterestHistory(symbol, timeframe, since, limit)- OI historyfetchLiquidations(symbol, since, limit)- Public liquidationsfetchMyLiquidations(symbol, since, limit)- Your liquidations
Options
fetchOption(symbol)- Fetch option infofetchOptionChain(code)- Fetch option chainfetchGreeks(symbol)- Fetch option greeksfetchVolatilityHistory(code, since, limit)- Volatility historyfetchUnderlyingAssets()- Fetch underlying assets
Fees & Limits
fetchTradingFee(symbol)- Trading fee for symbolfetchTradingFees([symbols])- Trading fees for multiple symbolsfetchTradingLimits([symbols])- Trading limitsfetchTransactionFee(code)- Transaction/withdrawal feefetchTransactionFees([codes])- Multiple transaction feesfetchDepositWithdrawFee(code)- Deposit/withdrawal feefetchDepositWithdrawFees([codes])- Multiple deposit/withdraw fees
Deposits & Withdrawals
fetchDepositAddress(code, params)- Get deposit addressfetchDepositAddresses([codes])- Multiple deposit addressesfetchDepositAddressesByNetwork(code)- Addresses by networkcreateDepositAddress(code, params)- Create new deposit addressfetchDeposit(id, code)- Fetch single depositfetchWithdrawal(id, code)- Fetch single withdrawalfetchWithdrawAddresses(code)- Fetch withdrawal addressesfetchWithdrawalWhitelist(code)- Fetch whitelistwithdraw(code, amount, address, tag, params)- Withdraw fundsdeposit(code, amount, params)- Deposit funds (if supported)
Transfer & Convert
transfer(code, amount, fromAccount, toAccount)- Internal transferfetchTransfer(id, code)- Fetch transfer infofetchTransfers(code, since, limit)- Fetch transfer historyfetchConvertCurrencies()- Currencies available for convertfetchConvertQuote(fromCode, toCode, amount)- Get conversion quotecreateConvertTrade(fromCode, toCode, amount)- Execute conversionfetchConvertTrade(id)- Fetch convert tradefetchConvertTradeHistory(code, since, limit)- Convert history
Market Info
fetchMarkets()- Fetch all marketsfetchCurrencies()- Fetch all currenciesfetchTime()- Fetch exchange server timefetchStatus()- Fetch exchange statusfetchBorrowInterest(code, symbol, since, limit)- Borrow interest paidfetchLongShortRatio(symbol, timeframe, since, limit)- Long/short ratiofetchLongShortRatioHistory(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 tickerwatchTickers([symbols])- Watch multiple tickerswatchOrderBook(symbol)- Watch order book updateswatchOrderBookForSymbols([symbols])- Watch multiple order bookswatchTrades(symbol)- Watch public tradeswatchOHLCV(symbol, timeframe)- Watch candlestick updateswatchBidsAsks([symbols])- Watch best bid/ask
Real-time Account Data (Auth Required)
watchBalance()- Watch balance updateswatchOrders(symbol)- Watch your order updateswatchMyTrades(symbol)- Watch your trade updateswatchPositions([symbols])- Watch position updateswatchPositionsForSymbol(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,fetchAccountswithdraw,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 resourcesedit*- Modify existing resourcesset*- Configure settings (leverage, margin mode)*Wssuffix - 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 WebSocketcreateMarketOrderWs- Create market order via WebSocketcreateLimitBuyOrderWs- Buy limit order via WebSocketcreateLimitSellOrderWs- Sell limit order via WebSocketcreateMarketBuyOrderWs- Buy market order via WebSocketcreateMarketSellOrderWs- Sell market order via WebSocketcreateStopLimitOrderWs- Stop-limit order via WebSocketcreateStopMarketOrderWs- Stop-market order via WebSocketcreateStopLossOrderWs- Stop-loss order via WebSocketcreateTakeProfitOrderWs- Take-profit order via WebSocketcreateTrailingAmountOrderWs- Trailing stop via WebSocketcreateTrailingPercentOrderWs- Trailing stop % via WebSocketcreatePostOnlyOrderWs- Post-only order via WebSocketcreateReduceOnlyOrderWs- Reduce-only order via WebSocket
Managing Orders:
editOrderWs- Edit order via WebSocketcancelOrderWs- Cancel order via WebSocket (faster than REST)cancelOrdersWs- Cancel multiple orders via WebSocketcancelAllOrdersWs- Cancel all orders via WebSocket
Fetching Data:
fetchOrderWs- Fetch order via WebSocketfetchOrdersWs- Fetch orders via WebSocketfetchOpenOrdersWs- Fetch open orders via WebSocketfetchClosedOrdersWs- Fetch closed orders via WebSocketfetchMyTradesWs- Fetch your trades via WebSocketfetchBalanceWs- Fetch balance via WebSocketfetchPositionWs- Fetch position via WebSocketfetchPositionsWs- Fetch positions via WebSocketfetchPositionsForSymbolWs- Fetch positions for symbol via WebSocketfetchTradingFeesWs- 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
Ratings
4.5★★★★★10 reviews- ★★★★★Shikha Mishra· Oct 10, 2024
ccxt-python is among the better-maintained entries we tried; worth keeping pinned for repeat workflows.
- ★★★★★Piyush G· Sep 9, 2024
Keeps context tight: ccxt-python is the kind of skill you can hand to a new teammate without a long onboarding doc.
- ★★★★★Chaitanya Patil· Aug 8, 2024
Registry listing for ccxt-python matched our evaluation — installs cleanly and behaves as described in the markdown.
- ★★★★★Sakshi Patil· Jul 7, 2024
ccxt-python reduced setup friction for our internal harness; good balance of opinion and flexibility.
- ★★★★★Ganesh Mohane· Jun 6, 2024
I recommend ccxt-python for anyone iterating fast on agent tooling; clear intent and a small, reviewable surface area.
- ★★★★★Oshnikdeep· May 5, 2024
Useful defaults in ccxt-python — fewer surprises than typical one-off scripts, and it plays nicely with `npx skills` flows.
- ★★★★★Dhruvi Jain· Apr 4, 2024
ccxt-python has been reliable in day-to-day use. Documentation quality is above average for community skills.
- ★★★★★Rahul Santra· Mar 3, 2024
Solid pick for teams standardizing on skills: ccxt-python is focused, and the summary matches what you get after install.
- ★★★★★Pratham Ware· Feb 2, 2024
We added ccxt-python from the explainx registry; install was straightforward and the SKILL.md answered most questions upfront.
- ★★★★★Yash Thakker· Jan 1, 2024
ccxt-python fits our agent workflows well — practical, well scoped, and easy to wire into existing repos.