Python用CCXT

Python プロジェクトで仮想通貨取引所統合を行うためのCCXT使用ガイドです。

インストール

REST API（標準）

pip install ccxt

WebSocket API（リアルタイム、ccxt.pro）

pip install ccxt

オプションのパフォーマンス向上

pip install orjson      # より高速なJSON解析
pip install coincurve   # より高速なECDSA署名（45ms → 0.05ms）

REST APIとWebSocket APIは両方とも同じパッケージに含まれています。

クイックスタート

REST API - 同期処理

import ccxt

exchange = ccxt.binance()
exchange.load_markets()
ticker = exchange.fetch_ticker('BTC/USDT')
print(ticker)

REST API - 非同期処理

import asyncio
import ccxt.async_support as ccxt

async def main():
    exchange = ccxt.binance()
    await exchange.load_markets()
    ticker = await exchange.fetch_ticker('BTC/USDT')
    print(ticker)
    await exchange.close()  # 重要！

asyncio.run(main())

WebSocket API - リアルタイム更新

import asyncio
import ccxt.pro as ccxtpro

async def main():
    exchange = ccxtpro.binance()
    while True:
        ticker = await exchange.watch_ticker('BTC/USDT')
        print(ticker)  # ライブ更新！
    await exchange.close()

asyncio.run(main())

REST vs WebSocket

インポート	REST向け	WebSocket向け
同期	import ccxt	(WebSocketは非同期が必須)
非同期	import ccxt.async_support as ccxt	import ccxt.pro as ccxtpro

機能	REST API	WebSocket API
用途	ワンタイムクエリ、注文発注	リアルタイムモニタリング、ライブ価格フィード
メソッドの接頭辞	fetch_* (fetch_ticker, fetch_order_book)	watch_* (watch_ticker, watch_order_book)
速度	より遅い（HTTPリクエスト/レスポンス）	より高速（永続的な接続）
レート制限	厳しい（1-2 req/秒）	より緩い（連続ストリーム）
最適な用途	取引、アカウント管理	価格モニタリング、アービトラージ検出

REST を使用する場合：

• 注文を発注する
• アカウント残高を取得する
• ワンタイムのデータクエリ
• 注文管理（キャンセル、注文取得）

WebSocket を使用する場合：

• リアルタイムの価格モニタリング
• ライブオーダーブック更新
• アービトラージ検出
• ライブ更新でのポートフォリオ追跡

Exchange インスタンスの作成

REST API - 同期処理

import ccxt

# パブリック API（認証なし）
exchange = ccxt.binance({
    'enableRateLimit': True  # 推奨！
})

# プライベート API（認証あり）
exchange = ccxt.binance({
    'apiKey': 'YOUR_API_KEY',
    'secret': 'YOUR_SECRET',
    'enableRateLimit': True
})

REST API - 非同期処理

import ccxt.async_support as ccxt

exchange = ccxt.binance({
    'apiKey': 'YOUR_API_KEY',
    'secret': 'YOUR_SECRET',
    'enableRateLimit': True
})

# 終了時は必ずクローズ
await exchange.close()

WebSocket API

import ccxt.pro as ccxtpro

# パブリック WebSocket
exchange = ccxtpro.binance()

# プライベート WebSocket（認証あり）
exchange = ccxtpro.binance({
    'apiKey': 'YOUR_API_KEY',
    'secret': 'YOUR_SECRET'
})

# 終了時は必ずクローズ
await exchange.close()

一般的なREST操作

マーケットのロード

# すべての利用可能な取引ペアをロード
exchange.load_markets()

# マーケット情報にアクセス
btc_market = exchange.market('BTC/USDT')
print(btc_market['limits']['amount']['min'])  # 最小注文量

ティッカーの取得

# シングルティッカー
ticker = exchange.fetch_ticker('BTC/USDT')
print(ticker['last'])      # 最終価格
print(ticker['bid'])       # 最高買値
print(ticker['ask'])       # 最安売値
print(ticker['volume'])    # 24時間出来高

# 複数ティッカー（サポートされている場合）
tickers = exchange.fetch_tickers(['BTC/USDT', 'ETH/USDT'])

オーダーブックの取得

# 完全なオーダーブック
orderbook = exchange.fetch_order_book('BTC/USDT')
print(orderbook['bids'][0])  # [価格、量]
print(orderbook['asks'][0])  # [価格、量]

# 制限付きの深さ
orderbook = exchange.fetch_order_book('BTC/USDT', 5)  # 上位5レベル

注文の作成

リミット注文

# 買いリミット注文
order = exchange.create_limit_buy_order('BTC/USDT', 0.01, 50000)
print(order['id'])

# 売りリミット注文
order = exchange.create_limit_sell_order('BTC/USDT', 0.01, 60000)

# 汎用リミット注文
order = exchange.create_order('BTC/USDT', 'limit', 'buy', 0.01, 50000)

マーケット注文

# 買いマーケット注文
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)

残高の取得

balance = exchange.fetch_balance()
print(balance['BTC']['free'])   # 利用可能な残高
print(balance['BTC']['used'])   # 注文中の残高
print(balance['BTC']['total'])  # 合計残高

注文の取得

# オープン注文
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')

トレードの取得

# 最近のパブリックトレード
trades = exchange.fetch_trades('BTC/USDT', limit=10)

# あなたのトレード（認証が必須）
my_trades = exchange.fetch_my_trades('BTC/USDT')

注文のキャンセル

# 単一注文のキャンセル
exchange.cancel_order(order_id, 'BTC/USDT')

# シンボルのすべての注文をキャンセル
exchange.cancel_all_orders('BTC/USDT')

WebSocket 操作（リアルタイム）

ティッカーのウォッチ（ライブ価格更新）

import asyncio
import ccxt.pro as ccxtpro

async def main():
    exchange = ccxtpro.binance()
    while True:
        ticker = await exchange.watch_ticker('BTC/USDT')
        print(ticker['last'], ticker['timestamp'])
    await exchange.close()

asyncio.run(main())

オーダーブックのウォッチ（ライブ深さ更新）

async def main():
    exchange = ccxtpro.binance()
    while True:
        orderbook = await exchange.watch_order_book('BTC/USDT')
        print('Best bid:', orderbook['bids'][0])
        print('Best ask:', orderbook['asks'][0])
    await exchange.close()

asyncio.run(main())

トレードのウォッチ（ライブトレードストリーム）

async def main():
    exchange = ccxtpro.binance()
    while True:
        trades = await exchange.watch_trades('BTC/USDT')
        for trade in trades:
            print(trade['price'], trade['amount'], trade['side'])
    await exchange.close()

asyncio.run(main())

あなたの注文のウォッチ（ライブ注文更新）

async def main():
    exchange = ccxtpro.binance({
        'apiKey': 'YOUR_API_KEY',
        'secret': 'YOUR_SECRET'
    })
    while True:
        orders = await exchange.watch_orders('BTC/USDT')
        for order in orders:
            print(order['id'], order['status'], order['filled'])
    await exchange.close()

asyncio.run(main())

残高のウォッチ（ライブ残高更新）

async def main():
    exchange = ccxtpro.binance({
        'apiKey': 'YOUR_API_KEY',
        'secret': 'YOUR_SECRET'
    })
    while True:
        balance = await exchange.watch_balance()
        print('BTC:', balance['BTC'])
        print('USDT:', balance['USDT'])
    await exchange.close()

asyncio.run(main())

複数シンボルのウォッチ

async def main():
    exchange = ccxtpro.binance()
    symbols = ['BTC/USDT', 'ETH/USDT', 'SOL/USDT']

    while True:
        # すべてのシンボルを同時にウォッチ
        tickers = await exchange.watch_tickers(symbols)
        for symbol, ticker in tickers.items():
            print(symbol, ticker['last'])
    await exchange.close()

asyncio.run(main())

完全なメソッドリファレンス

マーケットデータメソッド

ティッカーと価格

• fetchTicker(symbol) - 1つのシンボルのティッカーを取得
• fetchTickers([symbols]) - 複数のティッカーを一度に取得
• fetchBidsAsks([symbols]) - 複数シンボルの最高買値/最安売値を取得
• fetchLastPrices([symbols]) - 最終価格を取得
• fetchMarkPrices([symbols]) - マーク価格を取得（デリバティブ）

オーダーブック

• fetchOrderBook(symbol, limit) - オーダーブックを取得
• fetchOrderBooks([symbols]) - 複数のオーダーブックを取得
• fetchL2OrderBook(symbol) - レベル2オーダーブックを取得
• fetchL3OrderBook(symbol) - レベル3オーダーブックを取得（サポートされている場合）

トレード

• fetchTrades(symbol, since, limit) - パブリックトレードを取得
• fetchMyTrades(symbol, since, limit) - あなたのトレードを取得（認証が必須）
• fetchOrderTrades(orderId, symbol) - 特定の注文のトレードを取得

OHLCV（ローソク足）

• fetchOHLCV(symbol, timeframe, since, limit) - ローソク足データを取得
• fetchIndexOHLCV(symbol, timeframe) - インデックス価格OHLCVを取得
• fetchMarkOHLCV(symbol, timeframe) - マーク価格OHLCVを取得
• fetchPremiumIndexOHLCV(symbol, timeframe) - プレミアムインデックスOHLCVを取得

アカウントと残高

• 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) - 入金と出金の両方を取得

トレーディングメソッド

注文の作成

• 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注文

注文の管理

• 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) - 注文を変更

マージンとレバレッジ

• 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) - マージンモードを取得

デリバティブとフューチャーズ

ポジション

• fetchPosition(symbol) - 単一ポジションを取得
• fetchPositions([symbols]) - すべてのポジションを取得
• fetchPositionsForSymbol(symbol) - シンボルのポジションを取得
• fetchPositionHistory(symbol, since, limit) - ポジション履歴
• fetchPositionsHistory(symbols, since, limit) - 複数ポジション履歴
• fetchPositionMode(symbol) - ポジションモードを取得（ワンウェイ/ヘッジ）
• setPositionMode(hedged, symbol) - ポジションモードを設定
• closePosition(symbol, side) - ポジションをクローズ
• closeAllPositions() - すべてのポジションをクローズ

ファンディングと決済

• fetchFundingRate(symbol) - 現在のファンディングレート
• fetchFundingRates([symbols]) - 複数のファンディングレート
• fetchFundingRateHistory(symbol, since, limit) - ファンディングレート履歴
• fetchFundingHistory(symbol, since, limit) - あなたのファンディング支払い
• fetchFundingInterval(symbol) - ファンディング間隔
• fetchSettlementHistory(symbol, since, limit) - 決済履歴
• fetchMySettlementHistory(symbol, since, limit) - あなたの決済履歴

オープンインタレストとリクイデーション

• fetchOpenInterest(symbol) - シンボルのオープンインタレスト
• fetchOpenInterests([symbols]) - 複数のオープンインタレスト
• fetchOpenInterestHistory(symbol, timeframe, since, limit) - OI履歴
• fetchLiquidations(symbol, since, limit) - パブリックリクイデーション
• fetchMyLiquidations(symbol, since, limit) - あなたのリクイデーション

オプション

• fetchOption(symbol) - オプション情報を取得
• fetchOptionChain(code) - オプションチェーンを取得
• fetchGreeks(symbol) - オプションのギリシャ文字を取得
• fetchVolatilityHistory(code, since, limit) - ボラティリティ履歴
• fetchUnderlyingAssets() - 原資産を取得

手数料と制限

• fetchTradingFee(symbol) - シンボルの取引手数料
• fetchTradingFees([symbols]) - 複数シンボルの取引手数料
• fetchTradingLimits([symbols]) - 取引制限
• fetchTransactionFee(code) - トランザクション/出金手数料
• fetchTransactionFees([codes]) - 複数のトランザクション手数料
• fetchDepositWithdrawFee(code) - 入出金手数料
• fetchDepositWithdrawFees([codes]) - 複数の入出金手数料

入金と出金

• 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(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) - 変換履歴

マーケット情報

• fetchMarkets() - すべてのマーケットを取得
• fetchCurrencies() - すべての通貨を取得
• fetchTime() - 取引所のサーバー時刻を取得
• fetchStatus() - 取引所のステータスを取得
• fetchBorrowInterest(code, symbol, since, limit) - 支払った借入利息
• fetchLongShortRatio(symbol, timeframe, since, limit) - ロング/ショート比
• fetchLongShortRatioHistory(symbol, timeframe, since, limit) - L/S比履歴

WebSocket メソッド (ccxt.pro)

すべてのRESTメソッドは watch* プレフィックスを持つWebSocket同等メソッドを持ちます：

リアルタイムマーケットデータ

• watchTicker(symbol) - 単一ティッカーをウォッチ
• watchTickers([symbols]) - 複数のティッカーをウォッチ
• watchOrderBook(symbol) - オーダーブック更新をウォッチ
• watchOrderBookForSymbols([symbols]) - 複数のオーダーブックをウォッチ
• watchTrades(symbol) - パブリックトレードをウォッチ
• watchOHLCV(symbol, timeframe) - ローソク足更新をウォッチ
• watchBidsAsks([symbols]) - 最高買値/最安売値をウォッチ

リアルタイムアカウントデータ（認証が必須）

• watchBalance() - 残高更新をウォッチ
• watchOrders(symbol) - あなたの注文更新をウォッチ
• watchMyTrades(symbol) - あなたのトレード更新をウォッチ
• watchPositions([symbols]) - ポジション更新をウォッチ
• watchPositionsForSymbol(symbol) - シンボルのポジションをウォッチ

認証が必須

🔒 としてマークされたメソッドはAPI認証情報が必須です：

• すべての create* メソッド（注文作成、アドレス作成）
• すべての cancel* メソッド（注文キャンセル）
• すべての edit* メソッド（注文変更）
• すべての fetchMy* メソッド（あなたのトレード、注文）
• fetchBalance, fetchLedger, fetchAccounts
• withdraw, transfer, deposit
• マージン/レバレッジメソッド
• ポジションメソッド
• watchBalance, watchOrders, watchMyTrades, watchPositions

メソッド可用性の確認

すべての取引所がすべてのメソッドをサポートしているわけではありません。使用前に確認してください：

// メソッドがサポートされているか確認
if (exchange.has['fetchOHLCV']) {
    const candles = await exchange.fetchOHLCV('BTC/USDT', '1h')
}

// 複数の機能を確認
console.log(exchange.has)
// {
//   fetchTicker: true,
//   fetchOHLCV: true,
//   fetchMyTrades: true,
//   fetchPositions: false,
//   ...
// }

メソッド命名規約

• fetch* - REST APIメソッド（HTTPリクエスト）
• watch* - WebSocketメソッド（リアルタイムストリーム）
• create* - 新しいリソースを作成（注文、アドレス）
• cancel* - 既存のリソースをキャンセル
• edit* - 既存のリソースを変更
• set* - 設定を構成（レバレッジ、マージンモード）
• *Ws サフィックス - WebSocketバリアント（一部の取引所）

プロキシ設定

CCXTはHTTP、HTTPS、SOCKSプロキシをREST APIとWebSocket接続の両方でサポートしています。

プロキシの設定

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

WebSocket のプロキシ

WebSocket接続もプロキシ設定を遵守します：

exchange.httpsProxy = 'https://proxy:8080'
// WebSocket接続はこのプロキシを使用します

プロキシ接続のテスト

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

WebSocket固有のメソッド

一部の取引所では、RESTメソッドのWebSocketバリアントが提供され、より高速な注文発注と管理が可能です。これらは *Ws サフィックスを使用します：

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経由で取引手数料を取得

WebSocket メソッドを使用する場合

*Ws メソッドを使用する場合：

• より高速な注文発注が必要（低レイテンシ）
• すでにWebSocket経由で接続している
• REST APIレート制限の使用を減らしたい
• 取引戦略が100ms以下のレイテンシを必要とする

RESTメソッドを使用する場合：

• 確実な実行確認が必要
• ワンオフリクエストを行う
• 取引所がWebSocketバリアントをサポートしていない
• 詳細なエラーレスポンスが必要

例：注文発注の比較

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)

WebSocket メソッド可用性の確認

すべての取引所が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)
}

認証

API キーの設定

import os

# インスタンス化時に設定（推奨）
exchange = ccxt.binance({
    'apiKey': os.environ.get('BINANCE_API_KEY'),
    'secret': os.environ.get('BINANCE_SECRET'),
    'enableRateLimit': True
})

# インスタンス化後に設定
exchange.apiKey = os.environ.get('BINANCE_API_KEY')
exchange.secret = os.environ.get('BINANCE_SECRET')

認証のテスト

try:
    balance = exchange.fetch_balance()
    print('認証成功！')
except ccxt.AuthenticationError:
    print('無効なAPI認証情報')

エラーハンドリング

例外の階層

BaseError
├─ NetworkError（回復可能 - リトライ）
│  ├─ RequestTimeout
│  ├─ ExchangeNotAvailable
│  ├─ RateLimitExceeded
│  └─ DDoSProtection
└─ ExchangeError（回復不可 - リトライしない）
   ├─ AuthenticationError
   ├─ InsufficientFunds
   ├─ InvalidOrder
   └─ NotSupported

基本的なエラーハンドリング

import ccxt

try:
    ticker = exchange.fetch_ticker('BTC/USDT')
except ccxt.NetworkError as e:
    print('ネットワークエラー - リトライ:', str(e))
except ccxt.ExchangeError as e:
    print('取引所エラー - リトライしない:', str(e))
except Exception as e:
    print('不明なエラー:', str(e))

特定の例外ハンドリング

try:
    order = exchange.create_order('BTC/USDT', 'limit', 'buy', 0.01, 50000)
except ccxt.InsufficientFunds:
    print('残高不足')
except ccxt.InvalidOrder:
    print('無効な注文パラメータ')
except ccxt.RateLimitExceeded:
    print('レート制限に達しました - リトライ前に待機')
    exchange.sleep(1000)  # 1秒待機
except ccxt.AuthenticationError:
    print('APIクレデンシャルを確認してください')

ネットワークエラーのリトライロジック

def fetch_with_retry(max_retries=3):
    for i in range(max_retries):
        try:
            return exchange.fetch_ticker('BTC/USDT')
        except ccxt.NetworkError:
            if i < max_retries - 1:
                print(f'リトライ {i + 1}/{max_retries}')
                exchange.sleep(1000 * (i + 1))  # 指数バックオフ
            else:
                raise

非同期 vs 同期

同期を使用する場合

• シンプルなスクリプト
• 単一の取引所操作
• Jupyter notebook
• クイックテスト

非同期を使用する場合

• 複数の同時操作
• WebSocket接続（必須）
• 高パフォーマンスな取引ボット
• 複数取引所のモニタリング

同期の例

import ccxt

exchange = ccxt.binance({'enableRateLimit': True})
ticker = exchange.fetch_ticker('BTC/USDT')
print(ticker['last'])

非同期の例

import asyncio
import ccxt.async_support as ccxt

async def main():
    exchange = ccxt.binance({'enableRateLimit': True})
    ticker = await exchange.fetch_ticker('BTC/USDT')
    print(ticker['last'])
    await exchange.close()

asyncio.run(main())

複数取引所の非同期

async def fetch_all():
    exchanges = [
        ccxt.binance({'enableRateLimit': True}),
        ccxt.coinbase({'enableRateLimit': True}),
        ccxt.kraken({'enableRateLimit': True})
    ]

    # 同時に取得
    tasks = [ex.fetch_ticker('BTC/USDT') for ex in exchanges]
    tickers = await asyncio.gather(*tasks, return_exceptions=True)

    for ex, ticker in zip(exchanges, tickers):
        if isinstance(ticker, Exception):
            print(f'{ex.id}: エラー - {ticker}')
        else:
            print(f'{ex.id}: ${ticker["last"]}')
        await ex.close()

asyncio.run(fetch_all())

レート制限

組み込みレート制限機能（推奨）

exchange = ccxt.binance({
    'enableRateLimit': True  # 自動的にリクエストを調整
})

手動遅延

exchange.fetch_ticker('BTC/USDT')
exchange.sleep(1000)  # 1秒待機（ミリ秒）
exchange.fetch_ticker('ETH/USDT')

レート制限の確認

print(exchange.rateLimit)  # リクエスト間のミリ秒

一般的な落とし穴

非同期モードで await を忘れる

# 誤り - コルーチンを返し、データではない
async def wrong():
    ticker = exchange.fetch_ticker('BTC/USDT')  # awaitなし！
    print(ticker['last'])  # エラー

# 正しい
async def correct():
    ticker = await exchange.fetch_ticker('BTC/USDT')
    print(ticker['last'])  # 動作！

WebSocket に同期を使用する

# 誤り - WebSocketは非同期が必須
import ccxt.pro as ccxtpro
exchange = ccxtpro.binance()
ticker = exchange.watch_ticker('BTC/USDT')  # エラー: awaitが必須！

# 正しい
import asyncio
import ccxt.pro as ccxtpro

async def main():
    exchange = ccxtpro.binance()
    ticker = await exchange.watch_ticker('BTC/USDT')
    await exchange.close()

asyncio.run(main())

非同期 exchange をクローズし忘れる

# 誤り - リソースリーク
async def wrong():
    exchange = ccxt.binance()
    await exchange.fetch_ticker('BTC/USDT')
    # クローズを忘れた！

# 正しい
async def correct():
    exchange = ccxt.binance()
    try:
        await exchange.fetch_ticker('BTC/USDT')
    finally:
        await exchange.close()

非同期コード内で同期を使用する

# 誤り - イベントループをブロック
async def wrong():
    exchange = ccxt.binance()  # 同期インポート！
    ticker = exchange.fetch_ticker('BTC/USDT')  # ブロッキング！

# 正しい
import ccxt.async_support as ccxt

async def correct():
    exchange = ccxt.binance()
    ticker = await exchange.fetch_ticker('BTC/USDT')
    await exchange.close()

リアルタイムモニタリングに REST を使用する

# 誤り - レート制限を無駄にする
while True:
    ticker = exchange.fetch_ticker('BTC/USDT')  # REST
    print(ticker['last'])
    exchange.sleep(1000)

# 正しい - WebSocket を使用
import ccxt.pro as ccxtpro

async def correct():
    exchange = ccxtpro.binance()
    while True:
        ticker = await exchange.watch_ticker('BTC/USDT')  # WebSocket
        print(ticker['last'])
    await exchange.close()

トラブルシューティング

一般的な問題

1. "ModuleNotFoundError: No module named 'ccxt'"

• 解決策: pip install ccxt を実行

2. "RateLimitExceeded"

• 解決策: レート制限を有効にする: 'enableRateLimit': True
• または、リクエスト間に手動遅延を追加

3. "AuthenticationError"

• 解決策: API キーとシークレットを確認
• 取引所でAPI キーの権限を確認
• システムクロックが同期していることを確認（NTP を使用）

4. "InvalidNonce"

• 解決策: システムクロックを同期
• 1つのAPI キーで複数の exchange インスタンスを使用しない

5. "InsufficientFunds"

• 解決策: 利用可能な残高を確認（balance['BTC']['free']）
• 取引手数料を考慮

6. "ExchangeNotAvailable"

• 解決策: 取引所のステータス/メンテナンスを確認
• 遅延後にリトライ

**7. SSL/証明書エラー

• 解決策: certifi をアップグレード: pip install --upgrade certifi

**8. パフォーマンスが遅い

• 解決策: パフォーマンス向上をインストール：
  • pip install orjson（高速JSON）
  • pip install coincurve（高速署名）

デバッグ

# 詳細ログを有効にする
exchange.verbose = True

# 取引所の機能を確認
print(exchange.has)
# {
#   'fetchTicker': True,
#   'fetchOrderBook': True,
#   'createOrder': True,
#   ...
# }

# マーケット情報を確認
print(exchange.markets['BTC/USDT'])

# 最後のリクエスト/レスポンスを確認
print(exchange.last_http_response)
print(exchange.last_json_response)

さらに詳しく

• CCXT マニュアル
• CCXT Pro ドキュメント
• サポートされている取引所
• GitHub リポジトリ