ccxt-php

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

CCXT for PHP

CCXT for PHP 开发指南

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

一份关于在PHP项目中集成加密货币交易所时使用CCXT的全面指南。

Installation

安装

Via Composer (REST and WebSocket)

通过Composer安装（支持REST与WebSocket）

bash

composer require ccxt/ccxt

bash

composer require ccxt/ccxt

Required PHP Extensions

所需PHP扩展

cURL
mbstring (UTF-8)
PCRE
iconv
gmp (for some exchanges)

cURL
mbstring（UTF-8编码支持）
PCRE
iconv
gmp（部分交易所需要）

Optional for Async/WebSocket

异步/WebSocket可选依赖

ReactPHP (installed automatically with ccxt)

ReactPHP（安装CCXT时会自动安装）

Quick Start

快速开始

REST API - Synchronous

REST API - 同步方式

php

<?php
date_default_timezone_set('UTC');  // Required!
require_once 'vendor/autoload.php';

$exchange = new \ccxt\binance();
$exchange->load_markets();
$ticker = $exchange->fetch_ticker('BTC/USDT');
print_r($ticker);

php

<?php
date_default_timezone_set('UTC');  // 必须设置！
require_once 'vendor/autoload.php';

$exchange = new \ccxt\binance();
$exchange->load_markets();
$ticker = $exchange->fetch_ticker('BTC/USDT');
print_r($ticker);

REST API - Asynchronous (ReactPHP)

REST API - 异步方式（基于ReactPHP）

php

<?php
use function React\Async\await;

date_default_timezone_set('UTC');
require_once 'vendor/autoload.php';

$exchange = new \ccxt\async\binance();
$ticker = await($exchange->fetch_ticker('BTC/USDT'));
print_r($ticker);

php

<?php
use function React\Async\await;

date_default_timezone_set('UTC');
require_once 'vendor/autoload.php';

$exchange = new \ccxt\async\binance();
$ticker = await($exchange->fetch_ticker('BTC/USDT'));
print_r($ticker);

WebSocket API - Real-time Updates

WebSocket API - 实时数据更新

php

<?php
use function React\Async\await;
use function React\Async\async;

date_default_timezone_set('UTC');
require_once 'vendor/autoload.php';

$exchange = new \ccxt\pro\binance();

while (true) {
    $ticker = await($exchange->watch_ticker('BTC/USDT'));
    print_r($ticker);  // Live updates!
}

await($exchange->close());

php

<?php
use function React\Async\await;
use function React\Async\async;

date_default_timezone_set('UTC');
require_once 'vendor/autoload.php';

$exchange = new \ccxt\pro\binance();

while (true) {
    $ticker = await($exchange->watch_ticker('BTC/USDT'));
    print_r($ticker);  // 实时更新！
}

await($exchange->close());

REST vs WebSocket

REST与WebSocket对比

Mode	REST	WebSocket
Sync	`\ccxt\binance()`	(WebSocket requires async)
Async	`\ccxt\async\binance()`	`\ccxt\pro\binance()`

Feature	REST API	WebSocket API
Use for	One-time queries, placing orders	Real-time monitoring, live price feeds
Method prefix	`fetch_*` (fetch_ticker, fetch_order_book)	`watch_*` (watch_ticker, watch_order_book)
Speed	Slower (HTTP request/response)	Faster (persistent connection)
Rate limits	Strict (1-2 req/sec)	More lenient (continuous stream)
Best for	Trading, account management	Price monitoring, arbitrage detection

模式	REST	WebSocket
同步	`\ccxt\binance()`	（WebSocket仅支持异步）
异步	`\ccxt\async\binance()`	`\ccxt\pro\binance()`

特性	REST API	WebSocket API
适用场景	一次性查询、订单提交	实时监控、实时价格推送
方法前缀	`fetch_*` （如fetch_ticker、fetch_order_book）	`watch_*` （如watch_ticker、watch_order_book）
速度	较慢（HTTP请求/响应模式）	更快（长连接模式）
请求限制	严格限制（1-2次/秒）	限制宽松（持续数据流）
最佳适用场景	交易操作、账户管理	价格监控、套利检测

Creating Exchange Instance

创建交易所实例

REST API - Synchronous

REST API - 同步方式

php

<?php
date_default_timezone_set('UTC');
require_once 'vendor/autoload.php';

// Public API (no authentication)
$exchange = new \ccxt\binance([
    'enableRateLimit' => true  // Recommended!
]);

// Private API (with authentication)
$exchange = new \ccxt\binance([
    'apiKey' => 'YOUR_API_KEY',
    'secret' => 'YOUR_SECRET',
    'enableRateLimit' => true
]);

php

<?php
date_default_timezone_set('UTC');
require_once 'vendor/autoload.php';

// 公开API（无需身份验证）
$exchange = new \ccxt\binance([
    'enableRateLimit' => true  // 推荐启用！
]);

// 私有API（需身份验证）
$exchange = new \ccxt\binance([
    'apiKey' => 'YOUR_API_KEY',
    'secret' => 'YOUR_SECRET',
    'enableRateLimit' => true
]);

REST API - Asynchronous

REST API - 异步方式

php

<?php
use function React\Async\await;

$exchange = new \ccxt\async\binance([
    'enableRateLimit' => true
]);

$ticker = await($exchange->fetch_ticker('BTC/USDT'));

php

<?php
use function React\Async\await;

$exchange = new \ccxt\async\binance([
    'enableRateLimit' => true
]);

$ticker = await($exchange->fetch_ticker('BTC/USDT'));

WebSocket API

php

<?php
use function React\Async\await;

// Public WebSocket
$exchange = new \ccxt\pro\binance();

// Private WebSocket (with authentication)
$exchange = new \ccxt\pro\binance([
    'apiKey' => 'YOUR_API_KEY',
    'secret' => 'YOUR_SECRET'
]);

// Always close when done
await($exchange->close());

php

<?php
use function React\Async\await;

// 公开WebSocket
$exchange = new \ccxt\pro\binance();

// 私有WebSocket（需身份验证）
$exchange = new \ccxt\pro\binance([
    'apiKey' => 'YOUR_API_KEY',
    'secret' => 'YOUR_SECRET'
]);

// 使用完成后务必关闭连接
await($exchange->close());

Common REST Operations

常见REST操作

Loading Markets

加载市场信息

php

// Load all available trading pairs
$exchange->load_markets();

// Access market information
$btc_market = $exchange->market('BTC/USDT');
print_r($btc_market['limits']['amount']['min']);  // Minimum order amount

php

// 加载所有可用交易对
$exchange->load_markets();

// 访问市场详情
$btc_market = $exchange->market('BTC/USDT');
print_r($btc_market['limits']['amount']['min']);  // 最小下单量

Fetching Ticker

获取行情数据

php

// Single ticker
$ticker = $exchange->fetch_ticker('BTC/USDT');
print_r($ticker['last']);      // Last price
print_r($ticker['bid']);       // Best bid
print_r($ticker['ask']);       // Best ask
print_r($ticker['volume']);    // 24h volume

// Multiple tickers (if supported)
$tickers = $exchange->fetch_tickers(['BTC/USDT', 'ETH/USDT']);

php

// 单个交易对行情
$ticker = $exchange->fetch_ticker('BTC/USDT');
print_r($ticker['last']);      // 最新成交价
print_r($ticker['bid']);       // 最优买价
print_r($ticker['ask']);       // 最优卖价
print_r($ticker['volume']);    // 24小时成交量

// 多个交易对行情（若交易所支持）
$tickers = $exchange->fetch_tickers(['BTC/USDT', 'ETH/USDT']);

Fetching Order Book

获取订单簿

php

// Full orderbook
$orderbook = $exchange->fetch_order_book('BTC/USDT');
print_r($orderbook['bids'][0]);  // [price, amount]
print_r($orderbook['asks'][0]);  // [price, amount]

// Limited depth
$orderbook = $exchange->fetch_order_book('BTC/USDT', 5);  // Top 5 levels

php

// 完整订单簿
$orderbook = $exchange->fetch_order_book('BTC/USDT');
print_r($orderbook['bids'][0]);  // [价格, 数量]
print_r($orderbook['asks'][0]);  // [价格, 数量]

// 限定深度的订单簿
$orderbook = $exchange->fetch_order_book('BTC/USDT', 5);  // 前5档数据

Creating Orders

提交订单

Limit Order

限价订单

php

// Buy limit order
$order = $exchange->create_limit_buy_order('BTC/USDT', 0.01, 50000);
print_r($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);

php

// 买入限价订单
$order = $exchange->create_limit_buy_order('BTC/USDT', 0.01, 50000);
print_r($order['id']);

// 卖出限价订单
$order = $exchange->create_limit_sell_order('BTC/USDT', 0.01, 60000);

// 通用限价订单
$order = $exchange->create_order('BTC/USDT', 'limit', 'buy', 0.01, 50000);

Market Order

市价订单

php

// 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);

php

// 买入市价订单
$order = $exchange->create_market_buy_order('BTC/USDT', 0.01);

// 卖出市价订单
$order = $exchange->create_market_sell_order('BTC/USDT', 0.01);

// 通用市价订单
$order = $exchange->create_order('BTC/USDT', 'market', 'sell', 0.01);

Fetching Balance

获取账户余额

php

$balance = $exchange->fetch_balance();
print_r($balance['BTC']['free']);   // Available balance
print_r($balance['BTC']['used']);   // Balance in orders
print_r($balance['BTC']['total']);  // Total balance

php

$balance = $exchange->fetch_balance();
print_r($balance['BTC']['free']);   // 可用余额
print_r($balance['BTC']['used']);   // 订单占用余额
print_r($balance['BTC']['total']);  // 总余额

Fetching Orders

获取订单信息

php

// 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');

php

// 未成交订单
$open_orders = $exchange->fetch_open_orders('BTC/USDT');

// 已成交订单
$closed_orders = $exchange->fetch_closed_orders('BTC/USDT');

// 所有订单（未成交+已成交）
$all_orders = $exchange->fetch_orders('BTC/USDT');

// 通过订单ID查询单个订单
$order = $exchange->fetch_order($order_id, 'BTC/USDT');

Fetching Trades

获取交易记录

php

// Recent public trades
$trades = $exchange->fetch_trades('BTC/USDT', null, 10);

// Your trades (requires authentication)
$my_trades = $exchange->fetch_my_trades('BTC/USDT');

php

// 最近公开交易记录
$trades = $exchange->fetch_trades('BTC/USDT', null, 10);

// 个人交易记录（需身份验证）
$my_trades = $exchange->fetch_my_trades('BTC/USDT');

Canceling Orders

取消订单

php

// Cancel single order
$exchange->cancel_order($order_id, 'BTC/USDT');

// Cancel all orders for a symbol
$exchange->cancel_all_orders('BTC/USDT');

php

// 取消单个订单
$exchange->cancel_order($order_id, 'BTC/USDT');

// 取消某个交易对的所有订单
$exchange->cancel_all_orders('BTC/USDT');

WebSocket Operations (Real-time)

WebSocket实时操作

Watching Ticker (Live Price Updates)

监控行情（实时价格更新）

php

<?php
use function React\Async\await;

$exchange = new \ccxt\pro\binance();

while (true) {
    $ticker = await($exchange->watch_ticker('BTC/USDT'));
    print_r($ticker['last']);
}

await($exchange->close());

php

<?php
use function React\Async\await;

$exchange = new \ccxt\pro\binance();

while (true) {
    $ticker = await($exchange->watch_ticker('BTC/USDT'));
    print_r($ticker['last']);
}

await($exchange->close());

Watching Order Book (Live Depth Updates)

监控订单簿（实时深度更新）

php

<?php
use function React\Async\await;

$exchange = new \ccxt\pro\binance();

while (true) {
    $orderbook = await($exchange->watch_order_book('BTC/USDT'));
    print_r('Best bid: ' . $orderbook['bids'][0][0]);
    print_r('Best ask: ' . $orderbook['asks'][0][0]);
}

await($exchange->close());

php

<?php
use function React\Async\await;

$exchange = new \ccxt\pro\binance();

while (true) {
    $orderbook = await($exchange->watch_order_book('BTC/USDT'));
    print_r('最优买价: ' . $orderbook['bids'][0][0]);
    print_r('最优卖价: ' . $orderbook['asks'][0][0]);
}

await($exchange->close());

Watching Trades (Live Trade Stream)

监控交易记录（实时交易流）

php

<?php
use function React\Async\await;

$exchange = new \ccxt\pro\binance();

while (true) {
    $trades = await($exchange->watch_trades('BTC/USDT'));
    foreach ($trades as $trade) {
        print_r($trade['price'] . ' ' . $trade['amount'] . ' ' . $trade['side']);
    }
}

await($exchange->close());

php

<?php
use function React\Async\await;

$exchange = new \ccxt\pro\binance();

while (true) {
    $trades = await($exchange->watch_trades('BTC/USDT'));
    foreach ($trades as $trade) {
        print_r($trade['price'] . ' ' . $trade['amount'] . ' ' . $trade['side']);
    }
}

await($exchange->close());

Watching Your Orders (Live Order Updates)

监控个人订单（实时订单更新）

php

<?php
use function React\Async\await;

$exchange = new \ccxt\pro\binance([
    'apiKey' => 'YOUR_API_KEY',
    'secret' => 'YOUR_SECRET'
]);

while (true) {
    $orders = await($exchange->watch_orders('BTC/USDT'));
    foreach ($orders as $order) {
        print_r($order['id'] . ' ' . $order['status'] . ' ' . $order['filled']);
    }
}

await($exchange->close());

php

<?php
use function React\Async\await;

$exchange = new \ccxt\pro\binance([
    'apiKey' => 'YOUR_API_KEY',
    'secret' => 'YOUR_SECRET'
]);

while (true) {
    $orders = await($exchange->watch_orders('BTC/USDT'));
    foreach ($orders as $order) {
        print_r($order['id'] . ' ' . $order['status'] . ' ' . $order['filled']);
    }
}

await($exchange->close());

Watching Balance (Live Balance Updates)

监控账户余额（实时余额更新）

php

<?php
use function React\Async\await;

$exchange = new \ccxt\pro\binance([
    'apiKey' => 'YOUR_API_KEY',
    'secret' => 'YOUR_SECRET'
]);

while (true) {
    $balance = await($exchange->watch_balance());
    print_r('BTC: ' . $balance['BTC']['total']);
}

await($exchange->close());

php

<?php
use function React\Async\await;

$exchange = new \ccxt\pro\binance([
    'apiKey' => 'YOUR_API_KEY',
    'secret' => 'YOUR_SECRET'
]);

while (true) {
    $balance = await($exchange->watch_balance());
    print_r('BTC余额: ' . $balance['BTC']['total']);
}

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)

```
fetchTicker(symbol)
```
- 获取单个交易对行情
```
fetchTickers([symbols])
```
- 批量获取多个交易对行情
```
fetchBidsAsks([symbols])
```
- 获取多个交易对的最优买卖价
```
fetchLastPrices([symbols])
```
- 获取多个交易对的最新成交价
```
fetchMarkPrices([symbols])
```
- 获取标记价格（衍生品）

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)

```
fetchOrderBook(symbol, limit)
```
- 获取订单簿
```
fetchOrderBooks([symbols])
```
- 批量获取多个订单簿
```
fetchL2OrderBook(symbol)
```
- 获取Level 2订单簿
```
fetchL3OrderBook(symbol)
```
- 获取Level 3订单簿（若交易所支持）

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

```
fetchTrades(symbol, since, limit)
```
- 获取公开交易记录
```
fetchMyTrades(symbol, since, limit)
```
- 获取个人交易记录（需身份验证）
```
fetchOrderTrades(orderId, symbol)
```
- 获取指定订单的交易记录

OHLCV (Candlesticks)

K线数据（OHLCV）

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

fetchOHLCV(symbol, timeframe, since, limit)

- 获取K线数据

```
fetchIndexOHLCV(symbol, timeframe)
```
- 获取指数价格K线
```
fetchMarkOHLCV(symbol, timeframe)
```
- 获取标记价格K线

fetchPremiumIndexOHLCV(symbol, timeframe)

- 获取溢价指数K线

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

```
fetchBalance()
```
- 获取账户余额（需身份验证）
```
fetchAccounts()
```
- 获取子账户信息
```
fetchLedger(code, since, limit)
```
- 获取账户流水
```
fetchLedgerEntry(id, code)
```
- 获取指定流水记录
```
fetchTransactions(code, since, limit)
```
- 获取交易记录
```
fetchDeposits(code, since, limit)
```
- 获取充值记录
```
fetchWithdrawals(code, since, limit)
```
- 获取提现记录

fetchDepositsWithdrawals(code, since, limit)

- 获取充值与提现记录

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

createOrder(symbol, type, side, amount, price, params)

- 通用订单提交

createLimitOrder(symbol, side, amount, price)

- 提交限价订单

```
createMarketOrder(symbol, side, amount)
```
- 提交市价订单

createLimitBuyOrder(symbol, amount, price)

- 提交买入限价订单

createLimitSellOrder(symbol, amount, price)

- 提交卖出限价订单

```
createMarketBuyOrder(symbol, amount)
```
- 提交买入市价订单
```
createMarketSellOrder(symbol, amount)
```
- 提交卖出市价订单

createMarketBuyOrderWithCost(symbol, cost)

- 按指定金额买入

createStopLimitOrder(symbol, side, amount, price, stopPrice)

- 提交止损限价订单

createStopMarketOrder(symbol, side, amount, stopPrice)

- 提交止损市价订单

createStopLossOrder(symbol, side, amount, stopPrice)

- 提交止损订单

createTakeProfitOrder(symbol, side, amount, takeProfitPrice)

- 提交止盈订单

createTrailingAmountOrder(symbol, side, amount, trailingAmount)

- 提交追踪止损订单（按金额）

createTrailingPercentOrder(symbol, side, amount, trailingPercent)

- 提交追踪止损订单（按比例）

createTriggerOrder(symbol, side, amount, triggerPrice)

- 触发订单

createPostOnlyOrder(symbol, side, amount, price)

- 提交仅挂单订单

createReduceOnlyOrder(symbol, side, amount, price)

- 提交仅减仓订单

```
createOrders([orders])
```
- 批量提交订单

createOrderWithTakeProfitAndStopLoss(symbol, type, side, amount, price, tpPrice, slPrice)

- 提交OCO订单

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

```
fetchOrder(orderId, symbol)
```
- 获取单个订单
```
fetchOrders(symbol, since, limit)
```
- 获取所有订单
```
fetchOpenOrders(symbol, since, limit)
```
- 获取未成交订单
```
fetchClosedOrders(symbol, since, limit)
```
- 获取已成交订单

fetchCanceledOrders(symbol, since, limit)

- 获取已取消订单

```
fetchOpenOrder(orderId, symbol)
```
- 获取单个未成交订单
```
fetchOrdersByStatus(status, symbol)
```
- 按状态获取订单
```
cancelOrder(orderId, symbol)
```
- 取消单个订单
```
cancelOrders([orderIds], symbol)
```
- 批量取消订单
```
cancelAllOrders(symbol)
```
- 取消某个交易对的所有订单

editOrder(orderId, symbol, type, side, amount, price)

- 修改订单

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

```
fetchBorrowRate(code)
```
- 获取保证金借贷利率
```
fetchBorrowRates([codes])
```
- 批量获取借贷利率

fetchBorrowRateHistory(code, since, limit)

- 获取借贷利率历史

```
fetchCrossBorrowRate(code)
```
- 获取全仓保证金借贷利率
```
fetchIsolatedBorrowRate(symbol, code)
```
- 获取逐仓保证金借贷利率
```
borrowMargin(code, amount, symbol)
```
- 借入保证金
```
repayMargin(code, amount, symbol)
```
- 归还保证金
```
fetchLeverage(symbol)
```
- 获取杠杆倍数
```
setLeverage(leverage, symbol)
```
- 设置杠杆倍数
```
fetchLeverageTiers(symbols)
```
- 获取杠杆档位
```
fetchMarketLeverageTiers(symbol)
```
- 获取指定交易对的杠杆档位
```
setMarginMode(marginMode, symbol)
```
- 设置保证金模式（全仓/逐仓）
```
fetchMarginMode(symbol)
```
- 获取保证金模式

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

```
fetchPosition(symbol)
```
- 获取单个仓位
```
fetchPositions([symbols])
```
- 获取所有仓位
```
fetchPositionsForSymbol(symbol)
```
- 获取指定交易对的仓位

fetchPositionHistory(symbol, since, limit)

- 获取仓位历史

fetchPositionsHistory(symbols, since, limit)

- 批量获取仓位历史

```
fetchPositionMode(symbol)
```
- 获取仓位模式（单向/双向）
```
setPositionMode(hedged, symbol)
```
- 设置仓位模式
```
closePosition(symbol, side)
```
- 平仓
```
closeAllPositions()
```
- 全部平仓

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

```
fetchFundingRate(symbol)
```
- 获取当前资金费率
```
fetchFundingRates([symbols])
```
- 批量获取资金费率

fetchFundingRateHistory(symbol, since, limit)

- 获取资金费率历史

fetchFundingHistory(symbol, since, limit)

- 获取个人资金费用记录

```
fetchFundingInterval(symbol)
```
- 获取资金费用结算间隔

fetchSettlementHistory(symbol, since, limit)

- 获取结算历史

fetchMySettlementHistory(symbol, since, limit)

- 获取个人结算历史

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

```
fetchOpenInterest(symbol)
```
- 获取持仓量
```
fetchOpenInterests([symbols])
```
- 批量获取持仓量

fetchOpenInterestHistory(symbol, timeframe, since, limit)

- 获取持仓量历史

```
fetchLiquidations(symbol, since, limit)
```
- 获取公开强平记录

fetchMyLiquidations(symbol, since, limit)

- 获取个人强平记录

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

```
fetchOption(symbol)
```
- 获取期权信息
```
fetchOptionChain(code)
```
- 获取期权链
```
fetchGreeks(symbol)
```
- 获取期权希腊值

fetchVolatilityHistory(code, since, limit)

- 获取波动率历史

```
fetchUnderlyingAssets()
```
- 获取标的资产

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

```
fetchTradingFee(symbol)
```
- 获取交易手续费
```
fetchTradingFees([symbols])
```
- 批量获取交易手续费
```
fetchTradingLimits([symbols])
```
- 获取交易限制
```
fetchTransactionFee(code)
```
- 获取转账/提现手续费
```
fetchTransactionFees([codes])
```
- 批量获取转账手续费
```
fetchDepositWithdrawFee(code)
```
- 获取充值/提现手续费
```
fetchDepositWithdrawFees([codes])
```
- 批量获取充值/提现手续费

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)

```
fetchDepositAddress(code, params)
```
- 获取充值地址
```
fetchDepositAddresses([codes])
```
- 批量获取充值地址
```
fetchDepositAddressesByNetwork(code)
```
- 按网络获取充值地址
```
createDepositAddress(code, params)
```
- 创建新的充值地址
```
fetchDeposit(id, code)
```
- 获取单个充值记录
```
fetchWithdrawal(id, code)
```
- 获取单个提现记录
```
fetchWithdrawAddresses(code)
```
- 获取提现地址
```
fetchWithdrawalWhitelist(code)
```
- 获取提现白名单

withdraw(code, amount, address, tag, params)

- 提现

```
deposit(code, amount, params)
```
- 充值（若交易所支持）

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

transfer(code, amount, fromAccount, toAccount)

- 内部转账

```
fetchTransfer(id, code)
```
- 获取转账记录
```
fetchTransfers(code, since, limit)
```
- 获取转账历史
```
fetchConvertCurrencies()
```
- 获取支持兑换的币种

fetchConvertQuote(fromCode, toCode, amount)

- 获取兑换报价

createConvertTrade(fromCode, toCode, amount)

- 执行兑换

```
fetchConvertTrade(id)
```
- 获取兑换记录

fetchConvertTradeHistory(code, since, limit)

- 获取兑换历史

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

```
fetchMarkets()
```
- 获取所有交易对
```
fetchCurrencies()
```
- 获取所有币种
```
fetchTime()
```
- 获取交易所服务器时间
```
fetchStatus()
```
- 获取交易所状态

fetchBorrowInterest(code, symbol, since, limit)

- 获取借贷利息记录

fetchLongShortRatio(symbol, timeframe, since, limit)

- 获取多空比

fetchLongShortRatioHistory(symbol, timeframe, since, limit)

- 获取多空比历史

WebSocket Methods (ccxt.pro)

WebSocket方法（ccxt.pro）

All REST methods have WebSocket equivalents with

watch*

prefix:

所有REST方法都有对应的WebSocket方法，前缀为

watch*

：

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

```
watchTicker(symbol)
```
- 监控单个交易对行情
```
watchTickers([symbols])
```
- 监控多个交易对行情
```
watchOrderBook(symbol)
```
- 监控订单簿更新
```
watchOrderBookForSymbols([symbols])
```
- 监控多个订单簿更新
```
watchTrades(symbol)
```
- 监控公开交易记录
```
watchOHLCV(symbol, timeframe)
```
- 监控K线更新
```
watchBidsAsks([symbols])
```
- 监控最优买卖价

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

```
watchBalance()
```
- 监控余额更新
```
watchOrders(symbol)
```
- 监控个人订单更新
```
watchMyTrades(symbol)
```
- 监控个人交易记录更新
```
watchPositions([symbols])
```
- 监控仓位更新
```
watchPositionsForSymbol(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

标记为🔒的方法需要API密钥：

所有
```
create*
```
方法（提交订单、创建地址等）
所有
```
cancel*
```
方法（取消订单等）
所有
```
edit*
```
方法（修改订单等）
所有
```
fetchMy*
```
方法（个人交易、订单等）
```
fetchBalance
```
,
```
fetchLedger
```
,
```
fetchAccounts
```
```
withdraw
```
,
```
transfer
```
,
```
deposit
```
杠杆/保证金相关方法
仓位相关方法

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,
//   ...
// }

并非所有交易所都支持所有方法，使用前请检查：

// 检查方法是否支持
if (exchange.has['fetchOHLCV']) {
    const candles = await exchange.fetchOHLCV('BTC/USDT', '1h')
}

// 检查多个功能支持情况
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)

```
fetch*
```
- REST API方法（HTTP请求）
```
watch*
```
- WebSocket方法（实时流）
```
create*
```
- 创建资源（订单、地址等）
```
cancel*
```
- 取消资源
```
edit*
```
- 修改资源
```
set*
```
- 配置设置（杠杆、保证金模式等）
```
*Ws
```
后缀 - WebSocket变体（部分交易所）

Proxy Configuration

代理配置

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

CCXT支持HTTP、HTTPS和SOCKS代理，适用于REST与WebSocket连接。

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'

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

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

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

// 带身份验证的代理
exchange.httpProxy = 'http://user:pass@proxy-host:port'

Proxy for WebSocket

WebSocket代理

WebSocket connections also respect proxy settings:

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

WebSocket连接同样遵循代理设置：

exchange.httpsProxy = 'https://proxy:8080'
// WebSocket连接将使用该代理

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

exchange.httpProxy = 'http://localhost:8080'
try {
    await exchange.fetchTicker('BTC/USDT')
    console.log('代理可用！')
} catch (error) {
    console.error('代理连接失败:', error)
}

WebSocket-Specific Methods

WebSocket专属方法

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

*Ws

suffix:

部分交易所提供REST方法的WebSocket变体，用于更快的订单提交与管理，这些方法后缀为

*Ws

：

Trading via WebSocket

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

提交订单：

```
createOrderWs
```
- 通过WebSocket提交订单（比REST更快）
```
createLimitOrderWs
```
- 通过WebSocket提交限价订单
```
createMarketOrderWs
```
- 通过WebSocket提交市价订单
```
createLimitBuyOrderWs
```
- 通过WebSocket提交买入限价订单
```
createLimitSellOrderWs
```
- 通过WebSocket提交卖出限价订单
```
createMarketBuyOrderWs
```
- 通过WebSocket提交买入市价订单
```
createMarketSellOrderWs
```
- 通过WebSocket提交卖出市价订单
```
createStopLimitOrderWs
```
- 通过WebSocket提交止损限价订单
```
createStopMarketOrderWs
```
- 通过WebSocket提交止损市价订单
```
createStopLossOrderWs
```
- 通过WebSocket提交止损订单
```
createTakeProfitOrderWs
```
- 通过WebSocket提交止盈订单
```
createTrailingAmountOrderWs
```
- 通过WebSocket提交追踪止损订单（按金额）
```
createTrailingPercentOrderWs
```
- 通过WebSocket提交追踪止损订单（按比例）
```
createPostOnlyOrderWs
```
- 通过WebSocket提交仅挂单订单
```
createReduceOnlyOrderWs
```
- 通过WebSocket提交仅减仓订单

订单管理：

```
editOrderWs
```
- 通过WebSocket修改订单
```
cancelOrderWs
```
- 通过WebSocket取消订单（比REST更快）
```
cancelOrdersWs
```
- 通过WebSocket批量取消订单
```
cancelAllOrdersWs
```
- 通过WebSocket取消某个交易对的所有订单

数据获取：

```
fetchOrderWs
```
- 通过WebSocket获取订单
```
fetchOrdersWs
```
- 通过WebSocket获取订单
```
fetchOpenOrdersWs
```
- 通过WebSocket获取未成交订单
```
fetchClosedOrdersWs
```
- 通过WebSocket获取已成交订单
```
fetchMyTradesWs
```
- 通过WebSocket获取个人交易记录
```
fetchBalanceWs
```
- 通过WebSocket获取余额
```
fetchPositionWs
```
- 通过WebSocket获取仓位
```
fetchPositionsWs
```
- 通过WebSocket获取所有仓位
```
fetchPositionsForSymbolWs
```
- 通过WebSocket获取指定交易对的仓位
```
fetchTradingFeesWs
```
- 通过WebSocket获取交易手续费

When to Use WebSocket Methods

何时使用WebSocket方法

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

当以下情况时使用
*Ws
方法：

需要更快的订单提交（更低延迟）
已通过WebSocket连接到交易所
希望减少REST API的请求限制消耗
交易策略要求延迟低于100ms

当以下情况时使用REST方法：

需要确保执行确认
仅需一次性请求
交易所不支持对应WebSocket变体
需要详细的错误响应

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)

REST API（速度较慢，更可靠）：

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

WebSocket API（速度更快，延迟更低）：

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

Checking WebSocket Method Availability

检查WebSocket方法可用性

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

并非所有交易所都支持WebSocket交易方法：

if (exchange.has['createOrderWs']) {
    // 交易所支持WebSocket订单提交
    const order = await exchange.createOrderWs('BTC/USDT', 'limit', 'buy', 0.01, 50000)
} else {
    // 降级使用REST
    const order = await exchange.createOrder('BTC/USDT', 'limit', 'buy', 0.01, 50000)
}

Authentication

身份验证

Setting API Keys

设置API密钥

php

<?php
// During instantiation (recommended)
$exchange = new \ccxt\binance([
    'apiKey' => getenv('BINANCE_API_KEY'),
    'secret' => getenv('BINANCE_SECRET'),
    'enableRateLimit' => true
]);

// After instantiation
$exchange->apiKey = getenv('BINANCE_API_KEY');
$exchange->secret = getenv('BINANCE_SECRET');

php

<?php
// 实例化时设置（推荐）
$exchange = new \ccxt\binance([
    'apiKey' => getenv('BINANCE_API_KEY'),
    'secret' => getenv('BINANCE_SECRET'),
    'enableRateLimit' => true
]);

// 实例化后设置
$exchange->apiKey = getenv('BINANCE_API_KEY');
$exchange->secret = getenv('BINANCE_SECRET');

Testing Authentication

测试身份验证

php

try {
    $balance = $exchange->fetch_balance();
    print_r('Authentication successful!');
} catch (\ccxt\AuthenticationError $e) {
    print_r('Invalid API credentials');
}

php

try {
    $balance = $exchange->fetch_balance();
    print_r('身份验证成功！');
} catch (\ccxt\AuthenticationError $e) {
    print_r('API凭据无效');
}

Error Handling

错误处理

Exception Hierarchy

异常层级

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

BaseError
├─ NetworkError（可恢复 - 可重试）
│  ├─ RequestTimeout
│  ├─ ExchangeNotAvailable
│  ├─ RateLimitExceeded
│  └─ DDoSProtection
└─ ExchangeError（不可恢复 - 请勿重试）
   ├─ AuthenticationError
   ├─ InsufficientFunds
   ├─ InvalidOrder
   └─ NotSupported

Basic Error Handling

基础错误处理

php

<?php
try {
    $ticker = $exchange->fetch_ticker('BTC/USDT');
} catch (\ccxt\NetworkError $e) {
    echo 'Network error - retry: ' . $e->getMessage();
} catch (\ccxt\ExchangeError $e) {
    echo 'Exchange error - do not retry: ' . $e->getMessage();
} catch (\Exception $e) {
    echo 'Unknown error: ' . $e->getMessage();
}

php

<?php
try {
    $ticker = $exchange->fetch_ticker('BTC/USDT');
} catch (\ccxt\NetworkError $e) {
    echo '网络错误 - 可重试: ' . $e->getMessage();
} catch (\ccxt\ExchangeError $e) {
    echo '交易所错误 - 请勿重试: ' . $e->getMessage();
} catch (\Exception $e) {
    echo '未知错误: ' . $e->getMessage();
}

Specific Exception Handling

特定异常处理

php

<?php
try {
    $order = $exchange->create_order('BTC/USDT', 'limit', 'buy', 0.01, 50000);
} catch (\ccxt\InsufficientFunds $e) {
    echo 'Not enough balance';
} catch (\ccxt\InvalidOrder $e) {
    echo 'Invalid order parameters';
} catch (\ccxt\RateLimitExceeded $e) {
    echo 'Rate limit hit - wait before retrying';
    sleep(1);  // Wait 1 second
} catch (\ccxt\AuthenticationError $e) {
    echo 'Check your API credentials';
}

php

<?php
try {
    $order = $exchange->create_order('BTC/USDT', 'limit', 'buy', 0.01, 50000);
} catch (\ccxt\InsufficientFunds $e) {
    echo '余额不足';
} catch (\ccxt\InvalidOrder $e) {
    echo '订单参数无效';
} catch (\ccxt\RateLimitExceeded $e) {
    echo '请求超限 - 请等待后重试';
    sleep(1);  // 等待1秒
} catch (\ccxt\AuthenticationError $e) {
    echo '请检查API凭据';
}

Retry Logic for Network Errors

网络错误重试逻辑

php

<?php
function fetch_with_retry($exchange, $max_retries = 3) {
    for ($i = 0; $i < $max_retries; $i++) {
        try {
            return $exchange->fetch_ticker('BTC/USDT');
        } catch (\ccxt\NetworkError $e) {
            if ($i < $max_retries - 1) {
                echo "Retry " . ($i + 1) . "/$max_retries\n";
                sleep(1 * ($i + 1));  // Exponential backoff
            } else {
                throw $e;
            }
        }
    }
}

php

<?php
function fetch_with_retry($exchange, $max_retries = 3) {
    for ($i = 0; $i < $max_retries; $i++) {
        try {
            return $exchange->fetch_ticker('BTC/USDT');
        } catch (\ccxt\NetworkError $e) {
            if ($i < $max_retries - 1) {
                echo "重试 " . ($i + 1) . "/$max_retries\n";
                sleep(1 * ($i + 1));  // 指数退避
            } else {
                throw $e;
            }
        }
    }
}

Rate Limiting

请求限制

Built-in Rate Limiter (Recommended)

内置请求限制器（推荐）

php

$exchange = new \ccxt\binance([
    'enableRateLimit' => true  // Automatically throttles requests
]);

php

$exchange = new \ccxt\binance([
    'enableRateLimit' => true  // 自动限流
]);

Manual Delays

手动延迟

php

$exchange->fetch_ticker('BTC/USDT');
usleep($exchange->rateLimit * 1000);  // Convert ms to microseconds
$exchange->fetch_ticker('ETH/USDT');

php

$exchange->fetch_ticker('BTC/USDT');
usleep($exchange->rateLimit * 1000);  // 将毫秒转换为微秒
$exchange->fetch_ticker('ETH/USDT');

Checking Rate Limit

检查请求限制

php

print_r($exchange->rateLimit);  // Milliseconds between requests

php

print_r($exchange->rateLimit);  // 请求间隔（毫秒）

Common Pitfalls

常见陷阱

Forgetting Timezone Setting

忘记设置时区

php

// Wrong - will cause errors
<?php
require_once 'vendor/autoload.php';
$exchange = new \ccxt\binance();  // ERROR!

// Correct
<?php
date_default_timezone_set('UTC');  // Required!
require_once 'vendor/autoload.php';
$exchange = new \ccxt\binance();

php

// 错误写法 - 会导致错误
<?php
require_once 'vendor/autoload.php';
$exchange = new \ccxt\binance();  // 错误！

// 正确写法
<?php
date_default_timezone_set('UTC');  // 必须设置！
require_once 'vendor/autoload.php';
$exchange = new \ccxt\binance();

Wrong Namespace Format

命名空间格式错误

php

// Wrong - missing leading backslash
$exchange = new ccxt\binance();  // May fail!

// Correct
$exchange = new \ccxt\binance();  // Leading backslash!

php

// 错误写法 - 缺少前导反斜杠
$exchange = new ccxt\binance();  // 可能失败！

// 正确写法
$exchange = new \ccxt\binance();  // 必须带前导反斜杠！

Using REST for Real-time Monitoring

使用REST进行实时监控

php

// Wrong - wastes rate limits
while (true) {
    $ticker = $exchange->fetch_ticker('BTC/USDT');  // REST
    print_r($ticker['last']);
    sleep(1);
}

// Correct - use WebSocket
use function React\Async\await;
$exchange = new \ccxt\pro\binance();
while (true) {
    $ticker = await($exchange->watch_ticker('BTC/USDT'));  // WebSocket
    print_r($ticker['last']);
}

php

// 错误写法 - 浪费请求限额
while (true) {
    $ticker = $exchange->fetch_ticker('BTC/USDT');  // REST方式
    print_r($ticker['last']);
    sleep(1);
}

// 正确写法 - 使用WebSocket
use function React\Async\await;
$exchange = new \ccxt\pro\binance();
while (true) {
    $ticker = await($exchange->watch_ticker('BTC/USDT'));  // WebSocket方式
    print_r($ticker['last']);
}

Not Closing WebSocket Connections

未关闭WebSocket连接

php

// Wrong - memory leak
$exchange = new \ccxt\pro\binance();
$ticker = await($exchange->watch_ticker('BTC/USDT'));
// Forgot to close!

// Correct
$exchange = new \ccxt\pro\binance();
try {
    while (true) {
        $ticker = await($exchange->watch_ticker('BTC/USDT'));
    }
} finally {
    await($exchange->close());
}

php

// 错误写法 - 内存泄漏
$exchange = new \ccxt\pro\binance();
$ticker = await($exchange->watch_ticker('BTC/USDT'));
// 忘记关闭连接！

// 正确写法
$exchange = new \ccxt\pro\binance();
try {
    while (true) {
        $ticker = await($exchange->watch_ticker('BTC/USDT'));
    }
} finally {
    await($exchange->close());
}

Not Checking PHP Extensions

未检查PHP扩展

php

// Check required extensions before running
<?php
$required = ['curl', 'mbstring', 'iconv', 'gmp'];
foreach ($required as $ext) {
    if (!extension_loaded($ext)) {
        die("Error: $ext extension is not loaded\n");
    }
}

php

// 运行前检查所需扩展
<?php
$required = ['curl', 'mbstring', 'iconv', 'gmp'];
foreach ($required as $ext) {
    if (!extension_loaded($ext)) {
        die("错误: 未加载$ext扩展\n");
    }
}

Troubleshooting

故障排除

Common Issues

常见问题

1. "date_default_timezone_get(): Invalid date.timezone"

Solution: Add
```
date_default_timezone_set('UTC');
```
at the top

2. "Class 'ccxt\binance' not found"

Solution: Run
```
composer require ccxt/ccxt
```
Check you're using
```
\ccxt\binance
```
with leading backslash

3. "RateLimitExceeded"

Solution: Enable rate limiter:
```
'enableRateLimit' => true
```

4. "AuthenticationError"

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

5. "InvalidNonce"

Solution: Sync system clock
Use only one exchange instance per API key

6. Missing PHP extensions

Solution: Install required extensions:
- Ubuntu/Debian:
```
apt-get install php-curl php-mbstring php-gmp
```
- macOS: Usually pre-installed
- Windows: Enable in php.ini

1. "date_default_timezone_get(): Invalid date.timezone"

解决方案：在代码顶部添加
```
date_default_timezone_set('UTC');
```

2. "Class 'ccxt\binance' not found"

解决方案：执行
```
composer require ccxt/ccxt
```
确保使用带前导反斜杠的
```
\ccxt\binance
```

3. "RateLimitExceeded"

解决方案：启用请求限制器：
```
'enableRateLimit' => true
```

4. "AuthenticationError"

解决方案：检查API密钥与密钥
验证API密钥在交易所的权限
检查系统时钟是否同步

5. "InvalidNonce"

解决方案：同步系统时钟
每个API密钥仅使用一个交易所实例

6. 缺少PHP扩展

解决方案：安装所需扩展：
- Ubuntu/Debian:
```
apt-get install php-curl php-mbstring php-gmp
```
- macOS: 通常已预装
- Windows: 在php.ini中启用

Debugging

调试

php

// Enable verbose logging
$exchange->verbose = true;

// Check exchange capabilities
print_r($exchange->has);
// Array(
//   'fetchTicker' => true,
//   'fetchOrderBook' => true,
//   'createOrder' => true,
//   ...
// )

// Check market information
print_r($exchange->markets['BTC/USDT']);

// Check last request/response
print_r($exchange->last_http_response);
print_r($exchange->last_json_response);

php

// 启用详细日志
$exchange->verbose = true;

// 检查交易所功能支持
print_r($exchange->has);
// Array(
//   'fetchTicker' => true,
//   'fetchOrderBook' => true,
//   'createOrder' => true,
//   ...
// )

// 检查市场信息
print_r($exchange->markets['BTC/USDT']);

// 检查最后一次请求/响应
print_r($exchange->last_http_response);
print_r($exchange->last_json_response);