Análisis de Datos de Alta Frecuencia — Procesamiento de Datos de Mercado a Nivel de Tick

El trading de alta frecuencia en cripto opera en escalas de tiempo de milisegundos/microsegundos. Procesar millones de ticks por día, manejar flujos de datos explosivos y extraer señales de microestructura separa a los traders profesionales del resto. Esta guía recorre la gestión de datos a nivel de tick y el análisis en tiempo real que impulsan los ciclos de actualización de 5 minutos de Smart Money API.

Conclusión clave: Las ballenas no mueven los mercados instantáneamente. Sus bloques de operaciones crean firmas detectables en el desequilibrio del libro de órdenes, los spreads bid-ask y las proporciones de volumen taker. Smart Money API captura estas firmas en tiempo real.

Recopilación y Almacenamiento de Datos de Tick

Fuentes de Datos

Para cripto, los datos de tick provienen de:

Almacenamiento Eficiente de Ticks con Parquet

Almacene datos columnares comprimidos para consultas rápidas:

Python — Canalización de datos de tick
import pandas as pd
import pyarrow.parquet as pq
# Búfer de ticks en tiempo real (acumular durante 1h, luego guardar)
tick_buffer = []
def on_tick(exchange, symbol, price, size, side, timestamp):
tick_buffer.append({
"timestamp": timestamp,
"exchange": exchange,
"symbol": symbol,
"price": price,
"size": size,
"side": side # "buy" o "sell"
})
# Cada hora, comprimir y guardar
if len(tick_buffer) > 1_000_000:
df = pd.DataFrame(tick_buffer)
pq.write_table(
pa.Table.from_pandas(df),
f"ticks/{symbol}_{timestamp:%Y%m%d_%H}.parquet",
compression="snappy"
)
tick_buffer = []

Análisis del Libro de Órdenes

Instantáneas del Libro de Órdenes Nivel 2

Capture el libro de órdenes completo cada 100-500ms:

Python — Procesamiento del libro de órdenes
class OrderBook:
def __init__(self):
self.bids = {} # precio -> tamaño
self.asks = {} # precio -> tamaño
def update(self, side, price, size):
if side == "bid":
if size == 0: del self.bids[price]
else: self.bids[price] = size
else:
if size == 0: del self.asks[price]
else: self.asks[price] = size
def get_imbalance(self, depth=10):
# Obtener las 10 mejores ofertas y demandas
top_bids = sorted(self.bids.items(), reverse=True)[:depth]
top_asks = sorted(self.asks.items())[:depth]
bid_volume = sum(size for _, size in top_bids)
ask_volume = sum(size for _, size in top_asks)
# Desequilibrio: >1 = alcista (más presión de compra)
return bid_volume / ask_volume if ask_volume > 0 else 1.0
def get_spread(self):
best_bid = max(self.bids.keys())
best_ask = min(self.asks.keys())
return (best_ask - best_bid) / best_bid # diferencial porcentual

Señales de Microestructura

Extraiga señales accionables de la estructura del libro de órdenes:

Métricas de Microestructura de Mercado

Precio Medio Ponderado por Volumen (VWAP)

Mejor referencia de ejecución que el precio de cierre simple:

Python — Cálculo de VWAP
def calculate_vwap(ticks):
# ticks: lista de tuplas (precio, volumen)
numerator = sum(price * volume for price, volume in ticks)
denominator = sum(volume for _, volume in ticks)
return numerator / denominator

Ratio Comprador/Vendedor Taker

Identifique qué lado está siendo agresivo:

Python — Análisis Taker
def get_taker_direction(tick):
# Si el precio de la operación = bid, entonces el vendedor fue agresivo (oferta)
# Si el precio de la operación = ask, entonces el comprador fue agresivo (demanda)
if abs(tick.price - best_bid) < tick.price_step:
return "sell"
elif abs(tick.price - best_ask) < tick.price_step:
return "buy"
else:
return "mid" # Dentro del spread, posiblemente dark pool
buy_volume = sum(t.size for t in ticks if get_taker_direction(t) == "buy")
sell_volume = sum(t.size for t in ticks if get_taker_direction(t) == "sell")
return buy_volume / (buy_volume + sell_volume) # % compra

Arquitectura de Pipeline en Tiempo Real

Procesamiento de Flujo WebSocket

Conéctate al WebSocket de Bybit/Binance/Hyperliquid para datos en vivo:

Python — Manejador de transmisión en vivo
import asyncio
import websockets
async def connect_bybit_ticks(symbol):
url = f"wss://stream.bybit.com/v5/public/spot"
async with websockets.connect(url) as ws:
# Suscribirse al flujo de trades
await ws.send(json.dumps({
"op": "subscribe",
"args": [f"publicTrade.{symbol}"]
}))
async for message in ws:
data = json.loads(message)
for trade en datos["data"]:
on_tick(
exchange="bybit",
symbol=symbol,
price=float(trade["price"]),
size=float(trade["size"]),
side=trade["side"],
timestamp=int(trade["time"])
)

Procesamiento Distribuido con Redis Streams

Maneja millones de ticks por día con colas de mensajes:

Python — Procesamiento de streams en Redis
import redis
r = redis.Redis(host='localhost', port=6379)
# Productor: envía ticks al stream
def publish_tick(exchange, symbol, tick):
stream_key = f"ticks:{exchange}:{symbol}"
r.xadd(stream_key, {
"price": tick.price,
"size": tick.size,
"side": tick.side,
"ts": tick.timestamp
})
# Grupo de consumidores lee con seguimiento de retraso
r.xgroup_create(stream_key, "analytics", id="$", mkstream=True)

Añade señales en tiempo real a tus análisis

Smart Money API agrega datos de ticks de 3 exchanges y más de 250 wallets de ballenas. Utiliza nuestras señales de microestructura precalculadas para mejorar tu propio análisis en tiempo real.

Empieza Gratis Hoy →