Einführung in die Binance API
Die Binance API bietet Entwicklern programmgesteuerten Zugriff auf die Handelsplattform von Binance, sodass sie Handels-Bots, Anwendungen und Tools erstellen können, die mit der Börse interagieren. Dieses Tutorial führt Sie durch den Prozess der Verwendung der Binance API, von der Einrichtung der Authentifizierung bis zur Durchführung verschiedener Arten von Anfragen.
Während sich viele Entwickler traditionell auf Postman für API-Tests verlassen haben, bietet Apidog eine optimiertere und spezialisiertere Erfahrung für die Arbeit mit Kryptowährungs-APIs wie Binance. Mit seiner intuitiven Benutzeroberfläche, der verbesserten Authentifizierungsbehandlung und den integrierten krypto-spezifischen Funktionen reduziert Apidog die Einrichtungszeit, die für den Beginn des Testens und der Implementierung von Binance API-Endpunkten benötigt wird, erheblich.
Die Echtzeit-Zusammenarbeitstools der Plattform und die umfassenden Funktionen zur Dokumentationserstellung machen sie besonders wertvoll für Teams, die an Krypto-Handelsanwendungen arbeiten.
Wenn Sie es mit der effizienten Binance API-Integration ernst meinen, wird der Wechsel zu Apidog Ihren Entwicklungsworkflow deutlich verbessern und die Time-to-Deployment für Ihre Krypto-Projekte verkürzen.
Einrichten der Binance API-Authentifizierung
Bevor Sie die Binance API verwenden, müssen Sie API-Schlüssel von Ihrem Binance-Konto erstellen. Dieser Abschnitt behandelt, wie Sie Ihre API-Schlüssel einrichten und sichern.
Erstellen von Binance API-Schlüsseln
- Melden Sie sich bei Ihrem Binance-Konto an
- Navigieren Sie in Ihren Kontoeinstellungen zu "API-Verwaltung"
- Erstellen Sie einen neuen API-Schlüssel
- Notieren Sie sich Ihren API-Schlüssel und den geheimen Schlüssel
- Konfigurieren Sie Einschränkungen (IP-Whitelisting, Handelberechtigungen usw.)
Von der Binance API unterstützte Arten von API-Schlüsseln
Binance unterstützt drei Arten von API-Schlüssel-Authentifizierungsmethoden:
- HMAC-Schlüssel - Die gebräuchlichste Authentifizierungsmethode
- RSA-Schlüssel - Bietet erweiterte Sicherheitsfunktionen
- Ed25519-Schlüssel - Bietet die beste Leistung und Sicherheit
HMAC-Authentifizierungsbeispiel
So authentifizieren Sie sich mit HMAC-Schlüsseln:
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)
Verständnis der Binance API-Endpunkte
Die Binance API ist in mehrere Kategorien von Endpunkten unterteilt, die auf ihrer Funktionalität basieren.
Allgemeine Binance API-Endpunkte
Diese Endpunkte liefern allgemeine Informationen über die Börse:
# 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()
Marktdaten Binance API-Endpunkte
Diese Endpunkte bieten Zugriff auf Marktdaten:
# 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
Handel mit der Binance API
Mit den Handelsendpunkten können Sie Aufträge erteilen und verwalten.
Aufträge mit der Binance API erteilen
So erteilen Sie verschiedene Arten von Aufträgen:
# 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()
Verwalten von Aufträgen mit der Binance API
So fragen Sie Aufträge ab, stornieren sie und verfolgen sie:
# 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()
Konto- und Benutzerdaten mit der Binance API
Mit diesen Endpunkten können Sie auf Kontoinformationen zugreifen und Benutzerdaten streamen.
Kontoinformationen mit der Binance API
# 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()
Benutzerdatenströme mit der Binance API
# 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()
Erweiterte Binance API-Funktionen
Dieser Abschnitt behandelt einige der erweiterten Funktionen der Binance API.
Arbeiten mit Auftragslisten (OCO) in der Binance API
One-Cancels-the-Other (OCO)-Aufträge ermöglichen es Ihnen, ein Paar von Aufträgen zu erteilen, bei denen der andere automatisch storniert wird, wenn einer ausgelöst wird:
# 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()
Umgang mit Ratenbeschränkungen in der Binance API
Binance wendet Ratenbeschränkungen auf API-Anfragen an. So gehen Sie damit um:
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()
Erstellen eines vollständigen Binance API-Handels-Bots
Lassen Sie uns nun alles zusammenfügen, um einen einfachen Handels-Bot zu erstellen:
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()
Best Practices für die Verwendung der Binance API
Hier sind einige Best Practices, die Sie bei der Arbeit mit der Binance API befolgen sollten:
Sicherheitspraktiken für die Binance API
- API-Schlüsselberechtigungen einschränken: Aktivieren Sie nur die Berechtigungen, die Sie benötigen (z. B. schreibgeschützt, Handel, Auszahlungen)
- IP-Adressen auf die Whitelist setzen: Beschränken Sie Ihre API-Schlüssel so, dass sie nur von bestimmten IP-Adressen aus funktionieren
- Sichere API-Schlüsselspeicherung: API-Schlüssel niemals fest in Ihrem Code codieren, sondern Umgebungsvariablen oder sichere Tresore verwenden
- Regelmäßige Schlüsselrotation: Ändern Sie Ihre API-Schlüssel regelmäßig, um das Risiko zu mindern
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")
Fehlerbehandlung mit der Binance API
Implementieren Sie eine robuste Fehlerbehandlung, um mit API-Fehlern und Verbindungsproblemen umzugehen:
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
# ...
Fazit
Die Binance API bietet eine leistungsstarke Möglichkeit, programmgesteuert mit der Binance-Börse zu interagieren. Dieses Tutorial behandelte die wesentlichen Aspekte der Verwendung der API, von der Authentifizierung über die Auftragserteilung bis hin zur Verwaltung Ihres Kontos. Durch die Befolgung bewährter Verfahren und die Implementierung einer ordnungsgemäßen Fehlerbehandlung können Sie robuste Anwendungen und Handels-Bots erstellen, die die umfangreichen Funktionen von Binance nutzen.
Denken Sie daran, Ihre API-Schlüssel sicher aufzubewahren, die Ratenbeschränkungen zu respektieren und Ihren Code in einer Testumgebung gründlich zu testen, bevor Sie ihn mit echtem Geld verwenden. Wenn Binance seine API aktualisiert, stellen Sie sicher, dass Sie über Änderungen an den Endpunkten oder Parametern auf dem Laufenden bleiben, um sicherzustellen, dass Ihre Anwendungen weiterhin korrekt funktionieren.
Mit dem Wissen aus diesem Tutorial sollten Sie gut gerüstet sein, um Ihre eigenen Handelstools und -anwendungen mit der Binance API zu erstellen.
