```html
Introduction à l'API Binance
L'API Binance offre aux développeurs un accès programmatique à la plateforme de trading de Binance, leur permettant de créer des robots de trading, des applications et des outils qui interagissent avec la bourse. Ce tutoriel vous guidera tout au long du processus d'utilisation de l'API Binance, de la configuration de l'authentification à la réalisation de différents types de requêtes.
Alors que de nombreux développeurs se sont traditionnellement appuyés sur Postman pour les tests d'API, Apidog offre une expérience plus rationalisée et spécialisée pour travailler avec les API de cryptomonnaies comme Binance. Avec son interface intuitive, sa gestion améliorée de l'authentification et ses fonctionnalités spécifiques aux cryptomonnaies intégrées, Apidog réduit considérablement le temps de configuration nécessaire pour commencer à tester et à implémenter les points de terminaison de l'API Binance.
Les outils de collaboration en temps réel de la plateforme et ses capacités complètes de génération de documentation la rendent particulièrement précieuse pour les équipes travaillant sur des applications de trading de cryptomonnaies.
Si vous êtes sérieux au sujet de l'intégration efficace de l'API Binance, passer à Apidog améliorera considérablement votre flux de travail de développement et réduira le délai de déploiement de vos projets de cryptomonnaies.
Configuration de l'authentification de l'API Binance
Avant d'utiliser l'API Binance, vous devez créer des clés API à partir de votre compte Binance. Cette section explique comment configurer et sécuriser vos clés API.
Création de clés API Binance
- Connectez-vous à votre compte Binance
- Accédez à "Gestion des API" dans les paramètres de votre compte
- Créez une nouvelle clé API
- Notez votre clé API et votre clé secrète
- Configurez les restrictions (liste blanche IP, autorisations de trading, etc.)
Types de clés API pris en charge par l'API Binance
Binance prend en charge trois types de méthodes d'authentification par clé API :
- Clés HMAC - La méthode d'authentification la plus courante
- Clés RSA - Offre des fonctionnalités de sécurité améliorées
- Clés Ed25519 - Offre les meilleures performances et la meilleure sécurité
Exemple d'authentification HMAC
Voici comment s'authentifier avec les clés HMAC :
import hmac
import hashlib
import time
import requests
from urllib.parse import urlencode
# API credentials
api_key = 'your_api_key'
api_secret = 'your_api_secret'
# Base URL for Binance API
base_url = '<https://api.binance.com>'
# Function to create a signature for authenticated endpoints
def get_signature(query_string):
return hmac.new(
api_secret.encode('utf-8'),
query_string.encode('utf-8'),
hashlib.sha256
).hexdigest()
# Example request to get account information
def get_account():
endpoint = '/api/v3/account'
timestamp = int(time.time() * 1000)
params = {
'timestamp': timestamp,
'recvWindow': 5000 # Optional parameter
}
query_string = urlencode(params)
signature = get_signature(query_string)
url = f"{base_url}{endpoint}?{query_string}&signature={signature}"
headers = {
'X-MBX-APIKEY': api_key
}
response = requests.get(url, headers=headers)
return response.json()
# Call the function
account_info = get_account()
print(account_info)
Comprendre les points de terminaison de l'API Binance
L'API Binance est organisée en plusieurs catégories de points de terminaison en fonction de leurs fonctionnalités.
Points de terminaison généraux de l'API Binance
Ces points de terminaison fournissent des informations générales sur la bourse :
# Test connectivity
def test_connectivity():
endpoint = '/api/v3/ping'
url = f"{base_url}{endpoint}"
response = requests.get(url)
return response.json()
# Get server time
def get_server_time():
endpoint = '/api/v3/time'
url = f"{base_url}{endpoint}"
response = requests.get(url)
return response.json()
# Get exchange information
def get_exchange_info():
endpoint = '/api/v3/exchangeInfo'
url = f"{base_url}{endpoint}"
response = requests.get(url)
return response.json()
Points de terminaison de l'API Binance pour les données de marché
Ces points de terminaison permettent d'accéder aux données de marché :
# Get order book for a symbol
def get_order_book(symbol, limit=100):
endpoint = '/api/v3/depth'
params = {
'symbol': symbol,
'limit': limit
}
url = f"{base_url}{endpoint}?{urlencode(params)}"
response = requests.get(url)
return response.json()
# Get recent trades
def get_recent_trades(symbol, limit=500):
endpoint = '/api/v3/trades'
params = {
'symbol': symbol,
'limit': limit
}
url = f"{base_url}{endpoint}?{urlencode(params)}"
response = requests.get(url)
return response.json()
# Get candlestick data
def get_klines(symbol, interval, start_time=None, end_time=None, limit=500):
endpoint = '/api/v3/klines'
params = {
'symbol': symbol,
'interval': interval,
'limit': limit
}
if start_time:
params['startTime'] = start_time
if end_time:
params['endTime'] = end_time
url = f"{base_url}{endpoint}?{urlencode(params)}"
response = requests.get(url)
# Format the response
klines = response.json()
formatted_klines = []
for k in klines:
formatted_klines.append({
'open_time': k[0],
'open': float(k[1]),
'high': float(k[2]),
'low': float(k[3]),
'close': float(k[4]),
'volume': float(k[5]),
'close_time': k[6],
'quote_volume': float(k[7]),
'trades': k[8],
'taker_buy_base_volume': float(k[9]),
'taker_buy_quote_volume': float(k[10])
})
return formatted_klines
Trading avec l'API Binance
Les points de terminaison de trading vous permettent de passer et de gérer des ordres.
Passer des ordres avec l'API Binance
Voici comment passer différents types d'ordres :
# Place a LIMIT order
def place_limit_order(symbol, side, quantity, price):
endpoint = '/api/v3/order'
timestamp = int(time.time() * 1000)
params = {
'symbol': symbol,
'side': side, # 'BUY' or 'SELL'
'type': 'LIMIT',
'timeInForce': 'GTC', # Good Till Canceled
'quantity': quantity,
'price': price,
'timestamp': timestamp,
'recvWindow': 5000
}
query_string = urlencode(params)
signature = get_signature(query_string)
url = f"{base_url}{endpoint}?{query_string}&signature={signature}"
headers = {
'X-MBX-APIKEY': api_key
}
response = requests.post(url, headers=headers)
return response.json()
# Place a MARKET order
def place_market_order(symbol, side, quantity):
endpoint = '/api/v3/order'
timestamp = int(time.time() * 1000)
params = {
'symbol': symbol,
'side': side, # 'BUY' or 'SELL'
'type': 'MARKET',
'quantity': quantity,
'timestamp': timestamp,
'recvWindow': 5000
}
query_string = urlencode(params)
signature = get_signature(query_string)
url = f"{base_url}{endpoint}?{query_string}&signature={signature}"
headers = {
'X-MBX-APIKEY': api_key
}
response = requests.post(url, headers=headers)
return response.json()
# Place a STOP_LOSS order
def place_stop_loss_order(symbol, side, quantity, stop_price):
endpoint = '/api/v3/order'
timestamp = int(time.time() * 1000)
params = {
'symbol': symbol,
'side': side,
'type': 'STOP_LOSS',
'quantity': quantity,
'stopPrice': stop_price,
'timestamp': timestamp,
'recvWindow': 5000
}
query_string = urlencode(params)
signature = get_signature(query_string)
url = f"{base_url}{endpoint}?{query_string}&signature={signature}"
headers = {
'X-MBX-APIKEY': api_key
}
response = requests.post(url, headers=headers)
return response.json()
Gestion des ordres avec l'API Binance
Voici comment interroger, annuler et suivre les ordres :
# Query order status
def query_order(symbol, order_id=None, orig_client_order_id=None):
endpoint = '/api/v3/order'
timestamp = int(time.time() * 1000)
params = {
'symbol': symbol,
'timestamp': timestamp,
'recvWindow': 5000
}
if order_id:
params['orderId'] = order_id
elif orig_client_order_id:
params['origClientOrderId'] = orig_client_order_id
else:
raise ValueError("Either order_id or orig_client_order_id must be provided")
query_string = urlencode(params)
signature = get_signature(query_string)
url = f"{base_url}{endpoint}?{query_string}&signature={signature}"
headers = {
'X-MBX-APIKEY': api_key
}
response = requests.get(url, headers=headers)
return response.json()
# Cancel an order
def cancel_order(symbol, order_id=None, orig_client_order_id=None):
endpoint = '/api/v3/order'
timestamp = int(time.time() * 1000)
params = {
'symbol': symbol,
'timestamp': timestamp,
'recvWindow': 5000
}
if order_id:
params['orderId'] = order_id
elif orig_client_order_id:
params['origClientOrderId'] = orig_client_order_id
else:
raise ValueError("Either order_id or orig_client_order_id must be provided")
query_string = urlencode(params)
signature = get_signature(query_string)
url = f"{base_url}{endpoint}?{query_string}&signature={signature}"
headers = {
'X-MBX-APIKEY': api_key
}
response = requests.delete(url, headers=headers)
return response.json()
# Get all open orders
def get_open_orders(symbol=None):
endpoint = '/api/v3/openOrders'
timestamp = int(time.time() * 1000)
params = {
'timestamp': timestamp,
'recvWindow': 5000
}
if symbol:
params['symbol'] = symbol
query_string = urlencode(params)
signature = get_signature(query_string)
url = f"{base_url}{endpoint}?{query_string}&signature={signature}"
headers = {
'X-MBX-APIKEY': api_key
}
response = requests.get(url, headers=headers)
return response.json()
Données de compte et d'utilisateur avec l'API Binance
Ces points de terminaison vous permettent d'accéder aux informations de compte et de diffuser des données utilisateur.
Informations sur le compte avec l'API Binance
# Get account information
def get_account_information():
endpoint = '/api/v3/account'
timestamp = int(time.time() * 1000)
params = {
'timestamp': timestamp,
'recvWindow': 5000
}
query_string = urlencode(params)
signature = get_signature(query_string)
url = f"{base_url}{endpoint}?{query_string}&signature={signature}"
headers = {
'X-MBX-APIKEY': api_key
}
response = requests.get(url, headers=headers)
return response.json()
# Get account trade list
def get_account_trades(symbol, start_time=None, end_time=None, limit=500):
endpoint = '/api/v3/myTrades'
timestamp = int(time.time() * 1000)
params = {
'symbol': symbol,
'timestamp': timestamp,
'limit': limit,
'recvWindow': 5000
}
if start_time:
params['startTime'] = start_time
if end_time:
params['endTime'] = end_time
query_string = urlencode(params)
signature = get_signature(query_string)
url = f"{base_url}{endpoint}?{query_string}&signature={signature}"
headers = {
'X-MBX-APIKEY': api_key
}
response = requests.get(url, headers=headers)
return response.json()
Flux de données utilisateur avec l'API Binance
# Start a user data stream
def start_user_data_stream():
endpoint = '/api/v3/userDataStream'
headers = {
'X-MBX-APIKEY': api_key
}
response = requests.post(f"{base_url}{endpoint}", headers=headers)
return response.json()
# Keep alive a user data stream
def keep_alive_user_data_stream(listen_key):
endpoint = '/api/v3/userDataStream'
params = {
'listenKey': listen_key
}
headers = {
'X-MBX-APIKEY': api_key
}
response = requests.put(f"{base_url}{endpoint}?{urlencode(params)}", headers=headers)
return response.json()
# Close a user data stream
def close_user_data_stream(listen_key):
endpoint = '/api/v3/userDataStream'
params = {
'listenKey': listen_key
}
headers = {
'X-MBX-APIKEY': api_key
}
response = requests.delete(f"{base_url}{endpoint}?{urlencode(params)}", headers=headers)
return response.json()
Fonctionnalités avancées de l'API Binance
Cette section couvre certaines des fonctionnalités les plus avancées de l'API Binance.
Travailler avec des listes d'ordres (OCO) dans l'API Binance
Les ordres One-Cancels-the-Other (OCO) vous permettent de placer une paire d'ordres où, si l'un est déclenché, l'autre est automatiquement annulé :
# Place an OCO order
def place_oco_order(symbol, side, quantity, price, stop_price):
endpoint = '/api/v3/orderList/oco'
timestamp = int(time.time() * 1000)
params = {
'symbol': symbol,
'side': side,
'quantity': quantity,
'price': price,
'stopPrice': stop_price,
'timestamp': timestamp,
'recvWindow': 5000
}
# Define the types for the OCO order based on side
if side == 'SELL':
params['aboveType'] = 'STOP_LOSS'
params['belowType'] = 'LIMIT_MAKER'
else:
params['aboveType'] = 'LIMIT_MAKER'
params['belowType'] = 'STOP_LOSS'
params['aboveTimeInForce'] = 'GTC'
params['belowTimeInForce'] = 'GTC'
query_string = urlencode(params)
signature = get_signature(query_string)
url = f"{base_url}{endpoint}?{query_string}&signature={signature}"
headers = {
'X-MBX-APIKEY': api_key
}
response = requests.post(url, headers=headers)
return response.json()
Gestion des limites de débit dans l'API Binance
Binance applique des limites de débit aux requêtes d'API. Voici comment les gérer :
import time
from functools import wraps
# Decorator to handle rate limits
def handle_rate_limit(max_retries=3, retry_delay=30):
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
retries = 0
while retries <= max_retries:
try:
response = func(*args, **kwargs)
if 'code' in response and response['code'] == -1429: # Rate limit exceeded
retries += 1
if retries > max_retries:
raise Exception(f"Rate limit exceeded after {max_retries} retries")
print(f"Rate limit exceeded. Waiting {retry_delay} seconds before retry...")
time.sleep(retry_delay)
else:
return response
except Exception as e:
if "429" in str(e) or "418" in str(e):
retries += 1
if retries > max_retries:
raise
print(f"Rate limit exceeded. Waiting {retry_delay} seconds before retry...")
time.sleep(retry_delay)
else:
raise
return wrapper
return decorator
# Example usage
@handle_rate_limit()
def get_exchange_info_with_retry():
endpoint = '/api/v3/exchangeInfo'
url = f"{base_url}{endpoint}"
response = requests.get(url)
return response.json()
Création d'un robot de trading complet avec l'API Binance
Maintenant, mettons tout ensemble pour créer un simple robot de trading :
import hmac
import hashlib
import time
import requests
import json
import websocket
import threading
from urllib.parse import urlencode
class BinanceTrader:
def __init__(self, api_key, api_secret, symbol='BTCUSDT'):
self.api_key = api_key
self.api_secret = api_secret
self.base_url = '<https://api.binance.com>'
self.symbol = symbol
self.ws = None
self.listen_key = None
self.keep_alive_thread = None
def get_signature(self, query_string):
return hmac.new(
self.api_secret.encode('utf-8'),
query_string.encode('utf-8'),
hashlib.sha256
).hexdigest()
def get_server_time(self):
endpoint = '/api/v3/time'
response = requests.get(f"{self.base_url}{endpoint}")
return response.json()['serverTime']
def get_account_info(self):
endpoint = '/api/v3/account'
timestamp = int(time.time() * 1000)
params = {
'timestamp': timestamp,
'recvWindow': 5000
}
query_string = urlencode(params)
signature = self.get_signature(query_string)
url = f"{self.base_url}{endpoint}?{query_string}&signature={signature}"
headers = {
'X-MBX-APIKEY': self.api_key
}
response = requests.get(url, headers=headers)
return response.json()
def place_market_order(self, side, quantity):
endpoint = '/api/v3/order'
timestamp = int(time.time() * 1000)
params = {
'symbol': self.symbol,
'side': side,
'type': 'MARKET',
'quantity': quantity,
'timestamp': timestamp,
'recvWindow': 5000
}
query_string = urlencode(params)
signature = self.get_signature(query_string)
url = f"{self.base_url}{endpoint}?{query_string}&signature={signature}"
headers = {
'X-MBX-APIKEY': self.api_key
}
response = requests.post(url, headers=headers)
return response.json()
def start_user_data_stream(self):
endpoint = '/api/v3/userDataStream'
headers = {
'X-MBX-APIKEY': self.api_key
}
response = requests.post(f"{self.base_url}{endpoint}", headers=headers)
self.listen_key = response.json()['listenKey']
return self.listen_key
def keep_alive_user_data_stream(self):
while True:
if self.listen_key:
endpoint = '/api/v3/userDataStream'
params = {
'listenKey': self.listen_key
}
headers = {
'X-MBX-APIKEY': self.api_key
}
requests.put(f"{self.base_url}{endpoint}?{urlencode(params)}", headers=headers)
time.sleep(30 * 60) # Keep alive every 30 minutes
def on_message(self, ws, message):
data = json.loads(message)
# Handle account updates
if data.get('e') == 'outboundAccountPosition':
print("Account update received:")
print(f"Update time: {data['u']}")
print("Balances:")
for balance in data['B']:
print(f"Asset: {balance['a']}, Free: {balance['f']}, Locked: {balance['l']}")
# Handle order updates
elif data.get('e') == 'executionReport':
print("Order update received:")
print(f"Symbol: {data['s']}")
print(f"Side: {data['S']}")
print(f"Order type: {data['o']}")
print(f"Order status: {data['X']}")
print(f"Price: {data['p']}")
print(f"Quantity: {data['q']}")
print(f"Executed quantity: {data['z']}")
# Implement trading logic here based on order updates
if data['X'] == 'FILLED' and data['S'] == 'BUY':
# Example: Place a sell order when buy is filled
sell_price = float(data['p']) * 1.05 # 5% profit target
self.place_limit_order('SELL', data['q'], sell_price)
def on_error(self, ws, error):
print(f"Error: {error}")
def on_close(self, ws, close_status_code, close_msg):
print("WebSocket connection closed")
def on_open(self, ws):
print("WebSocket connection opened")
def start_websocket(self):
self.start_user_data_stream()
socket_url = f"wss://stream.binance.com:9443/ws/{self.listen_key}"
self.ws = websocket.WebSocketApp(
socket_url,
on_message=self.on_message,
on_error=self.on_error,
on_close=self.on_close,
on_open=self.on_open
)
# Start keep-alive thread
self.keep_alive_thread = threading.Thread(target=self.keep_alive_user_data_stream)
self.keep_alive_thread.daemon = True
self.keep_alive_thread.start()
# Run the WebSocket in a separate thread
ws_thread = threading.Thread(target=self.ws.run_forever)
ws_thread.daemon = True
ws_thread.start()
return ws_thread
# Example usage
if __name__ == "__main__":
api_key = "your_api_key"
api_secret = "your_api_secret"
trader = BinanceTrader(api_key, api_secret, 'BTCUSDT')
# Get account information
account_info = trader.get_account_info()
print("Account Information:")
print(f"Can Trade: {account_info['canTrade']}")
print(f"Can Withdraw: {account_info['canWithdraw']}")
print(f"Can Deposit: {account_info['canDeposit']}")
# Print balances
print("\\\\nBalances:")
for balance in account_info['balances']:
if float(balance['free']) > 0 or float(balance['locked']) > 0:
print(f"Asset: {balance['asset']}, Free: {balance['free']}, Locked: {balance['locked']}")
# Start the WebSocket for real-time updates
ws_thread = trader.start_websocket()
try:
# Keep the main thread running
while True:
time.sleep(1)
except KeyboardInterrupt:
print("Stopping...")
trader.ws.close()
Meilleures pratiques pour l'utilisation de l'API Binance
Voici quelques bonnes pratiques à suivre lorsque vous travaillez avec l'API Binance :
Pratiques de sécurité pour l'API Binance
- Restreindre les autorisations de clé API : n'activez que les autorisations dont vous avez besoin (par exemple, en lecture seule, trading, retraits)
- Listes blanches d'adresses IP : limitez vos clés API pour qu'elles ne fonctionnent qu'à partir d'adresses IP spécifiques
- Stockage sécurisé des clés API : ne codez jamais en dur les clés API dans votre code, utilisez des variables d'environnement ou des coffres-forts sécurisés
- Rotation régulière des clés : modifiez périodiquement vos clés API pour atténuer les risques
import os
# Load API keys from environment variables
api_key = os.environ.get('BINANCE_API_KEY')
api_secret = os.environ.get('BINANCE_API_SECRET')
if not api_key or not api_secret:
raise ValueError("API keys not found in environment variables")
Gestion des erreurs avec l'API Binance
Implémentez une gestion robuste des erreurs pour gérer les erreurs d'API et les problèmes de connexion :
def safe_request(func):
@wraps(func)
def wrapper(*args, **kwargs):
try:
response = func(*args, **kwargs)
# Check for API error codes
if isinstance(response, dict) and 'code' in response:
print(f"API Error: Code {response['code']}, Message: {response.get('msg', 'No message')}")
# Handle specific error codes
if response['code'] == -1021: # INVALID_TIMESTAMP
print("Server and local time are not synchronized. Adjusting timestamp...")
# Implement timestamp adjustment logic here
elif response['code'] == -2010: # INSUFFICIENT_BALANCE
print("Insufficient balance for order.")
# Add more specific error handling as needed
return response
except requests.exceptions.RequestException as e:
print(f"Request Error: {e}")
# Implement retry logic or fallback behavior
return None
except json.JSONDecodeError:
print("Failed to decode JSON response")
return None
except Exception as e:
print(f"Unexpected error: {e}")
return None
return wrapper
@safe_request
def get_account_info_safe():
# Implementation of get_account_info with proper error handling
# ...
Conclusion
L'API Binance offre un moyen puissant d'interagir avec la bourse Binance par programmation. Ce tutoriel a couvert les aspects essentiels de l'utilisation de l'API, de l'authentification à la passation d'ordres et à la gestion de votre compte. En suivant les meilleures pratiques et en mettant en œuvre une gestion appropriée des erreurs, vous pouvez créer des applications et des robots de trading robustes qui tirent parti de l'ensemble complet de fonctionnalités de Binance.
N'oubliez pas de sécuriser vos clés API, de respecter les limites de débit et de tester minutieusement votre code dans un environnement de test avant de l'utiliser avec des fonds réels. Au fur et à mesure que Binance met à jour son API, assurez-vous de rester informé de tout changement apporté aux points de terminaison ou aux paramètres pour vous assurer que vos applications continuent de fonctionner correctement.
Grâce aux connaissances acquises grâce à ce tutoriel, vous devriez être bien équipé pour commencer à créer vos propres outils et applications de trading à l'aide de l'API Binance.
```
