--- 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 ```bash go get github.com/ccxt/ccxt/go/v4 ``` ### WebSocket API (ccxt.pro) ```bash go get github.com/ccxt/ccxt/go/v4/pro ``` ## Quick Start ### REST API ```go 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 ```go 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 ```go 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 ```go 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 ```go // 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 ```go // 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 ```go // 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 ```go // 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 ```go // 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 ```go 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 ```go // 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 ```go // 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 ```go // 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) ```go 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) ```go 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) ```go 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) ```go 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) ```go 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 ```go 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 ```go 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 ```go 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 ```go 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 ```go 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) ```go exchange := binance.New() exchange.EnableRateLimit = true // Automatically throttles requests ``` ### Manual Delays ```go import "time" exchange.FetchTicker("BTC/USDT") time.Sleep(time.Duration(exchange.RateLimit) * time.Millisecond) exchange.FetchTicker("ETH/USDT") ``` ### Checking Rate Limit ```go fmt.Println(exchange.RateLimit) // Milliseconds between requests ``` ## Common Pitfalls ### Not Checking Error Returns ```go // 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 ```go // 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 ```go // 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 ```go // 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 ```go // 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 ```go // 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 - [CCXT Manual](https://docs.ccxt.com/) - [CCXT Pro Documentation](https://docs.ccxt.com/en/latest/ccxt.pro.html) - [Supported Exchanges](https://github.com/ccxt/ccxt#supported-cryptocurrency-exchange-markets) - [GitHub Repository](https://github.com/ccxt/ccxt)