Introducción a la API de Binance
La API de Binance proporciona a los desarrolladores acceso programático a la plataforma de trading de Binance, lo que les permite crear bots de trading, aplicaciones y herramientas que interactúan con el exchange. Este tutorial te guiará a través del proceso de uso de la API de Binance, desde la configuración de la autenticación hasta la realización de varios tipos de solicitudes.
Si bien muchos desarrolladores tradicionalmente han confiado en Postman para las pruebas de API, Apidog ofrece una experiencia más ágil y especializada para trabajar con API de criptomonedas como Binance. Con su interfaz intuitiva, manejo mejorado de la autenticación y funciones integradas específicas para criptomonedas, Apidog reduce significativamente el tiempo de configuración necesario para comenzar a probar e implementar los endpoints de la API de Binance.
Las herramientas de colaboración en tiempo real de la plataforma y las capacidades integrales de generación de documentación la hacen particularmente valiosa para los equipos que trabajan en aplicaciones de trading de criptomonedas.
Si te tomas en serio la integración eficiente de la API de Binance, cambiar a Apidog mejorará notablemente tu flujo de trabajo de desarrollo y reducirá el tiempo de implementación de tus proyectos de criptomonedas.
Configuración de la autenticación de la API de Binance
Antes de usar la API de Binance, debes crear claves API desde tu cuenta de Binance. Esta sección cubre cómo configurar y proteger tus claves API.
Creación de claves API de Binance
- Inicia sesión en tu cuenta de Binance
- Navega a "Gestión de API" en la configuración de tu cuenta
- Crea una nueva clave API
- Anota tu clave API y clave secreta
- Configura las restricciones (lista blanca de IP, permisos de trading, etc.)
Tipos de claves API admitidas por la API de Binance
Binance admite tres tipos de métodos de autenticación de clave API:
- Claves HMAC: el método de autenticación más común
- Claves RSA: ofrece funciones de seguridad mejoradas
- Claves Ed25519: proporciona el mejor rendimiento y seguridad
Ejemplo de autenticación HMAC
Aquí te mostramos cómo autenticarte con claves 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)
Comprensión de los endpoints de la API de Binance
La API de Binance está organizada en varias categorías de endpoints según su funcionalidad.
Endpoints generales de la API de Binance
Estos endpoints proporcionan información general sobre el exchange:
# 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()
Endpoints de datos de mercado de la API de Binance
Estos endpoints proporcionan acceso a datos de mercado:
# 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 con la API de Binance
Los endpoints de trading te permiten realizar y gestionar órdenes.
Realización de órdenes con la API de Binance
Aquí te mostramos cómo realizar diferentes tipos de órdenes:
# 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()
Gestión de órdenes con la API de Binance
Aquí te mostramos cómo consultar, cancelar y rastrear órdenes:
# 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()
Datos de cuenta y usuario con la API de Binance
Estos endpoints te permiten acceder a la información de la cuenta y transmitir datos de usuario.
Información de la cuenta con la API de 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()
Flujos de datos de usuario con la API de 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()
Funciones avanzadas de la API de Binance
Esta sección cubre algunas de las funciones más avanzadas de la API de Binance.
Trabajo con listas de órdenes (OCO) en la API de Binance
Las órdenes One-Cancels-the-Other (OCO) te permiten realizar un par de órdenes donde si una se activa, la otra se cancela automáticamente:
# 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()
Manejo de límites de velocidad en la API de Binance
Binance aplica límites de velocidad a las solicitudes de API. Aquí te mostramos cómo manejarlos:
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()
Construcción de un bot de trading completo con la API de Binance
Ahora juntemos todo para construir un bot de trading simple:
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()
Mejores prácticas para usar la API de Binance
Aquí hay algunas mejores prácticas a seguir al trabajar con la API de Binance:
Prácticas de seguridad para la API de Binance
- Restringir los permisos de la clave API: solo habilita los permisos que necesitas (por ejemplo, solo lectura, trading, retiros)
- Lista blanca de direcciones IP: restringe tus claves API para que solo funcionen desde direcciones IP específicas
- Almacenamiento seguro de claves API: nunca codifiques claves API en tu código, usa variables de entorno o bóvedas seguras
- Rotación regular de claves: cambia tus claves API periódicamente para mitigar el riesgo
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")
Manejo de errores con la API de Binance
Implementa un manejo de errores robusto para lidiar con errores de API y problemas de conexión:
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
# ...
Conclusión
La API de Binance ofrece una forma poderosa de interactuar con el exchange de Binance mediante programación. Este tutorial cubrió los aspectos esenciales del uso de la API, desde la autenticación hasta la realización de órdenes y la gestión de tu cuenta. Siguiendo las mejores prácticas e implementando un manejo de errores adecuado, puedes crear aplicaciones y bots de trading robustos que aprovechen el extenso conjunto de funciones de Binance.
Recuerda mantener tus claves API seguras, respetar los límites de velocidad y probar a fondo tu código en un entorno de prueba antes de usarlo con fondos reales. A medida que Binance actualice su API, asegúrate de mantenerte informado sobre cualquier cambio en los endpoints o parámetros para garantizar que tus aplicaciones sigan funcionando correctamente.
Con el conocimiento adquirido en este tutorial, deberías estar bien equipado para comenzar a construir tus propias herramientas y aplicaciones de trading utilizando la API de Binance.
