Ccxt Python

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_* (fetchticker, fetchorderbook) | watch_* (watchticker, watchorderbook) | | 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

…

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: CarlosCaPe
• Source: CarlosCaPe/octorato
• License: MIT
• Homepage: https://www.dataqbs.com/octorato

Install and usage instructions live in the source repository linked above.