¿Como Obtener Precios de Criptomonedas en Tiempo Real con Python y la API de Binance?
Las 10 principales criptomonedas de acuerdo a su capitalización de mercado. Fuente:
Mantenerse al día con los volátiles mercados de criptomonedas requiere acceso a datos de precios actualizados al segundo. Este artículo te mostrará cómo construir un sistema robusto de rastreo de precios en tiempo real usando Python y la API de Binance. Cubriremos todo, desde la obtención básica de precios hasta técnicas avanzadas como la integración de WebSocket, persistencia de datos y visualización.
Comenzando con la API de Binance
Binance proporciona una API poderosa que brinda a los desarrolladores acceso programático a datos de mercado y funcionalidad de trading. Para nuestros propósitos, nos enfocaremos en los endpoints públicos que no requieren autenticación. El endpoint principal que usaremos es:
https://api.binance.com/api/v3/ticker/price
Este endpoint devuelve el precio más reciente para un símbolo individual o todos los símbolos.
Para comenzar, asegúrate de tener Python 3.7+ instalado junto con las siguientes bibliotecas:
pip install requests python-binance pandas matplotlib
Pueden obtener más información sobre Binance y sus servicios de trading con cripto en la siguiente guía: Reseña de Binance
Obtención de Datos Básicos de Precios con la API de Binance
Comencemos con un script simple para obtener el precio actual de Bitcoin (BTC) contra USDT:
import requests
def get_btc_price():
url = "https://api.binance.com/api/v3/ticker/price?symbol=BTCUSDT"
response = requests.get(url)
data = response.json()
return float(data['price'])
btc_price = get_btc_price()
print(f"El precio actual de Bitcoin es: ${btc_price:.2f}")
Este script envía una solicitud GET a la API de Binance, analiza la respuesta JSON y extrae el precio. Podemos expandir esto para obtener precios de múltiples criptomonedas:
def get_crypto_prices(symbols):
base_url = "https://api.binance.com/api/v3/ticker/price"
prices = {}
for symbol in symbols:
url = f"{base_url}?symbol={symbol}"
response = requests.get(url)
data = response.json()
prices[symbol] = float(data['price'])
return prices
symbols = ['BTCUSDT', 'ETHUSDT', 'ADAUSDT', 'DOGEUSDT']
prices = get_crypto_prices(symbols)
for symbol, price in prices.items():
print(f"El precio actual de {symbol} es: ${price:.4f}")
Obtención de Actualizaciones de Precios en Tiempo Real
Para crear un sistema de rastreo verdaderamente en tiempo real, necesitamos obtener y actualizar precios continuamente. Aquí hay un script que proporciona actualizaciones continuas:
import requests
import time
def get_crypto_prices(symbols):
base_url = "https://api.binance.com/api/v3/ticker/price"
prices = {}
for symbol in symbols:
url = f"{base_url}?symbol={symbol}"
response = requests.get(url)
data = response.json()
prices[symbol] = float(data['price'])
return prices
def print_prices(prices):
for symbol, price in prices.items():
print(f"{symbol}: ${price:.4f}")
print("-" * 30)
symbols = ['BTCUSDT', 'ETHUSDT', 'ADAUSDT', 'DOGEUSDT']
while True:
prices = get_crypto_prices(symbols)
print_prices(prices)
time.sleep(5) # Esperar 5 segundos para la siguiente actualización
Este script obtendrá y mostrará precios cada 5 segundos. Puedes ajustar el valor de time.sleep() para cambiar la frecuencia de actualización.
Gestionando Límites de Tasa de la API
Binance impone límites de tasa para prevenir el abuso de la API. Para la mayoría de los endpoints públicos, el límite es de 1200 solicitudes por minuto. Para mantenerse dentro de estos límites y evitar posibles prohibiciones de IP, es crucial implementar una limitación de tasa adecuada en tu código. Aquí hay una versión mejorada de nuestro script que incluye limitación de tasa básica:
import requests
import time
from collections import deque
from datetime import datetime, timedelta
class RateLimiter:
def __init__(self, max_calls, period):
self.calls = deque()
self.max_calls = max_calls
self.period = period
def __call__(self, f):
def wrapper(*args, **kwargs):
now = datetime.now()
while self.calls and now - self.calls[0] > self.period:
self.calls.popleft()
if len(self.calls) < self.max_calls:
self.calls.append(now)
return f(*args, **kwargs)
else:
time.sleep((self.calls[0] + self.period - now).total_seconds())
return wrapper(*args, **kwargs)
return wrapper
@RateLimiter(max_calls=1200, period=timedelta(minutes=1))
def get_crypto_price(symbol):
url = f"https://api.binance.com/api/v3/ticker/price?symbol={symbol}"
response = requests.get(url)
data = response.json()
return float(data['price'])
def get_crypto_prices(symbols):
prices = {}
for symbol in symbols:
prices[symbol] = get_crypto_price(symbol)
return prices
# ... (el resto del script permanece igual)
Este script introduce una clase RateLimiter que asegura que no excedamos los límites que impone Binance al uso de su API. Básicamente decora nuestra función get_crypto_price, aplicando un máximo de 1200 llamadas por minuto.
Uso de WebSockets para Obtener Datos en Tiempo Real
Aunque consultar la API a intervalos regulares funciona, no es el método más eficiente para actualizaciones en tiempo real. Binance ofrece una API de WebSocket que permite actualizaciones de precios casi instantáneas. Con base en esto vamos a modificar nuestro script para usar WebSockets:
import asyncio
import json
from binance import AsyncClient, BinanceSocketManager
async def main():
client = await AsyncClient.create()
bm = BinanceSocketManager(client)
symbols = ['btcusdt', 'ethusdt', 'adausdt', 'dogeusdt']
async with bm.multiplex_socket([f"{symbol}@ticker" for symbol in symbols]) as stream:
while True:
res = await stream.recv()
data = json.loads(res)
symbol = data['data']['s']
price = float(data['data']['c'])
print(f"{symbol}: ${price:.4f}")
await client.close_connection()
if __name__ == "__main__":
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
Este script usa la biblioteca python-binance para conectarse a la API de WebSocket de Binance. Se suscribe a actualizaciones de ticker en tiempo real para múltiples símbolos e imprime los precios más recientes a medida que llegan. El enfoque de WebSocket es más eficiente y proporciona actualizaciones verdaderamente en tiempo real en comparación con el código anterior que hacía una revisión periódica de la API.
Implementando Persistencia de Datos
Para hacer nuestro sistema de rastreo de precios más poderoso, podemos agregar persistencia de datos. Esto nos permite almacenar datos históricos de precios para análisis posterior. Aquí hay un ejemplo usando SQLite:
import asyncio
import json
import sqlite3
from datetime import datetime
from binance import AsyncClient, BinanceSocketManager
def create_table():
conn = sqlite3.connect('crypto_prices.db')
c = conn.cursor()
c.execute('''CREATE TABLE IF NOT EXISTS prices
(symbol TEXT, price REAL, timestamp DATETIME)''')
conn.commit()
conn.close()
def insert_price(symbol, price):
conn = sqlite3.connect('crypto_prices.db')
c = conn.cursor()
now = datetime.now()
c.execute("INSERT INTO prices VALUES (?, ?, ?)", (symbol, price, now))
conn.commit()
conn.close()
async def main():
create_table()
client = await AsyncClient.create()
bm = BinanceSocketManager(client)
symbols = ['btcusdt', 'ethusdt', 'adausdt', 'dogeusdt']
async with bm.multiplex_socket([f"{symbol}@ticker" for symbol in symbols]) as stream:
while True:
res = await stream.recv()
data = json.loads(res)
symbol = data['data']['s']
price = float(data['data']['c'])
print(f"{symbol}: ${price:.4f}")
insert_price(symbol, price)
await client.close_connection()
if __name__ == "__main__":
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
Este script crea una base de datos SQLite y almacena cada actualización de precio, permitiendo el análisis de datos históricos. La función create_table() configura el esquema de la base de datos, mientras que insert_price() agrega nuevos datos de precios a la base de datos.
Visualizando los Datos de Precios
Con nuestros datos históricos en su lugar, podemos crear visualizaciones para comprender mejor las tendencias de precios. Aquí hay un script usando pandas y matplotlib para graficar tendencias de precios:
import sqlite3
import pandas as pd
import matplotlib.pyplot as plt
def plot_price_trends():
conn = sqlite3.connect('crypto_prices.db')
df = pd.read_sql_query("SELECT * FROM prices", conn)
conn.close()
df['timestamp'] = pd.to_datetime(df['timestamp'])
df = df.set_index('timestamp')
plt.figure(figsize=(12, 6))
for symbol in df['symbol'].unique():
symbol_data = df[df['symbol'] == symbol]
plt.plot(symbol_data.index, symbol_data['price'], label=symbol)
plt.title('Cryptocurrency Price Trends')
plt.xlabel('Date')
plt.ylabel('Price (USDT)')
plt.legend()
plt.grid(True)
plt.show()
plot_price_trends()
Este script lee los datos de precios de nuestra base de datos SQLite, crea un DataFrame de pandas y usa matplotlib para graficar las tendencias de precios de cada criptomoneda. La visualización resultante proporciona una imagen clara de cómo han cambiado los precios con el tiempo.
Técnicas de Análisis Avanzadas con los Datos de Precios Obtenidos Mediante Binance API
Con nuestros datos históricos y capacidades de visualización en su lugar, podemos implementar técnicas de análisis más avanzadas. Aquí hay algunos ejemplos:
Promedios Móviles: Calcular y graficar promedios móviles para identificar tendencias.
def plot_moving_averages(symbol, window=20):
conn = sqlite3.connect('crypto_prices.db')
df = pd.read_sql_query(f"SELECT * FROM prices WHERE symbol='{symbol}'", conn)
conn.close()
df['timestamp'] = pd.to_datetime(df['timestamp'])
df = df.set_index('timestamp')
df['MA'] = df['price'].rolling(window=window).mean()
plt.figure(figsize=(12, 6))
plt.plot(df.index, df['price'], label='Price')
plt.plot(df.index, df['MA'], label=f'{window}-day MA')
plt.title(f'{symbol} Price and Moving Average')
plt.xlabel('Date')
plt.ylabel('Price (USDT)')
plt.legend()
plt.grid(True)
plt.show()
plot_moving_averages('BTCUSDT', window=20)
Análisis de Volatilidad: Calcular y graficar la volatilidad de precios a lo largo del tiempo.
def plot_volatility(symbol, window=20):
conn = sqlite3.connect('crypto_prices.db')
df = pd.read_sql_query(f"SELECT * FROM prices WHERE symbol='{symbol}'", conn)
conn.close()
df['timestamp'] = pd.to_datetime(df['timestamp'])
df = df.set_index('timestamp')
df['returns'] = df['price'].pct_change()
df['volatility'] = df['returns'].rolling(window=window).std() * (252 ** 0.5) # Annualized
plt.figure(figsize=(12, 6))
plt.plot(df.index, df['volatility'])
plt.title(f'{symbol} {window}-day Volatility')
plt.xlabel('Date')
plt.ylabel('Volatility')
plt.grid(True)
plt.show()
plot_volatility('BTCUSDT', window=20)
Análisis de Correlación: Analizar la correlación entre diferentes criptomonedas.
def plot_correlation_matrix():
conn = sqlite3.connect('crypto_prices.db')
df = pd.read_sql_query("SELECT * FROM prices", conn)
conn.close()
df['timestamp'] = pd.to_datetime(df['timestamp'])
df = df.pivot(index='timestamp', columns='symbol', values='price')
corr_matrix = df.corr()
plt.figure(figsize=(10, 8))
plt.imshow(corr_matrix, cmap='coolwarm')
plt.colorbar()
plt.xticks(range(len(corr_matrix.columns)), corr_matrix.columns, rotation=45)
plt.yticks(range(len(corr_matrix.columns)), corr_matrix.columns)
plt.title('Cryptocurrency Price Correlation Matrix')
plt.tight_layout()
plt.show()
plot_correlation_matrix()
Conclusión
En esta guía completa, hemos explorado varios aspectos del rastreo de precios de criptomonedas en tiempo real usando Python y la API de Binance. Hemos cubierto la obtención básica de precios, actualizaciones en tiempo real usando tanto sondeo como WebSockets, limitación de tasa, persistencia de datos, visualización y técnicas de análisis avanzadas.
Al combinar estas herramientas y técnicas, puedes crear un sistema de rastreo de precios de criptomonedas poderoso y flexible adaptado a tus necesidades específicas. Ya seas un trader buscando información en tiempo real, un desarrollador construyendo una aplicación relacionada con cripto, o simplemente un entusiasta curioso sobre las tendencias del mercado, el conocimiento proporcionado aquí servirá como una base sólida para tus proyectos.
Recuerda siempre respetar los límites de tasa de la API y los términos de servicio al trabajar con APIs externas como Binance. A medida que continúes desarrollando tu sistema de rastreo de precios, considera explorar características adicionales como estrategias de trading automatizado, análisis de sentimiento de noticias cripto, o integración con otras fuentes de datos para crear una herramienta de análisis de mercado más completa.
El mundo de las criptomonedas está en constante evolución, y tener acceso a datos en tiempo real y herramientas de análisis poderosas puede darte una ventaja significativa para comprender y navegar este emocionante mercado.
También podemos usar otras API para obtener datos financieros y hacer análisis del mercado a través de Python. Pueden consultar los siguientes artículos:
