Guía de WebSocket en Python para la API de Backpack Exchange
Esta guía demuestra cómo usar la API WebSocket de Backpack Exchange con Python. Los WebSockets proporcionan flujos de datos en tiempo real para datos de mercado y actualizaciones de cuenta.
Prerequisitos
Obtén tus claves API si vas a usar streams privados: https://backpack.exchange/portfolio/settings/api-keys
Instala las librerías de Python necesarias:
websockets - para conexiones WebSocket
cryptography - para X-Signature (solo streams privados)
pip install websockets cryptographyInstala dotenv-python para gestionar de forma segura tus claves usando variables de entorno si vas a usar streams privados
pip install python-dotenvCrea un archivo .env y almacena tus claves así:
PUBLIC_KEY=zDIJj9qneWIY0IYZ5aXoHcNMCm+XDhVcTssiT0HyY0A=
SECRET_KEY=4odxgSUxFrC/zsKWZF4OQwYAgnNu9hnWH3NxWfLAPz4=Crea un archivo .gitignore y añade .env para excluirlo del control de versiones.
.envImporta las librerías necesarias:
import json
import asyncio
import websockets
import base64
from time import time
import os
from cryptography.hazmat.primitives.asymmetric import ed25519
from dotenv import load_dotenv, find_dotenvBásicos de la API WebSocket
La API WebSocket de Backpack Exchange está disponible en wss://ws.backpack.exchange.
Los streams WebSocket se nombran usando el formato: <type>.<symbol>
Por ejemplo:
depth.SOL_USDC- Libro de órdenes para SOL/USDCtrade.SOL_USDC- Trades para SOL/USDC
Por qué usar Async con WebSockets
Los WebSockets están diseñados para conexiones de larga duración que reciben datos en tiempo real. Usar programación asíncrona con WebSockets ofrece varias ventajas:
E/S no bloqueante: Async permite que tu aplicación maneje múltiples conexiones sin bloquear el hilo principal.
Eficiencia de recursos: Async usa menos recursos que crear múltiples hilos para conexiones concurrentes.
Mejor rendimiento: Async puede manejar muchas conexiones con menos overhead que enfoques síncronos.
Procesamiento en tiempo real: Async es ideal para flujos de datos en tiempo real donde necesitas recibir y procesar datos continuamente.
Desventajas de los enfoques síncronos:
Threading complejo: Requiere gestión manual de hilos
Intensivo en recursos: Cada conexión necesita su propio hilo
Manejo de errores difícil: La propagación de errores entre hilos es compleja
Problemas de escalabilidad: No escala bien con muchas conexiones
El enfoque async (como se muestra en nuestros ejemplos) es mucho más limpio, eficiente y fácil de mantener.
Streams públicos
Los streams públicos no requieren autenticación. Puedes suscribirte a ellos directamente.
Ejemplo: Suscribiéndose a un stream público
async def subscribe_to_public_stream():
uri = "wss://ws.backpack.exchange"
async with websockets.connect(uri) as websocket:
# Subscribe to the depth stream for SOL/USDC
subscribe_message = {
"method": "SUBSCRIBE",
"params": ["depth.SOL_USDC"]
}
await websocket.send(json.dumps(subscribe_message))
print(f"Subscribed to depth.SOL_USDC stream")
# Process incoming messages
while True:
response = await websocket.recv()
data = json.loads(response)
print(f"Received: {data}")
# You can process the data here based on your needs
# For example, update a local order book
# To run the async function in a Jupyter notebook, use:
# await subscribe_to_public_stream()
#
# TO run in your code
# asyncio.run(subscribe_to_public_stream()) Ejemplo: Suscribiéndose a múltiples streams públicos
async def subscribe_to_multiple_streams():
uri = "wss://ws.backpack.exchange"
async with websockets.connect(uri) as websocket:
# Subscribe to multiple streams
subscribe_message = {
"method": "SUBSCRIBE",
"params": ["depth.SOL_USDC", "trade.SOL_USDC"]
}
await websocket.send(json.dumps(subscribe_message))
print(f"Subscribed to multiple streams")
# Process incoming messages
while True:
response = await websocket.recv()
data = json.loads(response)
print(f"Received: {data}")
# Process different stream data based on the stream name
if "stream" in data and "data" in data:
stream_name = data["stream"]
stream_data = data["data"]
if stream_name.startswith("depth."):
# Process order book data
print(f"Order book update: {stream_data}")
elif stream_name.startswith("trade."):
# Process trade data
print(f"Trade update: {stream_data}")
# Run the async function in a Jupyter notebook:
# await subscribe_to_multiple_streams()
#
# To run in your code
# asyncio.run(subscribe_to_multiple_streams())Streams privados
Los streams privados requieren autenticación con tus claves API. Estos streams tienen el prefijo account. y proporcionan actualizaciones sobre tu cuenta.
Autenticación para streams privados
Para autenticarte para streams privados, necesitas:
Crear un string de firma de la forma:
instruction=subscribe×tamp=1614550000000&window=5000Firmarlo con tu clave privada
Incluir los datos de firma en tu mensaje de suscripción como un array:
"signature": ["<verifying key>", "<signature>", "<timestamp>", "<window>"]
Los streams privados tienen el prefijo account. y requieren que se envíen datos de firma en los parámetros de suscripción. La clave verificadora y la firma deben estar codificadas en base64.
# Load API keys from .env file
# load_dotenv(find_dotenv())
# public_key = os.getenv("PUBLIC_KEY")
# secret_key = os.getenv("SECRET_KEY")
# For demonstration purposes only - don't hardcode keys in production
public_key = "5+yQgwU0ZdJ/9s+GXfuPFfo7yQQpl9CgvQedJXne30o="
secret_key = "TDSkv44jf/iD/QCKkyCdixO+p1sfLXxk+PZH7mW/ams="
# Create private key from secret key
private_key = ed25519.Ed25519PrivateKey.from_private_bytes(
base64.b64decode(secret_key)
)Ejemplo: Suscribiéndose a un stream privado
async def subscribe_to_private_stream():
uri = "wss://ws.backpack.exchange"
# Generate authentication parameters
timestamp = int(time() * 1e3) # Unix time in milliseconds
window = "5000" # Time window in milliseconds
# Create signature string
sign_str = f"instruction=subscribe×tamp={timestamp}&window={window}"
# Sign the string
signature_bytes = private_key.sign(sign_str.encode())
encoded_signature = base64.b64encode(signature_bytes).decode()
async with websockets.connect(uri) as websocket:
# Subscribe to the order stream with authentication
subscribe_message = {
"method": "SUBSCRIBE",
"params": ["account.orderUpdate"],
"signature": [public_key, encoded_signature, str(timestamp), window]
}
await websocket.send(json.dumps(subscribe_message))
print(f"Subscribed to account.order stream")
# Process incoming messages
while True:
response = await websocket.recv()
data = json.loads(response)
print(f"Received: {data}")
# Process order updates
if "stream" in data and data["stream"] == "account.order" and "data" in data:
order_data = data["data"]
print(f"Order update: {order_data}")
# Run the async function in a Jupyter notebook:
await subscribe_to_private_stream()
#
# If using nest_asyncio (recommended):
# asyncio.run(subscribe_to_private_stream())WebSocket Ping/Pong
Las conexiones WebSocket requieren un mecanismo ping-pong para mantener la conexión activa. La buena noticia es que la librería websockets de Python maneja esto automáticamente
Fuentes
Para más información visita la documentación oficial: https://docs.backpack.exchange/#tag/Streams
Last updated