CCXT for Python

A comprehensive guide to using CCXT in Python projects for cryptocurrency exchange integration.

Installation

REST API (Standard)

bash

pip install ccxt

WebSocket API (Real-time, ccxt.pro)

bash

pip install ccxt

Optional Performance Enhancements

bash

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

python

import ccxt

exchange = ccxt.binance()
exchange.load_markets()
ticker = exchange.fetch_ticker('BTC/USDT')
print(ticker)

REST API - Asynchronous

python

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

python

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

python

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

python

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

python

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

python

# 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

python

# 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

python

# 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

python

# 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

python

# 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

python

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

python

# 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

python

# 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

python

# 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)

python

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)

python

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)

python

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)

python

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)

python

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

python

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

python

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

python

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

python

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

python

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

python

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

python

import ccxt

exchange = ccxt.binance({'enableRateLimit': True})
ticker = exchange.fetch_ticker('BTC/USDT')
print(ticker['last'])

Async Example

python

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

python

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)

python

exchange = ccxt.binance({
    'enableRateLimit': True  # Automatically throttles requests
})

Manual Delays

python

exchange.fetch_ticker('BTC/USDT')
exchange.sleep(1000)  # Wait 1 second (milliseconds)
exchange.fetch_ticker('ETH/USDT')

Checking Rate Limit

python

print(exchange.rateLimit)  # Milliseconds between requests

Common Pitfalls

Forgetting

await

in Async Mode

python

# 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

python

# 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

python

# 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

python

# 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

python

# 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

python

# 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)

ccxt-python

NPX Install

Tags

SKILL.md Content

CCXT for Python

Installation

REST API (Standard)

WebSocket API (Real-time, ccxt.pro)

Optional Performance Enhancements

Quick Start

REST API - Synchronous

REST API - Asynchronous

WebSocket API - Real-time Updates

REST vs WebSocket

Creating Exchange Instance

REST API - Synchronous

REST API - Asynchronous

WebSocket API

Common REST Operations

Loading Markets

Fetching Ticker

Fetching Order Book

Creating Orders

Limit Order

Market Order

Fetching Balance

Fetching Orders

Fetching Trades

Canceling Orders

WebSocket Operations (Real-time)

Watching Ticker (Live Price Updates)

Watching Order Book (Live Depth Updates)

Watching Trades (Live Trade Stream)

Watching Your Orders (Live Order Updates)

Watching Balance (Live Balance Updates)

Watching Multiple Symbols

Complete Method Reference

Market Data Methods

Tickers & Prices

Order Books

Trades

OHLCV (Candlesticks)

Account & Balance

Trading Methods

Creating Orders

Managing Orders

Margin & Leverage

Derivatives & Futures

Positions

Funding & Settlement

Open Interest & Liquidations

Options

Fees & Limits

Deposits & Withdrawals

Transfer & Convert

Market Info

WebSocket Methods (ccxt.pro)

Real-time Market Data

Real-time Account Data (Auth Required)

Authentication Required

Checking Method Availability

Method Naming Convention

Proxy Configuration

Setting Proxy

Proxy for WebSocket

Testing Proxy Connection

WebSocket-Specific Methods

Trading via WebSocket

When to Use WebSocket Methods

Example: Order Placement Comparison

Checking WebSocket Method Availability

Authentication

Setting API Keys

Testing Authentication

Error Handling

Exception Hierarchy

Basic Error Handling

Specific Exception Handling

Retry Logic for Network Errors

Async vs Sync

Forgetting
`await`
in Async Mode