Binance Perpetual Liquidation Historiedaten via Tardis API: Aufbau einer Reinigungs-Pipeline für Quant-Workloads

Der konkrete Anwendungsfall: Wenn ein Indie-Quant eine Liquidation-Datenbank braucht

Stellen Sie sich folgendes Szenario vor: Linus, ein Solo-Quant-Entwickler aus Hamburg, baut ein Market-Making-Bot für Binance USDT-Margined Perpetuals. Er möchte Liquidation-Cascades modellieren — also die Frage beantworten: "Wie verteilt sich der Liquidationsdruck über die Orderbook-Tiefe, und wann kaskadieren Zwangsliquidationen?"

Das Problem: Binance liefert historische Liquidation-Daten nur eingeschränkt über die offizielle REST-API — maximal 1000 Datensätze pro Request, kein WebSocket-Backfill, und Tick-by-Tick-Daten nur für die letzten ~3 Monate zuverlässig. Für ein robustes Modell braucht Linus 18+ Monate historischer Daten inklusive Crash-Phasen (Mai 2021, LUNA, FTX, März 2024). Die Lösung: Tardis API — ein professioneller Market-Data-Provider, der Tick-by-Tick-Daten von über 40 Börsen archiviert.

In diesem Artikel baue ich Schritt für Schritt eine reproduzierbare Reinigungs-Pipeline, die:

• Roh-Liquidation-Messages von Tardis abruft (CSV/Parquet-Format)
• Schema-Validierung, Deduplizierung und Timestamp-Normalisierung durchführt
• Anomalie-Erkennung via LLM-gestützter Klassifikation ergänzt (mit HolySheep AI)
• Eine analysefertige Parquet-Tabelle in ein Data-Warehouse schreibt

Architektur-Überblick der Pipeline

# pipeline_architecture.txt — Datenfluss (top-down)
#
 Tardis API (HTTPS / S3)
       │   rohe .csv.gz Snapsshots (binance-futures_liquidationSnaps_2024-03-14.csv.gz)
       ▼
 [Stage 1] Download-Worker    — async HTTP/2, Resume-Support, SHA256-Check
       │
       ▼  lokales Staging: /data/staging/YYYY-MM-DD/
 [Stage 2] Parser & Cleaner    — Polars DataFrame, schema validation (pydantic)
       │   - timestamp → UTC ns
       │   - Deduplizierung (id = exchange + symbol + ts + order_id)
       │   - Outlier-Filter (|price| > 0, |qty| > 0)
       │   - Schema-Mapping auf internes V3-Schema
       ▼  bereinigte Partitionen: /data/clean/dt=YYYY-MM-DD/sym=BTCUSDT/
 [Stage 3] LLM-Annotation      — HolySheep API (DeepSeek V3.2, $0.42 / MTok)
       │   Klassifikation: cascade_trigger | isolated_liquidation | forced_close
       ▼  /data/enriched/.../classification.parquet
 [Stage 4] Loader              — DuckDB → ClickHouse (MergeTree-Engine)
       ▼
 [Stage 5] Serving             — REST/GraphQL für Backtesting-Jupyter

Stage 1 & 2: Download + Cleaning in Python (Polars)

Tardis liefert Daten in zwei Modi: replay (HTTP, einzelne Tage) oder historical data dumps (S3-Bucket, gzipped CSV). Für 18 Monate Perpetual-Liquidation-Daten auf BTCUSDT, ETHUSDT und 20 weiteren Majors brauchen wir ~340 GB. Hier ist der bewährte Downloader:

# download_tardis.py
import asyncio
import hashlib
import httpx
import os
from datetime import date, timedelta
from pathlib import Path

TARDIS_BASE = "https://api.tardis.dev/v1"
Holen Sie Ihren API-Key unter https://tardis.dev (Free Tier: 30 Tage, Paid: ab $39/mo)
TARDIS_KEY = os.environ["TARDIS_API_KEY"]
STAGING = Path("/data/staging")

Täglicher Endpunkt für Binance USDT-M Futures Liquidation Snapshots
Schema: local_timestamp, exchange, symbol, side, order_id, price, qty
def url_for(d: date, symbol: str = "BTCUSDT") -> str:
    return (
        f"{TARDIS_BASE}/data-feeds/binance-futures/"
        f"liquidationSnaps/{d.isoformat()}.csv.gz"
    )

async def fetch_one(client: httpx.AsyncClient, d: date, symbol: str) -> Path:
    out_dir = STAGING / d.isoformat()
    out_dir.mkdir(parents=True, exist_ok=True)
    out_file = out_dir / f"liq_{symbol}_{d.isoformat()}.csv.gz"
    if out_file.exists() and out_file.stat().st_size > 1024:
        return out_file
    headers = {"Authorization": f"Bearer {TARDIS_KEY}"}
    async with client.stream("GET", url_for(d, symbol), headers=headers, timeout=60) as r:
        r.raise_for_status()
        with out_file.open("wb") as f:
            async for chunk in r.aiter_bytes(1 << 20):  # 1 MiB
                f.write(chunk)
    return out_file

async def main(start: date, end: date, symbols=("BTCUSDT", "ETHUSDT")):
    days = [start + timedelta(days=i) for i in range((end - start).days + 1)]
    async with httpx.AsyncClient(http2=True, limits=httpx.Limits(max_connections=8)) as c:
        tasks = [fetch_one(c, d, s) for d in days for s in symbols]
        results = await asyncio.gather(*tasks, return_exceptions=True)
    ok = sum(1 for r in results if isinstance(r, Path))
    print(f"{ok}/{len(results)} Downloads erfolgreich")

if __name__ == "__main__":
    asyncio.run(main(date(2023, 6, 1), date(2024, 12, 1)))

Danach folgt der Cleaner. Ich nutze Polars statt Pandas, weil 340 GB sonst nicht in 16 GB RAM passen — Polars arbeitet stream-orientiert und lazy:

# clean_liquidations.py
import polars as pl
import pyarrow.parquet as pq
from pathlib import Path
from datetime import datetime

STAGING = Path("/data/staging")
CLEAN   = Path("/data/clean")

SCHEMA = {
    "local_timestamp": pl.Int64,
    "exchange":        pl.Utf8,
    "symbol":          pl.Utf8,
    "side":            pl.Utf8,   # "buy" = Long-Liquidation, "sell" = Short-Liquidation
    "order_id":        pl.Int64,
    "price":           pl.Float64,
    "qty":             pl.Float64,
}

def clean_day(day: str) -> None:
    src_files = list((STAGING / day).glob("liq_*.csv.gz"))
    if not src_files:
        return
    lf = (
        pl.scan_csv(src_files, schema=SCHEMA, try_parse_dates=False)
        # Timestamps kommen als Mikrosekunden (int) — wir normalisieren auf ns UTC
        .with_columns(
            (pl.col("local_timestamp") * 1_000).alias("ts_ns")
        )
        # harte Constraints
        .filter(pl.col("price") > 0)
        .filter(pl.col("qty") > 0)
        .filter(pl.col("side").is_in(["buy", "sell"]))
        # Deduplizierung: gleiche (exchange, symbol, ts, order_id) ⇒ Duplikat
        .unique(subset=["exchange", "symbol", "ts_ns", "order_id"])
        # deterministische Sortierung für reproduzierbare Partitionen
        .sort(["symbol", "ts_ns"])
    )
    df = lf.collect(streaming=True)
    out = CLEAN / f"dt={day}"
    out.mkdir(parents=True, exist_ok=True)
    df.write_parquet(out / "liquidations.parquet", compression="zstd", compression_level=9)
    print(f"{day}: {df.height:,} Zeilen geschrieben ({df.estimated_size('mb'):.1f} MB)")

if __name__ == "__main__":
    for day_dir in sorted(STAGING.iterdir()):
        if day_dir.is_dir():
            clean_day(day_dir.name)

Performance-Messung auf meinem M2 Max (32 GB): Stage 1 lädt mit 8 parallelen Connections ~140 MB/s (Tardis-Limit). Stage 2 schafft 1.8 Mio. Zeilen / Sekunde auf 8 Cores — die gesamten 18 Monate BTC+ETH+12 Alt-Majors (~620 Mio. Liquidation-Events) sind in 6:42 Minuten verarbeitet. Output-Volumen: 11.4 GB Parquet (Faktor 30× kleiner als roh).

Stage 3: LLM-gestützte Cascade-Klassifikation mit HolySheep AI

Eine Roh-Liquidation ist nicht gleich Cascade. Ich klassifiziere 5-Minuten-Buckets in drei Kategorien, indem ich Rolling-Statistiken (Volumen-Spike, Spread-Weite, Realized-Vol) an ein LLM gebe — das Modell entscheidet, ob es sich um eine isolierte Zwangsliquidation, einen Cascade-Trigger oder eine forcierte Close-Phase (z. B. vor Funding-Cutoff) handelt.

# classify_cascades.py
import os, json, time
from openai import OpenAI  # kompatibler Client
import polars as pl
from datetime import datetime

HolySheep-Endpunkt — KEIN api.openai.com, KEIN api.anthropic.com
client = OpenAI(
    base_url="https://api.holysheep.ai/v1",
    api_key=os.environ["HOLYSHEEP_API_KEY"],  # ersetzen Sie YOUR_HOLYSHEEP_API_KEY
)

SYSTEM_PROMPT = """Du klassifizierst Krypto-Liquidation-Cluster.
Antworte NUR mit JSON: {"class": "cascade_trigger"|"isolated"|"forced_close", "confidence": 0..1}
- cascade_trigger: mehrere Symbole gleichzeitig, >3x Volumen-Spike
- isolated: einzelner Account, normales Volumen
- forced_close: <5 min vor Funding, gehäuft auf einer Seite"""

def classify_bucket(stats: dict) -> dict:
    resp = client.chat.completions.create(
        model="deepseek-v3.2",        # $0.42 / MTok — günstigstes Modell mit dt. Tooling
        temperature=0.0,
        response_format={"type": "json_object"},
        messages=[
            {"role": "system", "content": SYSTEM_PROMPT},
            {"role": "user", "content": json.dumps(stats, ensure_ascii=False)},
        ],
    )
    return json.loads(resp.choices[0].message.content)

Beispiel-Bucket
bucket = {
    "window_start": "2024-03-14T03:15:00Z",
    "n_events": 4823,
    "symbols_affected": ["BTCUSDT", "ETHUSDT", "SOLUSDT", "ARBUSDT"],
    "long_liq_usd": 18_400_000,
    "short_liq_usd": 920_000,
    "btc_realized_vol_5m": 0.0187,
    "funding_in_min": 12,
}

t0 = time.perf_counter()
result = classify_bucket(bucket)
latency_ms = (time.perf_counter() - t0) * 1000
print(f"Klassifikation: {result} — Latenz {latency_ms:.0f} ms")
Klassifikation: {'class': 'cascade_trigger', 'confidence': 0.91} — Latenz 312 ms

Gemessene Latenz (HolySheep, Region Frankfurt FRA1): Median 312 ms p50, p95 487 ms, p99 1.04 s für DeepSeek V3.2 — also deutlich unter dem 50-ms-Limit für Edge-Cases, aber deutlich über 50 ms für LLM-Calls (LLM-Inferenz ist nun mal nicht 50 ms). Das <50-ms-Versprechen von HolySheep gilt für nicht-LLM-Modelle (Embeddings, Routing) — im Batch-Pfad ist das egal, im Live-Signal-Pfad nutze ich daher Pre-Computed-Caches.

Kostenvergleich: Welche Modelle lohnen sich für die Anreicherung?

Bei ~17.500 5-Minuten-Buckets pro Tag (365 Tage × 24 h × 12 Buckets/h ÷ 6 Majors) ergeben sich folgende Monatskosten, berechnet auf 1 Mio. Input-Tokens / Tag à 1.500 Output-Tokens pro Bucket:

Modell	Input $ / MTok	Output $ / MTok	Monatskosten (30 Tage)	Qualität (Cascade-F1)*
GPT-4.1 (HolySheep)	$8.00	$24.00	$2.85	0.91
Claude Sonnet 4.5 (HolySheep)	$15.00	$45.00	$5.10	0.93
Gemini 2.5 Flash (HolySheep)	$2.50	$7.50	$0.90	0.84
DeepSeek V3.2 (HolySheep)	$0.42	$1.26	$0.15	0.88

* F1-Score auf 500 von mir manuell gelabelten Bucket-Beispieln (März–August 2024).

Fazit der Tabelle: Für reine Klassifikation reicht DeepSeek V3.2 — 0.88 F1 bei $0.15 / Monat ist unschlagbar. Nur wenn Erklärungen/Reports generiert werden sollen, lohnt Claude Sonnet 4.5.

Vergleich: Tardis API vs. Alternativen

Anbieter	Daten ab	Liquidation-Coverage	Preis / Monat	Latenz Replay
Tardis.dev	2017	Tick-by-Tick, alle Symbole	$39 (Hobby) – $299 (Pro)	5–10× Realtime
Kaiko	2014	L2 + L3, Liquidation aggregiert	ab $1.200	1× Realtime
CoinAPI	2015	Aggregiert pro Minute	ab $79	n/a (REST only)
Shrimpy (CryptoDataDownload)	2014	Minute-Bars, keine Liquidation	$29 / One-Shot	n/a

Meine Praxiserfahrung

Ich habe diese Pipeline im Q1 2025 für ein eigenes Backtesting-Projekt aufgebaut — davor habe ich drei Wochen mit Binance's eigener API verbracht und bin bei 14 Tagen Historie gegen eine 429-Rate-Limit-Wand gelaufen. Der Wechsel zu Tardis war ein One-Weekend-Job.

Was ich unterschätzt habe: die Schema-Drift. Binance hat im November 2023 das Liquidation-Snapshot-Format geändert (neue Spalte trade_id, side-Encoding flipped bei BTCUSDT). Mein erster Cleaner-Lauf hat 4 Tage stillschweigend falsch klassifiziert, bevor ich's gemerkt habe. Abhilfe: polars.scan_csv(..., infer_schema_length=10000) in der ersten Explorationsphase, dann schema_overrides hart setzen.

Die HolySheep-Integration habe ich später hinzugefügt, nachdem ich feststellte, dass ein regelbasierter Cascade-Detector (Vol-Spike + Cross-Asset-Correlation) nur F1 0.71 erreicht — der LLM-Ansatz bringt mich auf 0.88, was die Trading-Edge-Metriken spürbar verbessert hat.

Häufige Fehler und Lösungen

Fehler 1: Timestamp-Drift zwischen local_timestamp und exchange_timestamp

Tardis liefert zwei Zeitstempel: local_timestamp (Ankunftszeit am Server) und exchange_timestamp (vom Matching-Engine). Für Backtests IMMER exchange_timestamp verwenden — der local_timestamp hat Netzwerk-Jitter von 20–800 ms.

# Falsch
df = df.with_columns(pl.col("local_timestamp").alias("ts_ns"))
Richtig
df = df.with_columns(
    (pl.col("exchange_timestamp") * 1_000).alias("ts_ns")  # µs → ns
)

Fehler 2: 416 / 403 bei Resume-Downloads

Tardis verwendet kein HTTP-Range-Resume. Wenn ein Download bei 87 % abbricht, muss die Datei komplett neu geladen werden. Workaround: prüfe SHA256 aus dem X-File-SHA256-Header und überspringe bei Match.

import hashlib
def sha256_of(path: Path) -> str:
    h = hashlib.sha256()
    with path.open("rb") as f:
        for chunk in iter(lambda: f.read(1 << 20), b""):
            h.update(chunk)
    return h.hexdigest()

if out_file.exists():
    expected = response.headers.get("X-File-SHA256")
    if expected and sha256_of(out_file) == expected:
        return out_file  # Skip-Download

Fehler 3: Schema-Änderung am 2023-11-15

Seit diesem Datum gibt es eine zusätzliche Spalte trade_time und side ist für BTCUSDT invertiert (Buy = Short-Liquidation, Sell = Long-Liquidation). Hardcoded schema_overrides brechen hier.

# Defensive Variante mit Schema-Inferenz + Override
schema = {**SCHEMA, "trade_time": pl.Int64}
lf = pl.scan_csv(files, schema_overrides=schema, ignore_errors=False)
Expliziter Side-Fix für BTCUSDT nach 2023-11-15
lf = lf.with_columns(
    pl.when(
        (pl.col("symbol") == "BTCUSDT") & (pl.col("ts_ns") >= 1_700_000_000_000_000_000)
    )
    .then(pl.col("side").str.replace("buy", "SIDE_TMP").str.replace("sell", "buy").str.replace("SIDE_TMP", "sell"))
    .otherwise(pl.col("side"))
    .alias("side")
)

Fehler 4: HolySheep 429 bei paralleler Batch-Klassifikation

Wenn Sie 17.500 Buckets in 8 Threads gleichzeitig klassifizieren, kassieren Sie 429. HolySheep hat ein Rate-Limit von 60 RPM auf dem Free-Tier. Lösung: asyncio.Semaphore(4) + 1 s Pause.

import asyncio
sem = asyncio.Semaphore(4)
async def rate_limited_classify(stats):
    async with sem:
        try:
            return await classify_bucket_async(stats)
        except Exception as e:
            if "429" in str(e):
                await asyncio.sleep(2.0)
                return await classify_bucket_async(stats)
            raise

Geeignet / nicht geeignet für

✅ Geeignet für

• Solo-Quants & Indie-Entwickler, die 1–5 Jahre Tick-Daten brauchen
• Backtesting von Liquidation-Cascade-Strategien
• Markt-Mikrostruktur-Forschung (Order-Flow-Imbalance)
• Regulatorische Forensik (FTX-, LUNA-, 3AC-Exposure-Analyse)

❌ Nicht geeignet für

• Latenz-kritische HFT-Strategien (Tardis-Replay ist 5–10× langsamer als Realtime)
• Reine Spot-Märkte ohne Liquidation-Daten (z. B. Coinbase-Advanced)
• Wenn Sie < 1 Monat Historie brauchen — Binance Public API reicht

Preise und ROI

Die Pipeline-Kosten setzen sich zusammen aus:

• Tardis Hobby Plan: $39 / Monat (5 Symbole, 30 Tage Replay)
• Tardis Pro Plan: $299 / Monat (alle Symbole, unbegrenzter Replay) — für 18+ Monate nötig
• HolySheep API (DeepSeek V3.2): $0.15 / Monat bei 17.500 Buckets
• Compute (Hetzner CCX63, 48 vCPU, 192 GB): €58 / Monat (Dauerbetrieb) — reicht für 5 Symbole

Gesamtkosten pro Monat: ~$397 (~$365 USD + €58 EUR).

ROI-Betrachtung: Wenn die Pipeline eine Liquidations-Cascade-Strategie ermöglicht, die nach Backtest + Paper-Trading 0.8 % monatlich bei $50.000 AUM liefert ($400 / Monat), dann ist die Pipeline break-even ab Tag 1. Bei 5 % AUM / Monat (realistisch für Carry-Strategien auf Funding-Rate-Arb) liegt der ROI bei 1.250 %.

Warum HolySheep wählen

Im Vergleich zu direkten Anbindungen an OpenAI oder Anthropic bietet HolySheep AI für diesen Use-Case fünf handfeste Vorteile:

• Wechselkurs-Vorteil: 1 USD = 1 CNY (Stand 2026) — das sind 85%+ Ersparnis gegenüber asiatischen Providern, die USD-EUR-Konversion mit Aufschlag berechnen. Konkret: $0.42 / MTok für DeepSeek V3.2 ist international konkurrenzlos.
• Bezahlmethoden: WeChat Pay und Alipay — kein Stripe, kein internationales Wire-Transfer, keine Kreditkarte nötig. Besonders für asiatische Quant-Teams ein Game-Changer.
• Latenz-Optimierung für nicht-LLM-Workloads: < 50 ms p50 für Embeddings und Routing-Calls (z. B. Symbol-Clustering) — wichtig für Live-Dashboards, die auf den Klassifikations-Features aufsetzen.
• Startguthaben: Neue Accounts erhalten Credits für ~50.000 DeepSeek-V3.2-Anfragen — genug, um die kompletten 18 Monate einmal kostenlos zu klassifizieren.
• OpenAI-kompatibles SDK: Einzeiliger Wechsel base_url + api_key — kein Refactoring bestehender OpenAI-Tools nötig.

Alle Preisangaben verifiziert am 15.01.2026: GPT-4.1 $8 / MTok Input, Claude Sonnet 4.5 $15 / MTok Input, Gemini 2.5 Flash $2.50 / MTok Input, DeepSeek V3.2 $0.42 / MTok Input (HolySheep-Listenpreise, USD, zzgl. 1× API-Aufschlag auf Output-Tokens).

Fazit & nächste Schritte

Die Tardis-zu-HolySheep-Pipeline verwandelt 340 GB rohe Liquidation-Daten in eine analysefertige, klassifizierte Parquet-Datenbank — in unter 10 Minuten pro Tag, für weniger als $400 / Monat. Der Engpass ist nicht mehr die Datenbeschaffung, sondern die Strategie-Idee.

Mein konkreter nächster Schritt: ich werde die Pipeline auf OKX und Bybit erweitern (Tardis deckt das ab) und Cross-Exchange-Cascade-Detection implementieren — das ist der echte Alpha-Hebel, weil sich Liquidationen über Börsen hinweg kaskadieren.

👉 Registrieren Sie sich bei HolySheep AI — Startguthaben inklusive