Hochfrequenz-Datenanalyse — Verarbeitung von Tick-Level-Marktdaten

Hochfrequenzhandel im Kryptobereich operiert im Millisekunden-/Mikrosekundenbereich. Die Verarbeitung von Millionen Ticks pro Tag, die Bewältigung von sprunghaften Datenströmen und die Extraktion von Mikrostruktursignalen unterscheiden professionelle Händler vom Rest. Dieser Leitfaden führt durch die Verwaltung von Tick-Level-Daten und Echtzeitanalysen, die die 5-Minuten-Aktualisierungszyklen der Smart Money API ermöglichen.

Wesentliche Erkenntnis: Wale bewegen Märkte nicht sofort. Ihre Blocktrades hinterlassen erkennbare Signaturen in Orderbuch-Ungleichgewichten, Bid-Ask-Spreads und Taker-Volumenverhältnissen. Die Smart Money API erfasst diese Signaturen in Echtzeit.

Tick-Datenerfassung und -Speicherung

Datenquellen

Für Krypto stammen Tick-Daten von:

Effiziente Tick-Speicherung mit Parquet

Speichern Sie komprimierte Spaltendaten für schnelle Abfragen:

Python — Tick-Daten-Pipeline
import pandas as pd
import pyarrow.parquet as pq
# Echtzeit-Tick-Puffer (sammele für 1h, dann speichern)
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"
})
# Jede Stunde komprimieren und speichern
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 = []

Orderbuch-Analyse

Level-2-Orderbuch-Snapshots

Erfassen Sie das vollständige Orderbuch alle 100-500ms:

Python — Orderbuch-Verarbeitung
class OrderBook:
def __init__(self):
self.bids = {} # Preis -> Größe
self.asks = {} # Preis -> Größe
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):
# Hole die besten 10 Bids und 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)
# Imbalance: >1 = bullish (mehr Kaufdruck)
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 # prozentuale Spanne

Mikrostruktur-Signale

Aktionsfähige Signale aus der Orderbuch-Struktur extrahieren:

Markt-Mikrostruktur-Kennzahlen

Volumen-gewichteter Durchschnittspreis (VWAP)

Besseres Ausführungsbenchmark als einfacher Schlusskurs:

Python — VWAP-Berechnung
def calculate_vwap(ticks):
# ticks: Liste von (Preis, Volumen)-Tupeln
numerator = sum(price * volume for price, volume in ticks)
denominator = sum(volume for _, volume in ticks)
return numerator / denominator

Taker-Kauf/Verkauf-Verhältnis

Identifiziere, welche Seite aggressiv ist:

Python — Taker-Analyse
def get_taker_direction(tick):
# Wenn Handelspreis = Bid, dann war Verkäufer aggressiv (Angebot)
# Wenn Handelspreis = Ask, dann war Käufer aggressiv (Nachfrage)
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" # Innerhalb des Spreads, möglicherweise 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) # % Kauf

Echtzeit-Pipeline-Architektur

WebSocket-Stream-Verarbeitung

Verbinde dich mit Bybit/Binance/Hyperliquid WebSocket für Live-Daten:

Python — Live-Stream-Handler
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:
# Abonniere den Trade-Stream
await ws.send(json.dumps({
"op": "subscribe",
"args": [f"publicTrade.{symbol}"]
}))
async for message in ws:
data = json.loads(message)
for trade in data["data"]:
on_tick(
exchange="bybit",
symbol=symbol,
price=float(trade["price"]),
size=float(trade["size"]),
side=trade["side"],
timestamp=int(trade["time"])
)

Verteilte Verarbeitung mit Redis Streams

Verarbeiten Sie Millionen von Ticks pro Tag mit Message Queuing:

Python — Redis Stream-Verarbeitung
import redis
r = redis.Redis(host='localhost', port=6379)
# Producer: Ticks in den Stream pushen
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
})
# Consumer Group liest mit Lag-Tracking
r.xgroup_create(stream_key, "analytics", id="$", mkstream=True)

Fügen Sie Echtzeit-Signale zu Ihren Analysen hinzu

Smart Money API aggregiert Tick-Daten von 3 Börsen und 250+ Wallet-Adressen von Großinvestoren. Nutzen Sie unsere vorberechneten Mikrostruktur-Signale, um Ihre eigene Echtzeitanalyse zu verbessern.

Jetzt kostenlos starten →