CCXT for TypeScript/JavaScript

A comprehensive guide to using CCXT in TypeScript and JavaScript projects for cryptocurrency exchange integration.

Installation

REST API (Standard CCXT)

npm install ccxt

WebSocket API (Real-time, ccxt.pro)

npm install ccxt

Both REST and WebSocket APIs are included in the same package.

Quick Start

REST API – TypeScript

import ccxt from 'ccxt'

const exchange = new ccxt.binance()
await exchange.loadMarkets()
const ticker = await exchange.fetchTicker('BTC/USDT')
console.log(ticker)

REST API – JavaScript (CommonJS)

const ccxt = require('ccxt')

(async () => {
    const exchange = new ccxt.binance()
    await exchange.loadMarkets()
    const ticker = await exchange.fetchTicker('BTC/USDT')
    console.log(ticker)
})()

WebSocket API – Real-time Updates

import ccxt from 'ccxt'

const exchange = new ccxt.pro.binance()
while (true) {
    const ticker = await exchange.watchTicker('BTC/USDT')
    console.log(ticker)  // Live updates!
}
await exchange.close()

REST vs WebSocket

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

// Public API (no authentication)
const exchange = new ccxt.binance({
    enableRateLimit: true  // Recommended!
})

// Private API (with authentication)
const exchange = new ccxt.binance({
    apiKey: 'YOUR_API_KEY',
    secret: 'YOUR_SECRET',
    enableRateLimit: true
})

WebSocket API

// Public WebSocket
const exchange = new ccxt.pro.binance()

// Private WebSocket (with authentication)
const exchange = new ccxt.pro.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
await exchange.loadMarkets()

// Access market information
const btcMarket = exchange.market('BTC/USDT')
console.log(btcMarket.limits.amount.min)  // Minimum order amount

Fetching Ticker

// Single ticker
const ticker = await exchange.fetchTicker('BTC/USDT')
console.log(ticker.last)      // Last price
console.log(ticker.bid)       // Best bid
console.log(ticker.ask)       // Best ask
console.log(ticker.volume)    // 24h volume

// Multiple tickers (if supported)
const tickers = await exchange.fetchTickers(['BTC/USDT', 'ETH/USDT'])

Fetching Order Book

// Full orderbook
const orderbook = await exchange.fetchOrderBook('BTC/USDT')
console.log(orderbook.bids[0])  // [price, amount]
console.log(orderbook.asks[0])  // [price, amount]

// Limited depth
const orderbook = await exchange.fetchOrderBook('BTC/USDT', 5)  // Top 5 levels

Creating Orders

Limit Order

// Buy limit order
const order = await exchange.createLimitBuyOrder('BTC/USDT', 0.01, 50000)
console.log(order.id)

// Sell limit order
const order = await exchange.createLimitSellOrder('BTC/USDT', 0.01, 60000)

// Generic limit order
const order = await exchange.createOrder('BTC/USDT', 'limit', 'buy', 0.01, 50000)

Market Order

// Buy market order
const order = await exchange.createMarketBuyOrder('BTC/USDT', 0.01)

// Sell market order
const order = await exchange.createMarketSellOrder('BTC/USDT', 0.01)

// Generic market order
const order = await exchange.createOrder('BTC/USDT', 'market', 'sell', 0.01)

Fetching Balance

const balance = await exchange.fetchBalance()
console.log(balance.BTC.free)   // Available balance
console.log(balance.BTC.used)   // Balance in orders
console.log(balance.BTC.total)  // Total balance

Fetching Orders

// Open orders
const openOrders = await exchange.fetchOpenOrders('BTC/USDT')

// Closed orders
const closedOrders = await exchange.fetchClosedOrders('BTC/USDT')

// All orders (open + closed)
const allOrders = await exchange.fetchOrders('BTC/USDT')

// Single order by ID
const order = await exchange.fetchOrder(orderId, 'BTC/USDT')

Fetching Trades

// Recent public trades
const trades = await exchange.fetchTrades('BTC/USDT', undefined, 10)

// Your trades (requires authentication)
const myTrades = await exchange.fetchMyTrades('BTC/USDT')

Canceling Orders

// Cancel single order
await exchange.cancelOrder(orderId, 'BTC/USDT')

// Cancel all orders for a symbol
await exchange.cancelAllOrders('BTC/USDT')

WebSocket Operations (Real-time)

Watching Ticker (Live Price Updates)

const exchange = new ccxt.pro.binance()

while (true) {
    const ticker = await exchange.watchTicker('BTC/USDT')
    console.log(ticker.last, ticker.timestamp)
}

await exchange.close()

Watching Order Book (Live Depth Updates)

const exchange = new ccxt.pro.binance()

while (true) {
    const orderbook = await exchange.watchOrderBook('BTC/USDT')
    console.log('Best bid:', orderbook.bids[0])
    console.log('Best ask:', orderbook.asks[0])
}

await exchange.close()

Watching Trades (Live Trade Stream)

const exchange = new ccxt.pro.binance()

while (true) {
    const trades = await exchange.watchTrades('BTC/USDT')
    for (const trade of trades) {
        console.log(trade.price, trade.amount, trade.side)
    }
}

await exchange.close()

Watching Your Orders (Live Order Updates)

const exchange = new ccxt.pro.binance({
    apiKey: 'YOUR_API_KEY',
    secret: 'YOUR_SECRET'
})

while (true) {
    const orders = await exchange.watchOrders('BTC/USDT')
    for (const order of orders) {
        console.log(order.id, order.status, order.filled)
    }
}

await exchange.close()

Watching Balance (Live Balance Updates)

const exchange = new ccxt.pro.binance({
    apiKey: 'YOUR_API_KEY',
    secret: 'YOUR_SECRET'
})

while (true) {
    const balance = await exchange.watchBalance()
    console.log('BTC:', balance.BTC)
    console.log('USDT:', balance.USDT)
}

await exchange.close()

Watching Multiple Symbols

const exchange = new ccxt.pro.binance()
const symbols = ['BTC/USDT', 'ETH/USDT', 'SOL/USDT']

while (true) {
    // Watch all symbols concurrently
    const tickers = await exchange.watchTickers(symbols)
    for (const symbol in tickers) {
        console.log(symbol, tickers[symbol].last)
    }
}

await exchange.close()

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

// During instantiation
const exchange = new ccxt.binance({
    apiKey: 'YOUR_API_KEY',
    secret: 'YOUR_SECRET',
    enableRateLimit: true
})

// After instantiation
exchange.apiKey = 'YOUR_API_KEY'
exchange.secret = 'YOUR_SECRET'

Environment Variables (Recommended)

const exchange = new ccxt.binance({
    apiKey: process.env.BINANCE_API_KEY,
    secret: process.env.BINANCE_SECRET,
    enableRateLimit: true
})

Testing Authentication

try {
    const balance = await exchange.fetchBalance()
    console.log('Authentication successful!')
} catch (error) {
    if (error instanceof ccxt.AuthenticationError) {
        console.error('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 from 'ccxt'

try {
    const ticker = await exchange.fetchTicker('BTC/USDT')
} catch (error) {
    if (error instanceof ccxt.NetworkError) {
        console.error('Network error - retry:', error.message)
    } else if (error instanceof ccxt.ExchangeError) {
        console.error('Exchange error - do not retry:', error.message)
    } else {
        console.error('Unknown error:', error)
    }
}

Specific Exception Handling

try {
    const order = await exchange.createOrder('BTC/USDT', 'limit', 'buy', 0.01, 50000)
} catch (error) {
    if (error instanceof ccxt.InsufficientFunds) {
        console.error('Not enough balance')
    } else if (error instanceof ccxt.InvalidOrder) {
        console.error('Invalid order parameters')
    } else if (error instanceof ccxt.RateLimitExceeded) {
        console.error('Rate limit hit - wait before retrying')
        await exchange.sleep(1000)  // Wait 1 second
    } else if (error instanceof ccxt.AuthenticationError) {
        console.error('Check your API credentials')
    }
}

Retry Logic for Network Errors

async function fetchWithRetry(maxRetries = 3) {
    for (let i = 0; i < maxRetries; i++) {
        try {
            return await exchange.fetchTicker('BTC/USDT')
        } catch (error) {
            if (error instanceof ccxt.NetworkError && i < maxRetries - 1) {
                console.log(`Retry ${i + 1}/${maxRetries}`)
                await exchange.sleep(1000 * (i + 1))  // Exponential backoff
            } else {
                throw error
            }
        }
    }
}

Rate Limiting

Built-in Rate Limiter (Recommended)

const exchange = new ccxt.binance({
    enableRateLimit: true  // Automatically throttles requests
})

Manual Delays

await exchange.fetchTicker('BTC/USDT')
await exchange.sleep(1000)  // Wait 1 second
await exchange.fetchTicker('ETH/USDT')

Checking Rate Limit

console.log(exchange.rateLimit)  // Milliseconds between requests

Common Pitfalls

Forgetting await

// Wrong - returns Promise, not data
const ticker = exchange.fetchTicker('BTC/USDT')
console.log(ticker.last)  // ERROR: ticker is a Promise!

// Correct
const ticker = await exchange.fetchTicker('BTC/USDT')
console.log(ticker.last)  // Works!

Using REST for Real-time Monitoring

// Wrong - wastes rate limits, slow
while (true) {
    const ticker = await exchange.fetchTicker('BTC/USDT')  // REST
    console.log(ticker.last)
    await exchange.sleep(1000)
}

// Correct - use WebSocket
const exchange = new ccxt.pro.binance()
while (true) {
    const ticker = await exchange.watchTicker('BTC/USDT')  // WebSocket
    console.log(ticker.last)
}

Not Closing WebSocket Connections

// Wrong - memory leak
const exchange = new ccxt.pro.binance()
const ticker = await exchange.watchTicker('BTC/USDT')
// Forgot to close!

// Correct
const exchange = new ccxt.pro.binance()
try {
    while (true) {
        const ticker = await exchange.watchTicker('BTC/USDT')
        console.log(ticker)
    }
} finally {
    await exchange.close()
}

Multiple Instances with Same API Keys

// Wrong - nonce conflicts
const ex1 = new ccxt.binance({ apiKey: 'key', secret: 'secret' })
const ex2 = new ccxt.binance({ apiKey: 'key', secret: 'secret' })
await ex1.fetchBalance()
await ex2.fetchBalance()  // May fail due to nonce issues!

// Correct - reuse single instance
const exchange = new ccxt.binance({ apiKey: 'key', secret: 'secret' })
await exchange.fetchBalance()
await exchange.fetchBalance()

Not Enabling Rate Limiter

// Wrong - may hit rate limits
const exchange = new ccxt.binance()
for (let i = 0; i < 100; i++) {
    await exchange.fetchTicker('BTC/USDT')  // May fail!
}

// Correct
const exchange = new ccxt.binance({ enableRateLimit: true })
for (let i = 0; i < 100; i++) {
    await exchange.fetchTicker('BTC/USDT')  // Automatically throttled
}

Browser Usage

Via CDN

<script src="https://cdn.jsdelivr.net/npm/ccxt@latest/dist/ccxt.browser.js"></script>
<script>
    const exchange = new ccxt.binance()
    exchange.loadMarkets().then(() => {
        return exchange.fetchTicker('BTC/USDT')
    }).then(ticker => {
        console.log(ticker)
    })
</script>

ES Modules

import ccxt from 'https://cdn.jsdelivr.net/npm/ccxt@latest/dist/ccxt.browser.js'

const exchange = new ccxt.binance()
await exchange.loadMarkets()
const ticker = await exchange.fetchTicker('BTC/USDT')
console.log(ticker)

Troubleshooting

Common Issues

1. “Cannot find module ‘ccxt'”

• Solution: Run npm 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
• Don’t run multiple bots with same credentials

5. “InsufficientFunds”

• Solution: Check available balance (balance.BTC.free)
• Account for trading fees

6. “ExchangeNotAvailable”

• Solution: Check exchange status/maintenance
• Retry after a delay
• Use different exchange endpoint if available

7. WebSocket connection drops

• Solution: Implement reconnection logic
• Use try-catch and restart watch* methods
• Check network stability

Debugging

// Enable verbose logging
exchange.verbose = true

// Check exchange capabilities
console.log(exchange.has)
// {
//   fetchTicker: true,
//   fetchOrderBook: true,
//   createOrder: true,
//   ...
// }

// Check market information
console.log(exchange.markets['BTC/USDT'])

// Check last request/response
console.log(exchange.last_http_response)
console.log(exchange.last_json_response)

Learn More

• CCXT Manual
• CCXT Pro Documentation
• Supported Exchanges
• GitHub Repository