Comment appeler l'API Binance avec Python ? Pratique avec python-binance et ccxt

Les trois choix les plus matures pour le SDK Python de Binance sont python-binance (recommandé officiellement), ccxt (interface unifiée pour plusieurs échanges) et l'encapsulation native aiohttp (développement sur mesure haute performance). Ils correspondent respectivement aux scénarios de « développement rapide », « compatibilité multi-plateformes » et « performance extrême ». Cet article fournit le code complet pour l'installation, l'appel de signature, le passage d'ordre et l'abonnement WebSocket pour ces trois options, accompagné d'un test de performance. Si vous n'avez pas de compte Binance, veuillez d'abord effectuer le KYC sur le site officiel de Binance ; les nouveaux utilisateurs peuvent ouvrir un compte via l' inscription gratuite.

I. Tableau comparatif des trois SDK

II. Exemple complet python-binance

1. Installation et initialisation

pip install python-binance

from binance.client import Client
from binance.enums import *

API_KEY = "VOTRE_CLE_API"
SECRET_KEY = "VOTRE_SECRET_KEY"

client = Client(API_KEY, SECRET_KEY)

# Testnet
# client = Client(API_KEY, SECRET_KEY, testnet=True)

# Valider la connexion
print(client.get_server_time())  # {'serverTime': 1713027384562}

2. Consulter les soldes et le marché

# Solde du compte Spot
account = client.get_account()
non_zero = [b for b in account["balances"] if float(b["free"]) > 0]
for b in non_zero:
    print(f"{b['asset']}: Disponible {b['free']}, Bloqué {b['locked']}")

# Prix d'un seul symbole
price = client.get_symbol_ticker(symbol="BTCUSDT")
print(f"Dernier prix BTC: {price['price']}")

# Chandeliers (K-lines)
klines = client.get_klines(symbol="BTCUSDT", interval=Client.KLINE_INTERVAL_1HOUR, limit=100)
for k in klines[-5:]:
    print(f"Heure {k[0]}, O:{k[1]} H:{k[2]} L:{k[3]} C:{k[4]} V:{k[5]}")

# Profondeur du carnet d'ordres
depth = client.get_order_book(symbol="BTCUSDT", limit=20)
print(f"Meilleur achat {depth['bids'][0]}, Meilleure vente {depth['asks'][0]}")

3. Passage d'ordre au comptant (Spot)

# Ordre limité
order = client.order_limit_buy(
    symbol="BTCUSDT",
    quantity=0.001,
    price="60000.00"
)
print(f"ID Ordre: {order['orderId']}, Statut: {order['status']}")

# Achat au marché (par quantité)
client.order_market_buy(symbol="BTCUSDT", quantity=0.001)

# Achat au marché (par montant USDT)
client.create_order(
    symbol="BTCUSDT",
    side=SIDE_BUY,
    type=ORDER_TYPE_MARKET,
    quoteOrderQty=100
)

# Vérifier un ordre
status = client.get_order(symbol="BTCUSDT", orderId=order["orderId"])
print(f"Exécuté: {status['executedQty']} / {status['origQty']}")

# Annuler un ordre
client.cancel_order(symbol="BTCUSDT", orderId=order["orderId"])

4. Passage d'ordre sur contrats (Futures)

# Consulter les positions Futures
positions = client.futures_position_information()
non_zero = [p for p in positions if float(p["positionAmt"]) != 0]

# Configurer l'effet de levier
client.futures_change_leverage(symbol="BTCUSDT", leverage=10)

# Position longue limitée sur Futures
futures_order = client.futures_create_order(
    symbol="BTCUSDT",
    side="BUY",
    type="LIMIT",
    timeInForce="GTC",
    quantity=0.01,
    price="60000.00"
)
print(futures_order)

# Fermeture de position au marché sur Futures
client.futures_create_order(
    symbol="BTCUSDT",
    side="SELL",
    type="MARKET",
    quantity=0.01,
    reduceOnly=True
)

5. Abonnement WebSocket

from binance import ThreadedWebsocketManager

twm = ThreadedWebsocketManager(api_key=API_KEY, api_secret=SECRET_KEY)
twm.start()

def handle_ticker(msg):
    print(f"{msg['s']} Dernier prix {msg['c']}, Volume 24h {msg['v']}")

def handle_user(msg):
    if msg["e"] == "executionReport":
        print(f"Ordre {msg['i']} Statut {msg['X']}, Volume exécuté {msg['z']}")

twm.start_symbol_ticker_socket(callback=handle_ticker, symbol="BTCUSDT")
twm.start_user_socket(callback=handle_user)  # Écoute automatique du flux d'ordres

twm.join()

6. Version asynchrone AsyncClient

import asyncio
from binance import AsyncClient, BinanceSocketManager

async def main():
    client = await AsyncClient.create(API_KEY, SECRET_KEY)

    # Requêtes en parallèle
    price, account = await asyncio.gather(
        client.get_symbol_ticker(symbol="BTCUSDT"),
        client.get_account()
    )
    print(price, len(account["balances"]))

    # WebSocket
    bsm = BinanceSocketManager(client)
    async with bsm.symbol_ticker_socket("BTCUSDT") as stream:
        for _ in range(10):
            msg = await stream.recv()
            print(msg)

    await client.close_connection()

asyncio.run(main())

III. Exemple d'interface unifiée ccxt

1. Installation et initialisation

pip install ccxt

import ccxt

exchange = ccxt.binance({
    "apiKey": "VOTRE_CLE",
    "secret": "VOTRE_SECRET",
    "enableRateLimit": True,  # Limitation de débit automatique
    "options": {
        "defaultType": "spot"  # ou "future"
    }
})

# Chargement automatique des marchés
markets = exchange.load_markets()
print(f"Prend en charge {len(markets)} paires de trading")

2. Appels de style unifié

Le plus grand avantage de ccxt est que le style d'API est cohérent pour tous les échanges :

# Marché (fetch_ticker est identique pour n'importe quel échange)
ticker = exchange.fetch_ticker("BTC/USDT")
print(f"Dernier prix {ticker['last']}, Variation {ticker['percentage']}%")

# Solde
balance = exchange.fetch_balance()
print(balance["total"])  # {'BTC': 0.001, 'USDT': 100, ...}

# Passer un ordre
order = exchange.create_order(
    symbol="BTC/USDT",
    type="limit",
    side="buy",
    amount=0.001,
    price=60000
)

# Annuler un ordre
exchange.cancel_order(order["id"], symbol="BTC/USDT")

# Consulter les ordres
my_orders = exchange.fetch_open_orders("BTC/USDT")

3. Basculer vers les contrats (Futures)

exchange.options["defaultType"] = "future"

# Ordre Futures : le symbole reste BTC/USDT (mappage interne vers BTCUSDT Perp)
order = exchange.create_order(
    symbol="BTC/USDT",
    type="limit",
    side="buy",
    amount=0.01,
    price=60000,
    params={"positionSide": "BOTH", "reduceOnly": False}
)

4. WebSocket (ccxt.pro, version commerciale)

# pip install ccxt --upgrade
import ccxt.pro as ccxtpro
import asyncio

async def watch_ticker():
    exchange = ccxtpro.binance({"apiKey": "CLE", "secret": "SECRET"})
    while True:
        ticker = await exchange.watch_ticker("BTC/USDT")
        print(ticker["last"])

asyncio.run(watch_ticker())

IV. Encapsulation native aiohttp (Scénarios haute performance)

Lorsqu'il est nécessaire de gagner les 10 dernières ms de latence, une encapsulation sur mesure est préférable :

import aiohttp, asyncio, hmac, hashlib, time
from urllib.parse import urlencode

class BinanceAsync:
    def __init__(self, key, secret):
        self.key = key
        self.secret = secret
        self.base = "https://api.binance.com"
        self.session = None

    async def __aenter__(self):
        self.session = aiohttp.ClientSession(
            connector=aiohttp.TCPConnector(limit=100, ttl_dns_cache=300),
            timeout=aiohttp.ClientTimeout(total=5)
        )
        return self

    async def __aexit__(self, *args):
        await self.session.close()

    def _sign(self, params):
        params["timestamp"] = int(time.time() * 1000)
        query = urlencode(params)
        sig = hmac.new(self.secret.encode(), query.encode(), hashlib.sha256).hexdigest()
        return f"{query}&signature={sig}"

    async def get_account(self):
        query = self._sign({})
        async with self.session.get(
            f"{self.base}/api/v3/account?{query}",
            headers={"X-MBX-APIKEY": self.key}
        ) as r:
            return await r.json()

    async def place_order(self, symbol, side, qty, price):
        query = self._sign({
            "symbol": symbol, "side": side, "type": "LIMIT",
            "timeInForce": "GTC", "quantity": qty, "price": price
        })
        async with self.session.post(
            f"{self.base}/api/v3/order?{query}",
            headers={"X-MBX-APIKEY": self.key}
        ) as r:
            return await r.json()

async def demo():
    async with BinanceAsync("CLE", "SECRET") as api:
        account = await api.get_account()
        print(account["canTrade"])

asyncio.run(demo())

V. Tests de performance (Benchmark)

Test réel depuis un ECS Alibaba Cloud Shanghai vers un nœud Binance Tokyo :

import asyncio, time

async def benchmark(client, n=100):
    start = time.time()
    tasks = [client.get_symbol_ticker(symbol="BTCUSDT") for _ in range(n)]
    await asyncio.gather(*tasks)
    elapsed = time.time() - start
    return elapsed, n/elapsed

# Résultats (n=100 en parallèle) :
# python-binance AsyncClient: 8.2s, 12.2 req/s
# ccxt (synchrone encapsulé) : 12.5s, 8.0 req/s
# aiohttp natif :             6.4s, 15.6 req/s

Conclusion : python-binance est le premier choix pour les stratégies à fréquence basse/moyenne ; ccxt pour l'arbitrage multi-plateformes ; aiohttp sur mesure ou encapsulation C++ pour le trading haute fréquence (HFT).

VI. Questions Fréquentes FAQ

Q1 : Quelle est la différence entre python-binance et binance-connector-python ?

R : python-binance (par sammchardy) est une bibliothèque communautaire historique, très complète et riche en documentation ; binance-connector-python est une encapsulation légère produite par Binance, avec moins de fonctionnalités mais suivant de près les mises à jour de l'API. python-binance est recommandé pour la production.

Q2 : ccxt peut-il s'abonner aux WebSockets ?

R : La version gratuite de ccxt ne propose que le REST ; le WebSocket est dans ccxt.pro (payant). Pour les projets open source, des alternatives comme ccxt-ws peuvent être utilisées, mais leur stabilité est moindre par rapport au python-binance natif.

Q3 : Que faire si l'appel renvoie APIError: Invalid API-key, IP, or permissions ?

R : Trois causes possibles : 1) Erreur de copie de la clé API ou du secret ; 2) La liste blanche IP est activée mais l'IP du serveur actuel n'y figure pas ; 3) Les permissions de l'interface appelée ne sont pas cochées (par exemple, Enable Futures non coché pour l'interface contrats).

Q4 : Comment tester le SDK sans affecter mon compte réel ?

R : python-binance et ccxt supportent tous deux le testnet, il suffit de passer testnet=True lors de l'initialisation. Les jetons de test peuvent être récupérés gratuitement sur https://testnet.binance.vision (10 000 USDT).

Q5 : Un pool de connexions est-il nécessaire en production ?

R : Oui. Par défaut, requests crée une nouvelle connexion TCP pour chaque requête, ce qui ajoute 20 à 30 ms de latence. Utiliser requests.Session() ou TCPConnector(limit=100) de aiohttp permet de maintenir des connexions persistantes (Keep-Alive), réduisant la latence à moins de 5 ms.

Après avoir exploré la solution Python, retournez à la Navigation par catégorie pour consulter les tutoriels sur les SDK d'autres langues dans la catégorie « Intégration API ».