ccxt-go

star 42.9k

CCXT cryptocurrency exchange library for Go developers. Covers both REST API (standard) and WebSocket API (real-time). Helps install CCXT, connect to exchanges, fetch market data, place orders, stream live tickers/orderbooks, handle authentication, and manage errors in Go projects. Use when working with crypto exchanges in Go applications, microservices, or trading systems.

ccxt By ccxt schedule Updated 2/2/2026
play_arrow Run Skill in Manus View GitHub

name: ccxt-go description: CCXT cryptocurrency exchange library for Go developers. Covers both REST API (standard) and WebSocket API (real-time). Helps install CCXT, connect to exchanges, fetch market data, place orders, stream live tickers/orderbooks, handle authentication, and manage errors in Go projects. Use when working with crypto exchanges in Go applications, microservices, or trading systems.

CCXT for Go

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

Installation

REST API

go get github.com/ccxt/ccxt/go/v4

WebSocket API (ccxt.pro)

go get github.com/ccxt/ccxt/go/v4/pro

Quick Start

REST API

package main

import (
    "fmt"
    "github.com/ccxt/ccxt/go/v4/binance"
)

func main() {
    exchange := binance.New()
    markets, err := exchange.LoadMarkets()
    if err != nil {
        panic(err)
    }

    ticker, err := exchange.FetchTicker("BTC/USDT")
    if err != nil {
        panic(err)
    }

    fmt.Println(ticker)
}

WebSocket API - Real-time Updates

package main

import (
    "fmt"
    "github.com/ccxt/ccxt/go/v4/pro/binance"
)

func main() {
    exchange := binance.New()
    defer exchange.Close()

    for {
        ticker, err := exchange.WatchTicker("BTC/USDT")
        if err != nil {
            panic(err)
        }
        fmt.Println(ticker.Last)  // Live updates!
    }
}

REST vs WebSocket

Feature REST API WebSocket API
Use for One-time queries, placing orders Real-time monitoring, live price feeds
Import github.com/ccxt/ccxt/go/v4/{exchange} github.com/ccxt/ccxt/go/v4/pro/{exchange}
Methods 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

Important: All methods return (result, error) - always check errors!

Creating Exchange Instance

REST API

import "github.com/ccxt/ccxt/go/v4/binance"

// Public API (no authentication)
exchange := binance.New()
exchange.EnableRateLimit = true  // Recommended!

// Private API (with authentication)
exchange := binance.New()
exchange.ApiKey = "YOUR_API_KEY"
exchange.Secret = "YOUR_SECRET"
exchange.EnableRateLimit = true

WebSocket API

import "github.com/ccxt/ccxt/go/v4/pro/binance"

// Public WebSocket
exchange := binance.New()
defer exchange.Close()

// Private WebSocket (with authentication)
exchange := binance.New()
exchange.ApiKey = "YOUR_API_KEY"
exchange.Secret = "YOUR_SECRET"
defer exchange.Close()

Common REST Operations

Loading Markets

// Load all available trading pairs
markets, err := exchange.LoadMarkets()
if err != nil {
    panic(err)
}

// Access market information
btcMarket := exchange.Market("BTC/USDT")
fmt.Println(btcMarket.Limits.Amount.Min)  // Minimum order amount

Fetching Ticker

// Single ticker
ticker, err := exchange.FetchTicker("BTC/USDT")
if err != nil {
    panic(err)
}
fmt.Println(ticker.Last)      // Last price
fmt.Println(ticker.Bid)       // Best bid
fmt.Println(ticker.Ask)       // Best ask
fmt.Println(ticker.Volume)    // 24h volume

// Multiple tickers (if supported)
tickers, err := exchange.FetchTickers([]string{"BTC/USDT", "ETH/USDT"})

Fetching Order Book

// Full orderbook
orderbook, err := exchange.FetchOrderBook("BTC/USDT", nil)
if err != nil {
    panic(err)
}
fmt.Println(orderbook.Bids[0])  // [price, amount]
fmt.Println(orderbook.Asks[0])  // [price, amount]

// Limited depth
limit := 5
orderbook, err := exchange.FetchOrderBook("BTC/USDT", &limit)

Creating Orders

Limit Order

// Buy limit order
order, err := exchange.CreateLimitBuyOrder("BTC/USDT", 0.01, 50000, nil)
if err != nil {
    panic(err)
}
fmt.Println(order.Id)

// Sell limit order
order, err := exchange.CreateLimitSellOrder("BTC/USDT", 0.01, 60000, nil)

// Generic limit order
order, err := exchange.CreateOrder("BTC/USDT", "limit", "buy", 0.01, 50000, nil)

Market Order

// Buy market order
order, err := exchange.CreateMarketBuyOrder("BTC/USDT", 0.01, nil)

// Sell market order
order, err := exchange.CreateMarketSellOrder("BTC/USDT", 0.01, nil)

// Generic market order
order, err := exchange.CreateOrder("BTC/USDT", "market", "sell", 0.01, nil, nil)

Fetching Balance

balance, err := exchange.FetchBalance()
if err != nil {
    panic(err)
}
fmt.Println(balance["BTC"].Free)   // Available balance
fmt.Println(balance["BTC"].Used)   // Balance in orders
fmt.Println(balance["BTC"].Total)  // Total balance

Fetching Orders

// Open orders
openOrders, err := exchange.FetchOpenOrders("BTC/USDT", nil, nil, nil)

// Closed orders
closedOrders, err := exchange.FetchClosedOrders("BTC/USDT", nil, nil, nil)

// All orders (open + closed)
allOrders, err := exchange.FetchOrders("BTC/USDT", nil, nil, nil)

// Single order by ID
order, err := exchange.FetchOrder(orderId, "BTC/USDT", nil)

Fetching Trades

// Recent public trades
limit := 10
trades, err := exchange.FetchTrades("BTC/USDT", nil, &limit, nil)

// Your trades (requires authentication)
myTrades, err := exchange.FetchMyTrades("BTC/USDT", nil, nil, nil)

Canceling Orders

// Cancel single order
err := exchange.CancelOrder(orderId, "BTC/USDT", nil)

// Cancel all orders for a symbol
err := exchange.CancelAllOrders("BTC/USDT", nil)

WebSocket Operations (Real-time)

Watching Ticker (Live Price Updates)

import "github.com/ccxt/ccxt/go/v4/pro/binance"

exchange := binance.New()
defer exchange.Close()

for {
    ticker, err := exchange.WatchTicker("BTC/USDT")
    if err != nil {
        panic(err)
    }
    fmt.Println(ticker.Last, ticker.Timestamp)
}

Watching Order Book (Live Depth Updates)

exchange := binance.New()
defer exchange.Close()

for {
    orderbook, err := exchange.WatchOrderBook("BTC/USDT", nil)
    if err != nil {
        panic(err)
    }
    fmt.Println("Best bid:", orderbook.Bids[0])
    fmt.Println("Best ask:", orderbook.Asks[0])
}

Watching Trades (Live Trade Stream)

exchange := binance.New()
defer exchange.Close()

for {
    trades, err := exchange.WatchTrades("BTC/USDT", nil, nil, nil)
    if err != nil {
        panic(err)
    }
    for _, trade := range trades {
        fmt.Println(trade.Price, trade.Amount, trade.Side)
    }
}

Watching Your Orders (Live Order Updates)

exchange := binance.New()
exchange.ApiKey = "YOUR_API_KEY"
exchange.Secret = "YOUR_SECRET"
defer exchange.Close()

for {
    orders, err := exchange.WatchOrders("BTC/USDT", nil, nil, nil)
    if err != nil {
        panic(err)
    }
    for _, order := range orders {
        fmt.Println(order.Id, order.Status, order.Filled)
    }
}

Watching Balance (Live Balance Updates)

exchange := binance.New()
exchange.ApiKey = "YOUR_API_KEY"
exchange.Secret = "YOUR_SECRET"
defer exchange.Close()

for {
    balance, err := exchange.WatchBalance()
    if err != nil {
        panic(err)
    }
    fmt.Println("BTC:", balance["BTC"])
    fmt.Println("USDT:", balance["USDT"])
}

Complete Method Reference

Market Data Methods

Tickers & Prices

  • fetchTicker(symbol) - Fetch ticker for one symbol
  • fetchTickers([symbols]) - Fetch multiple tickers at once
  • fetchBidsAsks([symbols]) - Fetch best bid/ask for multiple symbols
  • fetchLastPrices([symbols]) - Fetch last prices
  • fetchMarkPrices([symbols]) - Fetch mark prices (derivatives)

Order Books

  • fetchOrderBook(symbol, limit) - Fetch order book
  • fetchOrderBooks([symbols]) - Fetch multiple order books
  • fetchL2OrderBook(symbol) - Fetch level 2 order book
  • fetchL3OrderBook(symbol) - Fetch level 3 order book (if supported)

Trades

  • fetchTrades(symbol, since, limit) - Fetch public trades
  • fetchMyTrades(symbol, since, limit) - Fetch your trades (auth required)
  • fetchOrderTrades(orderId, symbol) - Fetch trades for specific order

OHLCV (Candlesticks)

  • fetchOHLCV(symbol, timeframe, since, limit) - Fetch candlestick data
  • fetchIndexOHLCV(symbol, timeframe) - Fetch index price OHLCV
  • fetchMarkOHLCV(symbol, timeframe) - Fetch mark price OHLCV
  • fetchPremiumIndexOHLCV(symbol, timeframe) - Fetch premium index OHLCV

Account & Balance

  • fetchBalance() - Fetch account balance (auth required)
  • fetchAccounts() - Fetch sub-accounts
  • fetchLedger(code, since, limit) - Fetch ledger history
  • fetchLedgerEntry(id, code) - Fetch specific ledger entry
  • fetchTransactions(code, since, limit) - Fetch transactions
  • fetchDeposits(code, since, limit) - Fetch deposit history
  • fetchWithdrawals(code, since, limit) - Fetch withdrawal history
  • fetchDepositsWithdrawals(code, since, limit) - Fetch both deposits and withdrawals

Trading Methods

Creating Orders

  • createOrder(symbol, type, side, amount, price, params) - Create order (generic)
  • createLimitOrder(symbol, side, amount, price) - Create limit order
  • createMarketOrder(symbol, side, amount) - Create market order
  • createLimitBuyOrder(symbol, amount, price) - Buy limit order
  • createLimitSellOrder(symbol, amount, price) - Sell limit order
  • createMarketBuyOrder(symbol, amount) - Buy market order
  • createMarketSellOrder(symbol, amount) - Sell market order
  • createMarketBuyOrderWithCost(symbol, cost) - Buy with specific cost
  • createStopLimitOrder(symbol, side, amount, price, stopPrice) - Stop-limit order
  • createStopMarketOrder(symbol, side, amount, stopPrice) - Stop-market order
  • createStopLossOrder(symbol, side, amount, stopPrice) - Stop-loss order
  • createTakeProfitOrder(symbol, side, amount, takeProfitPrice) - Take-profit order
  • createTrailingAmountOrder(symbol, side, amount, trailingAmount) - Trailing stop
  • createTrailingPercentOrder(symbol, side, amount, trailingPercent) - Trailing stop %
  • createTriggerOrder(symbol, side, amount, triggerPrice) - Trigger order
  • createPostOnlyOrder(symbol, side, amount, price) - Post-only order
  • createReduceOnlyOrder(symbol, side, amount, price) - Reduce-only order
  • createOrders([orders]) - Create multiple orders at once
  • createOrderWithTakeProfitAndStopLoss(symbol, type, side, amount, price, tpPrice, slPrice) - OCO order

Managing Orders

  • fetchOrder(orderId, symbol) - Fetch single order
  • fetchOrders(symbol, since, limit) - Fetch all orders
  • fetchOpenOrders(symbol, since, limit) - Fetch open orders
  • fetchClosedOrders(symbol, since, limit) - Fetch closed orders
  • fetchCanceledOrders(symbol, since, limit) - Fetch canceled orders
  • fetchOpenOrder(orderId, symbol) - Fetch specific open order
  • fetchOrdersByStatus(status, symbol) - Fetch orders by status
  • cancelOrder(orderId, symbol) - Cancel single order
  • cancelOrders([orderIds], symbol) - Cancel multiple orders
  • cancelAllOrders(symbol) - Cancel all orders for symbol
  • editOrder(orderId, symbol, type, side, amount, price) - Modify order

Margin & Leverage

  • fetchBorrowRate(code) - Fetch borrow rate for margin
  • fetchBorrowRates([codes]) - Fetch multiple borrow rates
  • fetchBorrowRateHistory(code, since, limit) - Historical borrow rates
  • fetchCrossBorrowRate(code) - Cross margin borrow rate
  • fetchIsolatedBorrowRate(symbol, code) - Isolated margin borrow rate
  • borrowMargin(code, amount, symbol) - Borrow margin
  • repayMargin(code, amount, symbol) - Repay margin
  • fetchLeverage(symbol) - Fetch leverage
  • setLeverage(leverage, symbol) - Set leverage
  • fetchLeverageTiers(symbols) - Fetch leverage tiers
  • fetchMarketLeverageTiers(symbol) - Leverage tiers for market
  • setMarginMode(marginMode, symbol) - Set margin mode (cross/isolated)
  • fetchMarginMode(symbol) - Fetch margin mode

Derivatives & Futures

Positions

  • fetchPosition(symbol) - Fetch single position
  • fetchPositions([symbols]) - Fetch all positions
  • fetchPositionsForSymbol(symbol) - Fetch positions for symbol
  • fetchPositionHistory(symbol, since, limit) - Position history
  • fetchPositionsHistory(symbols, since, limit) - Multiple position history
  • fetchPositionMode(symbol) - Fetch position mode (one-way/hedge)
  • setPositionMode(hedged, symbol) - Set position mode
  • closePosition(symbol, side) - Close position
  • closeAllPositions() - Close all positions

Funding & Settlement

  • fetchFundingRate(symbol) - Current funding rate
  • fetchFundingRates([symbols]) - Multiple funding rates
  • fetchFundingRateHistory(symbol, since, limit) - Funding rate history
  • fetchFundingHistory(symbol, since, limit) - Your funding payments
  • fetchFundingInterval(symbol) - Funding interval
  • fetchSettlementHistory(symbol, since, limit) - Settlement history
  • fetchMySettlementHistory(symbol, since, limit) - Your settlement history

Open Interest & Liquidations

  • fetchOpenInterest(symbol) - Open interest for symbol
  • fetchOpenInterests([symbols]) - Multiple open interests
  • fetchOpenInterestHistory(symbol, timeframe, since, limit) - OI history
  • fetchLiquidations(symbol, since, limit) - Public liquidations
  • fetchMyLiquidations(symbol, since, limit) - Your liquidations

Options

  • fetchOption(symbol) - Fetch option info
  • fetchOptionChain(code) - Fetch option chain
  • fetchGreeks(symbol) - Fetch option greeks
  • fetchVolatilityHistory(code, since, limit) - Volatility history
  • fetchUnderlyingAssets() - Fetch underlying assets

Fees & Limits

  • fetchTradingFee(symbol) - Trading fee for symbol
  • fetchTradingFees([symbols]) - Trading fees for multiple symbols
  • fetchTradingLimits([symbols]) - Trading limits
  • fetchTransactionFee(code) - Transaction/withdrawal fee
  • fetchTransactionFees([codes]) - Multiple transaction fees
  • fetchDepositWithdrawFee(code) - Deposit/withdrawal fee
  • fetchDepositWithdrawFees([codes]) - Multiple deposit/withdraw fees

Deposits & Withdrawals

  • fetchDepositAddress(code, params) - Get deposit address
  • fetchDepositAddresses([codes]) - Multiple deposit addresses
  • fetchDepositAddressesByNetwork(code) - Addresses by network
  • createDepositAddress(code, params) - Create new deposit address
  • fetchDeposit(id, code) - Fetch single deposit
  • fetchWithdrawal(id, code) - Fetch single withdrawal
  • fetchWithdrawAddresses(code) - Fetch withdrawal addresses
  • fetchWithdrawalWhitelist(code) - Fetch whitelist
  • withdraw(code, amount, address, tag, params) - Withdraw funds
  • deposit(code, amount, params) - Deposit funds (if supported)

Transfer & Convert

  • transfer(code, amount, fromAccount, toAccount) - Internal transfer
  • fetchTransfer(id, code) - Fetch transfer info
  • fetchTransfers(code, since, limit) - Fetch transfer history
  • fetchConvertCurrencies() - Currencies available for convert
  • fetchConvertQuote(fromCode, toCode, amount) - Get conversion quote
  • createConvertTrade(fromCode, toCode, amount) - Execute conversion
  • fetchConvertTrade(id) - Fetch convert trade
  • fetchConvertTradeHistory(code, since, limit) - Convert history

Market Info

  • fetchMarkets() - Fetch all markets
  • fetchCurrencies() - Fetch all currencies
  • fetchTime() - Fetch exchange server time
  • fetchStatus() - Fetch exchange status
  • fetchBorrowInterest(code, symbol, since, limit) - Borrow interest paid
  • fetchLongShortRatio(symbol, timeframe, since, limit) - Long/short ratio
  • fetchLongShortRatioHistory(symbol, timeframe, since, limit) - L/S ratio history

WebSocket Methods (ccxt.pro)

All REST methods have WebSocket equivalents with watch* prefix:

Real-time Market Data

  • watchTicker(symbol) - Watch single ticker
  • watchTickers([symbols]) - Watch multiple tickers
  • watchOrderBook(symbol) - Watch order book updates
  • watchOrderBookForSymbols([symbols]) - Watch multiple order books
  • watchTrades(symbol) - Watch public trades
  • watchOHLCV(symbol, timeframe) - Watch candlestick updates
  • watchBidsAsks([symbols]) - Watch best bid/ask

Real-time Account Data (Auth Required)

  • watchBalance() - Watch balance updates
  • watchOrders(symbol) - Watch your order updates
  • watchMyTrades(symbol) - Watch your trade updates
  • watchPositions([symbols]) - Watch position updates
  • watchPositionsForSymbol(symbol) - Watch positions for symbol

Authentication Required

Methods marked with 🔒 require API credentials:

  • All create* methods (creating orders, addresses)
  • All cancel* methods (canceling orders)
  • All edit* methods (modifying orders)
  • All fetchMy* methods (your trades, orders)
  • fetchBalance, fetchLedger, fetchAccounts
  • withdraw, transfer, deposit
  • Margin/leverage methods
  • Position methods
  • watchBalance, watchOrders, watchMyTrades, watchPositions

Checking Method Availability

Not all exchanges support all methods. Check before using:

// Check if method is supported
if (exchange.has['fetchOHLCV']) {
    const candles = await exchange.fetchOHLCV('BTC/USDT', '1h')
}

// Check multiple capabilities
console.log(exchange.has)
// {
//   fetchTicker: true,
//   fetchOHLCV: true,
//   fetchMyTrades: true,
//   fetchPositions: false,
//   ...
// }

Method Naming Convention

  • fetch* - REST API methods (HTTP requests)
  • watch* - WebSocket methods (real-time streams)
  • create* - Create new resources (orders, addresses)
  • cancel* - Cancel existing resources
  • edit* - Modify existing resources
  • set* - Configure settings (leverage, margin mode)
  • *Ws suffix - WebSocket variant (some exchanges)

Proxy Configuration

CCXT supports HTTP, HTTPS, and SOCKS proxies for both REST and WebSocket connections.

Setting Proxy

// HTTP Proxy
exchange.httpProxy = 'http://your-proxy-host:port'

// HTTPS Proxy  
exchange.httpsProxy = 'https://your-proxy-host:port'

// SOCKS Proxy
exchange.socksProxy = 'socks://your-proxy-host:port'

// Proxy with authentication
exchange.httpProxy = 'http://user:pass@proxy-host:port'

Proxy for WebSocket

WebSocket connections also respect proxy settings:

exchange.httpsProxy = 'https://proxy:8080'
// WebSocket connections will use this proxy

Testing Proxy Connection

exchange.httpProxy = 'http://localhost:8080'
try {
    await exchange.fetchTicker('BTC/USDT')
    console.log('Proxy working!')
} catch (error) {
    console.error('Proxy connection failed:', error)
}

WebSocket-Specific Methods

Some exchanges provide WebSocket variants of REST methods for faster order placement and management. These use the *Ws suffix:

Trading via WebSocket

Creating Orders:

  • createOrderWs - Create order via WebSocket (faster than REST)
  • createLimitOrderWs - Create limit order via WebSocket
  • createMarketOrderWs - Create market order via WebSocket
  • createLimitBuyOrderWs - Buy limit order via WebSocket
  • createLimitSellOrderWs - Sell limit order via WebSocket
  • createMarketBuyOrderWs - Buy market order via WebSocket
  • createMarketSellOrderWs - Sell market order via WebSocket
  • createStopLimitOrderWs - Stop-limit order via WebSocket
  • createStopMarketOrderWs - Stop-market order via WebSocket
  • createStopLossOrderWs - Stop-loss order via WebSocket
  • createTakeProfitOrderWs - Take-profit order via WebSocket
  • createTrailingAmountOrderWs - Trailing stop via WebSocket
  • createTrailingPercentOrderWs - Trailing stop % via WebSocket
  • createPostOnlyOrderWs - Post-only order via WebSocket
  • createReduceOnlyOrderWs - Reduce-only order via WebSocket

Managing Orders:

  • editOrderWs - Edit order via WebSocket
  • cancelOrderWs - Cancel order via WebSocket (faster than REST)
  • cancelOrdersWs - Cancel multiple orders via WebSocket
  • cancelAllOrdersWs - Cancel all orders via WebSocket

Fetching Data:

  • fetchOrderWs - Fetch order via WebSocket
  • fetchOrdersWs - Fetch orders via WebSocket
  • fetchOpenOrdersWs - Fetch open orders via WebSocket
  • fetchClosedOrdersWs - Fetch closed orders via WebSocket
  • fetchMyTradesWs - Fetch your trades via WebSocket
  • fetchBalanceWs - Fetch balance via WebSocket
  • fetchPositionWs - Fetch position via WebSocket
  • fetchPositionsWs - Fetch positions via WebSocket
  • fetchPositionsForSymbolWs - Fetch positions for symbol via WebSocket
  • fetchTradingFeesWs - Fetch trading fees via WebSocket

When to Use WebSocket Methods

Use *Ws methods when:

  • You need faster order placement (lower latency)
  • You're already connected via WebSocket
  • You want to reduce REST API rate limit usage
  • Trading strategies require sub-100ms latency

Use REST methods when:

  • You need guaranteed execution confirmation
  • You're making one-off requests
  • The exchange doesn't support the WebSocket variant
  • You need detailed error responses

Example: Order Placement Comparison

REST API (slower, more reliable):

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

WebSocket API (faster, lower latency):

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

Checking WebSocket Method Availability

Not all exchanges support WebSocket trading methods:

if (exchange.has['createOrderWs']) {
    // Exchange supports WebSocket order creation
    const order = await exchange.createOrderWs('BTC/USDT', 'limit', 'buy', 0.01, 50000)
} else {
    // Fall back to REST
    const order = await exchange.createOrder('BTC/USDT', 'limit', 'buy', 0.01, 50000)
}

Authentication

Setting API Keys

import "os"

// During instantiation
exchange := binance.New()
exchange.ApiKey = os.Getenv("BINANCE_API_KEY")
exchange.Secret = os.Getenv("BINANCE_SECRET")
exchange.EnableRateLimit = true

Testing Authentication

balance, err := exchange.FetchBalance()
if err != nil {
    if _, ok := err.(*ccxt.AuthenticationError); ok {
        fmt.Println("Invalid API credentials")
    } else {
        panic(err)
    }
} else {
    fmt.Println("Authentication successful!")
}

Error Handling

Error Types

BaseError
├─ NetworkError (recoverable - retry)
│  ├─ RequestTimeout
│  ├─ ExchangeNotAvailable
│  ├─ RateLimitExceeded
│  └─ DDoSProtection
└─ ExchangeError (non-recoverable - don't retry)
   ├─ AuthenticationError
   ├─ InsufficientFunds
   ├─ InvalidOrder
   └─ NotSupported

Basic Error Handling

import "github.com/ccxt/ccxt/go/v4/ccxt"

ticker, err := exchange.FetchTicker("BTC/USDT")
if err != nil {
    switch e := err.(type) {
    case *ccxt.NetworkError:
        fmt.Println("Network error - retry:", e.Message)
    case *ccxt.ExchangeError:
        fmt.Println("Exchange error - do not retry:", e.Message)
    default:
        fmt.Println("Unknown error:", err)
    }
}

Specific Error Handling

order, err := exchange.CreateOrder("BTC/USDT", "limit", "buy", 0.01, 50000, nil)
if err != nil {
    switch err.(type) {
    case *ccxt.InsufficientFunds:
        fmt.Println("Not enough balance")
    case *ccxt.InvalidOrder:
        fmt.Println("Invalid order parameters")
    case *ccxt.RateLimitExceeded:
        fmt.Println("Rate limit hit - wait before retrying")
        time.Sleep(1 * time.Second)
    case *ccxt.AuthenticationError:
        fmt.Println("Check your API credentials")
    default:
        panic(err)
    }
}

Retry Logic for Network Errors

import "time"

func fetchWithRetry(exchange *binance.Exchange, maxRetries int) (*ccxt.Ticker, error) {
    for i := 0; i < maxRetries; i++ {
        ticker, err := exchange.FetchTicker("BTC/USDT")
        if err == nil {
            return ticker, nil
        }

        if _, ok := err.(*ccxt.NetworkError); ok && i < maxRetries-1 {
            fmt.Printf("Retry %d/%d\n", i+1, maxRetries)
            time.Sleep(time.Duration(i+1) * time.Second)  // Exponential backoff
        } else {
            return nil, err
        }
    }
    return nil, fmt.Errorf("all retries failed")
}

Rate Limiting

Built-in Rate Limiter (Recommended)

exchange := binance.New()
exchange.EnableRateLimit = true  // Automatically throttles requests

Manual Delays

import "time"

exchange.FetchTicker("BTC/USDT")
time.Sleep(time.Duration(exchange.RateLimit) * time.Millisecond)
exchange.FetchTicker("ETH/USDT")

Checking Rate Limit

fmt.Println(exchange.RateLimit)  // Milliseconds between requests

Common Pitfalls

Not Checking Error Returns

// Wrong - ignores errors
ticker, _ := exchange.FetchTicker("BTC/USDT")
fmt.Println(ticker.Last)  // May panic if ticker is nil!

// Correct - check errors
ticker, err := exchange.FetchTicker("BTC/USDT")
if err != nil {
    panic(err)
}
fmt.Println(ticker.Last)

Wrong Import Path

// Wrong - missing /v4
import "github.com/ccxt/ccxt/go/binance"  // ERROR!

// Correct - must include /v4
import "github.com/ccxt/ccxt/go/v4/binance"

// Correct - WebSocket with /v4/pro
import "github.com/ccxt/ccxt/go/v4/pro/binance"

Using REST for Real-time Monitoring

// Wrong - wastes rate limits
for {
    ticker, _ := exchange.FetchTicker("BTC/USDT")  // REST
    fmt.Println(ticker.Last)
    time.Sleep(1 * time.Second)
}

// Correct - use WebSocket
import "github.com/ccxt/ccxt/go/v4/pro/binance"

exchange := binance.New()
defer exchange.Close()

for {
    ticker, err := exchange.WatchTicker("BTC/USDT")  // WebSocket
    if err != nil {
        panic(err)
    }
    fmt.Println(ticker.Last)
}

Not Closing WebSocket Connections

// Wrong - memory leak
exchange := binance.New()
ticker, _ := exchange.WatchTicker("BTC/USDT")
// Forgot to close!

// Correct - always defer Close()
exchange := binance.New()
defer exchange.Close()

for {
    ticker, err := exchange.WatchTicker("BTC/USDT")
    if err != nil {
        break
    }
    fmt.Println(ticker.Last)
}

Incorrect Symbol Format

// Wrong symbol formats
"BTCUSDT"    // Wrong - no separator
"BTC-USDT"   // Wrong - dash separator
"btc/usdt"   // Wrong - lowercase

// Correct symbol format
"BTC/USDT"   // Unified CCXT format

Troubleshooting

Common Issues

1. "package github.com/ccxt/ccxt/go/v4/binance: cannot find package"

  • Solution: Run go get github.com/ccxt/ccxt/go/v4

2. "RateLimitExceeded"

  • Solution: Set exchange.EnableRateLimit = true

3. "AuthenticationError"

  • Solution: Check API key and secret
  • Verify API key permissions on exchange
  • Check system clock is synced

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

Debugging

// Enable verbose logging
exchange.Verbose = true

// Check exchange capabilities
fmt.Println(exchange.Has)
// map[string]bool{
//   "fetchTicker": true,
//   "fetchOrderBook": true,
//   "createOrder": true,
//   ...
// }

// Check market information
market := exchange.Markets["BTC/USDT"]
fmt.Println(market)

// Check last request/response
fmt.Println(exchange.LastHttpResponse)
fmt.Println(exchange.LastJsonResponse)

Learn More

Install via CLI
npx skills add https://github.com/ccxt/ccxt --skill ccxt-go
Repository Details
star Stars 42,948
call_split Forks 8,698
navigation Branch main
article Path SKILL.md
Occupations
Software Developers
More from Creator
ccxt
ccxt Explore all skills →