Análise de Dados de Alta Frequência — Processamento de Dados de Mercado em Nível de Tick

O trading de alta frequência em criptomoedas opera em escalas de tempo de milissegundos/microssegundos. Processar milhões de ticks por dia, lidar com fluxos de dados irregulares e extrair sinais de microestrutura separa os traders profissionais dos demais. Este guia aborda o gerenciamento de dados em nível de tick e a análise em tempo real que alimentam os ciclos de atualização de 5 minutos do Smart Money API.

Principais insights: As baleias não movimentam os mercados instantaneamente. Seus blocos de negociação criam assinaturas detectáveis no desequilíbrio do livro de ordens, nos spreads bid-ask e nas proporções de volume taker. O Smart Money API captura essas assinaturas em tempo real.

Coleta e Armazenamento de Dados de Tick

Fontes de Dados

Para criptomoedas, os dados de tick vêm de:

Armazenamento Eficiente de Ticks com Parquet

Armazene dados colunares comprimidos para consultas rápidas:

Python — Pipeline de dados de tick
import pandas as pd
import pyarrow.parquet as pq
# Buffer de ticks em tempo real (acumula por 1h, depois salva)
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" or "sell"
})
# A cada hora, comprime e salva
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álise do Livro de Ordens

Snapshots do Livro de Ordens Nível 2

Capture o livro de ordens completo a cada 100-500ms:

Python — Processamento do livro de ordens
class OrderBook:
def __init__(self):
self.bids = {} # price -> size
self.asks = {} # price -> size
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):
# Obtém os 10 melhores bids e asks
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)
# Desequilíbrio: >1 = altista (mais pressão de compra)
retornar volume_compra / volume_venda se volume_venda > 0 senão 1.0
definir obter_spread(eu):
melhor_compra = max(eu.compras.keys())
melhor_venda = min(eu.vendas.keys())
retornar (melhor_venda - melhor_compra) / melhor_compra # spread percentual

Sinais de Microestrutura

Extraia sinais acionáveis da estrutura do livro de ordens:

Métricas de Microestrutura de Mercado

Preço Médio Ponderado por Volume (VWAP)

Melhor referência de execução do que o preço de fechamento simples:

Python — Cálculo do VWAP
definir calcular_vwap(ticks):
# ticks: lista de tuplas (preço, volume)
numerador = soma(preço * volume para preço, volume em ticks)
denominador = soma(volume para _, volume em ticks)
retornar numerador / denominador

Razão Compra/Venda do Taker

Identifique qual lado está sendo agressivo:

Python — Análise do Taker
definir obter_direcao_taker(tick):
# Se o preço da negociação = compra, então o vendedor foi agressivo (oferta)
# Se o preço da negociação = venda, então o comprador foi agressivo (demanda)
se abs(tick.preço - melhor_compra) < tick.passo_preco:
retornar "venda"
senão se abs(tick.preço - melhor_venda) < tick.passo_preco:
retornar "compra"
senão:
retornar "meio" # Dentro do spread, possivelmente dark pool
volume_compra = soma(t.tamanho para t em ticks se obter_direcao_taker(t) == "compra")
volume_venda = soma(t.tamanho para t em ticks se obter_direcao_taker(t) == "venda")
retornar volume_compra / (volume_compra + volume_venda) # % compra

Arquitetura de Pipeline em Tempo Real

Processamento de Fluxo WebSocket

Conecte-se ao WebSocket da Bybit/Binance/Hyperliquid para dados em tempo real:

Python — Manipulador de fluxo ao vivo
importar asyncio
importar websockets
assíncrono definir conectar_ticks_bybit(símbolo):
url = f"wss://stream.bybit.com/v5/public/spot"
assíncrono com websockets.conectar(url) como ws:
# Inscreva-se no fluxo de negociações
aguardar ws.enviar(json.dumps({
"op": "inscrever",
"args": [f"publicTrade.{símbolo}"]
}))
assíncrono para mensagem em ws:
dados = json.carregar(mensagem)
para negociação em dados["data"]:
on_tick(
exchange="bybit",
symbol=symbol,
price=float(trade["price"]),
size=float(trade["size"]),
side=trade["side"],
timestamp=int(trade["time"])
)

Processamento Distribuído com Redis Streams

Gerencie milhões de ticks por dia com filas de mensagens:

Python — Processamento de streams Redis
import redis
r = redis.Redis(host='localhost', port=6379)
# Produtor: envia ticks para a 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 lê com rastreamento de atraso
r.xgroup_create(stream_key, "analytics", id="$", mkstream=True)

Adicione sinais em tempo real à sua análise

A Smart Money API agrega dados de ticks de 3 exchanges e mais de 250 carteiras de baleias. Use nossos sinais de microestrutura pré-calculados para aprimorar sua própria análise em tempo real.

Comece Grátis Hoje →