CCXT 2026: Giao diện giao dịch tiền điện tử đa nền tảng thống nhất 100+ sàn giao dịch — Hướng dẫn tích hợp bot giao dịch

pip install ccxt

# Cài đặt CCXT cho JavaScript (Node.js)
npm install ccxt

# Cài đặt CCXT cho PHP
composer require ccxt/ccxt

import ccxt

# Danh sách tất cả các sàn giao dịch hỗ trợ
print(f"Số lượng sàn giao dịch hỗ trợ: {len(ccxt.exchanges)}")
print("10 sàn giao dịch đầu tiên:", ccxt.exchanges[:10])

# Kiểm tra xem một sàn giao dịch có được hỗ trợ hay không
print("Binance được hỗ trợ:", 'binance' in ccxt.exchanges)
print("Coinbase được hỗ trợ:", 'coinbase' in ccxt.exchanges)

# Load một sàn giao dịch cụ thể với cấu hình
exchange = ccxt.binance({
    'enableRateLimit': True,
    'options': {
        'defaultType': 'spot',
        'adjustForTimeDifference': True,
    }
})

# Load thị trường để填充内容超出限制，已停止生成。如果您需要更多帮助，请告诉我具体需求。
---
## Kiến Trúc API Hợp Tác: Một Giao diện, Mọi Sàn Giao Dịch

Giá trị cốt lõi của CCXT nằm ở giao diện API hợp tác. Thư viện này sao chép các phương thức API bản địa của mỗi sàn giao dịch thành một tập hợp chuẩn hóa của phương thức. Điều này có nghĩa là `fetch_ticker('BTC/USDT')` hoạt động giống nhau trên Binance, Kraken, Coinbase hoặc bất kỳ sàn giao dịch nào được hỗ trợ.

### Phương Thức Dữ Liệu Thị Trường

API dữ liệu thị trường cung cấp tất cả những gì trader định lượng cần:

```python
import ccxt

# Khởi tạo sàn giao dịch
binance = ccxt.binance()

# Lấy thông tin ticker (bid, ask, giá cuối cùng, khối lượng)
ticker = binance.fetch_ticker('BTC/USDT')
print(f"Giá BTC/USDT cuối cùng: {ticker['last']}")
print(f"Khối lượng 24 giờ: {ticker['baseVolume']}")
print(f"% Biến động 24 giờ: {ticker['percentage']}%")

# Lấy biểu đồ lệnh (bids và asks)
orderbook = binance.fetch_order_book('BTC/USDT', limit=10)
print(f"Best Bid: {orderbook['bids'][0]}")
print(f"Best Ask: {orderbook['asks'][0]}")

# Lấy lịch sử giao dịch gần đây
trades = binance.fetch_trades('BTC/USDT', limit=50)
print(f"Số lượng giao dịch gần đây: {len(trades)}")

# Lấy nến OHLCV cho phân tích kỹ thuật
ohlcv = binance.fetch_ohlcv('BTC/USDT', timeframe='1h', limit=100)
print(f"Điểm dữ liệu OHLCV: {len(ohlcv)}")
# Định dạng: [thời gian, mở, cao nhất, thấp nhất, đóng, khối lượng]

import ccxt

# Khởi tạo với thông tin API để giao dịch
exchange = ccxt.binance({
    'apiKey': 'YOUR_API_KEY',
    'secret': 'YOUR_SECRET_KEY',
    'enableRateLimit': True,  # Quan trọng: ngăn chặn bị cấm IP
})

# Tạo lệnh mua thị trường
market_order = exchange.create_market_buy_order('BTC/USDT', amount=0.001)
print(f"Lệnh mua thị trường đã được thực hiện: {market_order['filled']}")
print(f"Giá trung bình: {market_order['average']}")

# Tạo lệnh bán giới hạn
limit_order = exchange.create_limit_sell_order(
    symbol='BTC/USDT',
    amount=0.001,
    price=85000
)
print(f"Mã lệnh bán giới hạn: {limit_order['id']}")
print(f"Tình trạng: {limit_order['status']}")  # 'open', 'closed', 'canceled'

# Kiểm tra tình trạng lệnh
order_status = exchange.fetch_order(limit_order['id'], 'BTC/USDT')
print(f"Tình trạng lệnh: {order_status['status']}")

# Hủy bỏ một lệnh mở
canceled = exchange.cancel_order(limit_order['id'], 'BTC/USDT')
print(f"Hủy bỏ: {canceled}")

# Lấy tất cả các khoản cân bằng
balances = exchange.fetch_balance()
print(f"USDT Free: {balances['USDT']['free']}")
print(f"USDT Used: {balances['USDT']['used']}")
print(f"BTC Tổng cộng: {balances['BTC']['total']}")

# Lấy lịch sử nạp và rút tiền
deposits = exchange.fetch_deposits('USDT')
withdrawals = exchange.fetch_withdrawals('USDT')

# Lấy lệnh mở của tôi
open_orders = exchange.fetch_open_orders('BTC/USDT')
print(f"Lệnh mở: {len(open_orders)}")

# Lấy lịch sử giao dịch của tôi
my_trades = exchange.fetch_my_trades('BTC/USDT', limit=100)

import ccxt
from dotenv import load_dotenv
import os

# Load thông tin từ biến môi trường (tư vấn)
load_dotenv()

exchange = ccxt.binance({
    'apiKey': os.getenv('BINANCE_API_KEY'),
    'secret': os.getenv('BINANCE_SECRET'),
    'enableRateLimit': True,
    'options': {
        'defaultType': 'spot',  # 'spot', 'margin', 'future', 'delivery'
    }
})

# Binance Testnet (giao dịch giấy miễn phí)
binance_testnet = ccxt.binance({
    'apiKey': 'TESTNET_API_KEY',
    'secret': 'TESTNET_SECRET',
    'enableRateLimit': True,
    'sandbox': True,  # Kích hoạt chế độ testnet
    'options': {
        'defaultType': 'spot',
    }
})

# Xác nhận testnet đang được sử dụng
binance_testnet.set_sandbox_mode(True)
print("Đang sử dụng testnet:", binance_testnet.urls['api']['test'])

# Tất cả các hoạt động giao dịch sử dụng tiền ảo giả
paper_order = binance_testnet.create_market_buy_order('BTC/USDT', 0.01)
print(f"Giao dịch giấy thực hiện: {paper_order['id']}")

# Kích hoạt giới hạn tần suất (LUôn luôn làm như vậy)
exchange = ccxt.binance({
    'apiKey': 'YOUR_KEY',
    'secret': 'YOUR_SECRET',
    'enableRateLimit': True,  # Quan trọng cho sản xuất
})

# CCXT tự động quản lý tần suất yêu cầu
# Không cần thêm mã nào — chỉ việc làm

# Kiểm tra giới hạn tỷ giá của sàn giao dịch
print(exchange.rateLimit)  # Lượng milisecond tối thiểu giữa các yêu cầu

# Đối với giao dịch có tần suất cao, điều chỉnh thùng-token
exchange = ccxt.binance({
    'apiKey': 'YOUR_KEY',
    'secret': 'YOUR_SECRET',
    'enableRateLimit': True,
    'options': {
        'adjustForTimeDifference': True,
    }
})

import ccxt.pro as ccxtpro
import asyncio

async def websocket_orderbook():
    exchange = ccxtpro.binance({'enableRateLimit': True})
    
    while True:
        try:
            # Theo dõi cập nhật bảng đặt lệnh thực tế
            orderbook = await exchange.watch_order_book('BTC/USDT')
            bid = orderbook['bids'][0][0]
            ask = orderbook['asks'][0][0]
            spread = ask - bid
            print(f"Bid: {bid:.2f} | Ask: {ask:.2f} | Spread: {spread:.2f}")
        except Exception as e:
            print(f"Lỗi WebSocket: {e}")
            await asyncio.sleep(1)

async def websocket_trades():
    exchange = ccxtpro.binance({'enableRateLimit': True})
    
    while True:
        try:
            # Theo dõi giao dịch sống
            trades = await exchange.watch_trades('BTC/USDT')
            for trade in trades[-5:]:
                side = 'MUA' if trade['side'] == 'buy' else 'BÁN'
                print(f"{side} {trade['amount']} BTC @ {trade['price']}")
        except Exception as e:
            print(f"Lỗi luồng giao dịch: {e}")

# Chạy nhiều luồng WebSocket đồng thời
async def main():
    await asyncio.gather(
        websocket_orderbook(),
        websocket_trades()
    )

# asyncio.run(main())

import ccxt
import pandas as pd
import time
from datetime import datetime

class CCXTTradingBot:
    def __init__(self, exchange_id, api_key, secret, symbol='BTC/USDT'):
        exchange_class = getattr(ccxt, exchange_id)
        self.exchange = exchange_class({
            'apiKey': api_key,
            'secret': secret,
            'enableRateLimit': True,
            'options': {'defaultType': 'spot'}
        })
        self.symbol = symbol
        self.position = None
        
    def fetch_ohlcv_dataframe(self, timeframe='1h', limit=100):
        """Lấy dữ liệu OHLCV dưới dạng DataFrame pandas để phân tích."""
        ohlcv = self.exchange.fetch_ohlcv(self.symbol, timeframe, limit=limit)
        df = pd.DataFrame(
            ohlcv, 
            columns=['timestamp', 'open', 'high', 'low', 'close', 'volume']
        )
        df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
        return df
    
    def calculate_sma(self, df, period=20):
        """Trung bình động đơn giản để phát hiện xu hướng."""
        return df['close'].rolling(window=period).mean()
    
    def generate_signal(self, df):
        """Tạo tín hiệu mua/bán dựa trên giao nhau SMA."""
        sma_short = self.calculate_sma(df, period=10)
        sma_long = self.calculate_sma(df, period=30)
        
        if sma_short.iloc[-1] > sma_long.iloc[-1] and \
           sma_short.iloc[-2] <= sma_long.iloc[-2]:
            return 'buy'
        elif sma_short.iloc[-1] < sma_long.iloc[-1] and \
             sma_short.iloc[-2] >= sma_long.iloc[-2]:
            return 'sell'
        return 'hold'
    
    def execute_trade(self, signal, amount=0.001):
        """Thực hiện giao dịch dựa trên tín hiệu."""
        if signal == 'buy' and self.position != 'long':
            order = self.exchange.create_market_buy_order(self.symbol, amount)
            self.position = 'long'
            print(f"[{datetime.now()}] MUA đã thực hiện: {order['id']}")
            return order
            
        elif signal == 'sell' and self.position == 'long':
            order = self.exchange.create_market_sell_order(self.symbol, amount)
            self.position = None
            print(f"[{datetime.now()}] BÁN đã thực hiện: {order['id']}")
            return order
            
        return None
    
    def run(self, interval=60):
        """Lồng giao dịch chính."""
        print(f"Khởi động bot cho {self.symbol}")
        print(f"Kiểm tra mỗi {interval} giây")
        
        while True:
            try:
                df = self.fetch_ohlcv_dataframe()
                signal = self.generate_signal(df)
                print(f"[{datetime.now()}] Tín hiệu: {signal.upper()}")
                
                self.execute_trade(signal)
                time.sleep(interval)
                
            except ccxt.NetworkError as e:
                print(f"Lỗi mạng: {e}. Đang thử lại sau 10s...")
                time.sleep(10)
            except ccxt.ExchangeError as e:
                print(f"Lỗi giao dịch: {e}. Dừng lại.")
                break

# Sử dụng
if __name__ == "__main__":
    bot = CCXTTradingBot(
        exchange_id='binance',
        api_key='YOUR_API_KEY',
        secret='YOUR_SECRET',
        symbol='BTC/USDT'
    )
    # bot.run(interval=300)  # Kiểm tra mỗi 5 phút

import ccxt
import asyncio

async def tìm_lợi_nhuận_từ_nhật_không():
    """Phát hiện sự khác biệt về giá trên các sàn giao dịch."""
    exchanges = {
        'binance': ccxt.binance({'enableRateLimit': True}),
        'kraken': ccxt.kraken({'enableRateLimit': True}),
        'kucoin': ccxt.kucoin({'enableRateLimit': True}),
        'okx': ccxt.okx({'enableRateLimit': True}),
    }
    
    symbol = 'BTC/USDT'
    
    while True:
        prices = {}
        
        for name, exchange in exchanges.items():
            try:
                ticker = await exchange.fetch_ticker(symbol)
                prices[name] = {
                    'bid': ticker['bid'],
                    'ask': ticker['ask'],
                    'last': ticker['last']
                }
            except Exception as e:
                print(f"{name} lỗi: {e}")
        
        # Tìm cơ hội lợi nhuận tốt nhất
        if len(prices) >= 2:
            best_bid = max(prices.items(), key=lambda x: x[1]['bid'])
            best_ask = min(prices.items(), key=lambda x: x[1]['ask'])
            
            spread = best_bid[1]['bid'] - best_ask[1]['ask']
            spread_pct = (spread / best_ask[1]['ask']) * 100
            
            if spread_pct > 0.1:  # > 0.1% tiềm năng lợi nhuận
                print(f"LỢI NHUẬN TỪ NHẬT KHIẾN: Mua trên {best_ask[0]} @ {best_ask[1]['ask']:.2f}")
                print(f"           Bán trên {best_bid[0]} @ {best_bid[1]['bid']:.2f}")
        
        await asyncio.sleep(5)

# asyncio.run(tìm_lợi_nhuận_từ_nhật_không())

# Tính phí giao dịch để ước tính lợi nhuận chính xác
exchange = ccxt.binance({'enableRateLimit': True})
exchange.load_markets()

# Lấy phí giao dịch cho một ký hiệu cụ thể
symbol = 'BTC/USDT'
fees = exchange.fetch_trading_fee(symbol)
print(f"Phí maker: {fees['maker'] * 100}%")
print(f"Phí taker: {fees['taker'] * 100}%")

# Tính lợi nhuận ròng sau phí cho một giao dịch $1000
trade_amount = 1000
taker_fee = fees['taker'] * trade_amount
net_profit = trade_amount * 0.001 - (taker_fee * 2)  # Mua + Bán
print(f"Lợi nhuận ròng sau phí: ${net_profit:.2f}")

import ccxt
import pandas as pd
import pandas_ta as ta

class CCXTDataProvider:
    """CCXT-based data provider cho các khung kiểm thử lại."""
    
    def __init__(self, exchange_id='binance'):
        self.exchange = getattr(ccxt, exchange_id)({
            'enableRateLimit': True
        })
    
    def fetch_historical_data(self, symbol, timeframe='1d', 
                               since=None, limit=1000):
        """Lấy dữ liệu OHLCV lịch sử cho kiểm thử lại."""
        if since is None:
            since = self.exchange.parse8601('2024-01-01T00:00:00Z')
        
        all_ohlcv = []
        while len(all_ohlcv) < limit:
            ohlcv = self.exchange.fetch_ohlcv(
                symbol, timeframe, since=since, limit=min(1000, limit)
            )
            if not ohlcv:
                break
            all_ohlcv.extend(ohlcv)
            since = ohlcv[-1][0] + 1
            
        df = pd.DataFrame(
            all_ohlcv,
            columns=['timestamp', 'open', 'high', 'low', 'close', 'volume']
        )
        df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
        df.set_index('timestamp', inplace=True)
        return df
    
    def add_technical_indicators(self, df):
        """Thêm các chỉ số kỹ thuật cho tín hiệu chiến lược."""
        df['sma_20'] = ta.sma(df['close'], length=20)
        df['sma_50'] = ta.sma(df['close'], length=50)
        df['rsi'] = ta.rsi(df['close'], length=14)
        df['bbands'] = ta.bbands(df['close'], length=20)['BBU_20_2.0']
        df['atr'] = ta.atr(df['high'], df['low'], df['close'], length=14)
        return df

# Sử dụng cho kiểm thử lại
provider = CCXTDataProvider('binance')
data = provider.fetch_historical_data('BTC/USDT', '1h', limit=5000)
data = provider.add_technical_indicators(data)
print(f"Dữ liệu kiểm thử hình dạng: {data.shape}")
print(data.tail())

import ccxt
import time
from tenacity import retry, stop_after_attempt, wait_exponential

class RobustCCXTTrader:
    def __init__(self, exchange_id, config):
        exchange_class = getattr(ccxt, exchange_id)
        self.exchange = exchange_class(config)
        
    @retry(stop=stop_after_attempt(3), 
           wait=wait_exponential(multiplier=1, min=2, max=10))
    def fetch_ticker_safe(self, symbol):
        """Lấy thông tin ticker với việc thử lại tự động khi thất bại."""
        return self.exchange.fetch_ticker(symbol)
    
    @retry(stop=stop_after_attempt(3),
           wait=wait_exponential(multiplier=1, min=2, max=10))
    def create_order_safe(self, symbol, side, amount, price=None, 
                          order_type='market'):
        """Tạo lệnh với thử lại và phân loại lỗi."""
        try:
            if order_type == 'market':
                if side == 'buy':
                    return self.exchange.create_market_buy_order(symbol, amount)
                return self.exchange.create_market_sell_order(symbol, amount)
            else:
                if side == 'buy':
                    return self.exchange.create_limit_buy_order(symbol, amount, price)
                return self.exchange.create_limit_sell_order(symbol, amount, price)
        except ccxt.InsufficientFunds as e:
            print(f"Khoản tiền không đủ: {e}")
            raise
        except ccxt.InvalidOrder as e:
            print(f"Lệnh không hợp lệ: {e}")
            raise
        except ccxt.NetworkError as e:
            print(f"Lỗi mạng, sẽ thử lại: {e}")
            raise  # Triggers retry
    
    def check_exchange_health(self):
        """Kiểm tra sàn giao dịch hoạt động hay không."""
        try:
            status = self.exchange.fetch_status()
            return status.get('status') == 'ok'
        except Exception:
            return False