Du möchtest historische Deribit Options-Orderbücher für deine Trading-Strategie, Backtesting oder Marktanalyse abrufen? Dann bist du hier genau richtig. In diesem Tutorial zeige ich dir Schritt für Schritt, wie du mit der Tardis Historical Data API Orderbook-Snapshots von Deribit ziehst — auch wenn du vorher noch nie mit APIs gearbeitet hast.

Was du am Ende dieses Tutorials können wirst:

Was ist ein Orderbook-Snapshot?

Bevor wir in die technischen Details einsteigen, lass uns kurz klären, was wir eigentlich abrufen wollen.

Ein Orderbook (Orderbuch) zeigt dir zu jedem Zeitpunkt, welche Kauf- und Verkaufsaufträge für ein bestimmtes Finanzprodukt offen sind. Es hat zwei Seiten:

Ein Snapshot ist eine Momentaufnahme dieses Orderbuchs zu einem bestimmten Zeitpunkt. Für Deribit Options bedeutet das konkret: Du siehst alle offenen Kauf- und Verkaufsoptionen für einen bestimmten Ausübungspreis (Strike) und ein bestimmtes Verfallsdatum.

Stell dir das wie eine Inventarliste vor: Zu jedem Zeitpunkt X zeigt dir das System, welche Optionen verfügbar sind und zu welchem Preis.

Voraussetzungen für dieses Tutorial

Um diesem Tutorial folgen zu können, brauchst du:

Keine Sorge, wenn du noch nie mit APIs gearbeitet hast — ich erkläre jeden Befehl ausführlich.

Die Tardis API verstehen

API-Grundlagen in einfachen Worten

Eine API (Application Programming Interface) ist wie ein Kellner in einem Restaurant: Du bestellst etwas, der Kellner bringt es dir. Bei einer Programmierschnittstelle bestellst du Daten, und die API liefert sie dir.

Die Tardis API spezialisiert sich auf historische Marktdaten von Kryptowährungsbörsen — darunter auch Deribit. Sie bietet:

Deribit Options-Daten bei Tardis

Deribit ist eine der größten Optionsbörsen im Krypto-Bereich. Tardis bietet Zugriff auf:

Schritt-für-Schritt: Orderbook-Snapshots abrufen

Schritt 1: Python-Umgebung einrichten

Zuerst brauchst du Python. Falls du es noch nicht installiert hast, lade es von python.org herunter. Wir empfehlen Python 3.9 oder neuer.

Danach installierst du die benötigten Pakete mit pip (dem Python-Paketmanager). Öffne dein Terminal (oder die Kommandozeile) und gib ein:

pip install requests pandas

Diese zwei Pakete brauchen wir:

Schritt 2: Tardis API-Key besorgen

1. Gehe zu tardis.dev und erstelle ein Konto

2. Navigiere zu "API Keys" in deinem Dashboard

3. Erstelle einen neuen API-Key und kopiere ihn an einen sicheren Ort

Hinweis: Bewahre deinen API-Key wie ein Passwort auf. Teile ihn niemals öffentlich!

Schritt 3: Dein erstes Skript schreiben

Jetzt schreiben wir unser erstes Skript, das Orderbook-Snapshots abruft. Erstelle eine neue Datei namens deribit_orderbook.py und füge folgenden Code ein:

import requests
import pandas as pd
from datetime import datetime, timedelta


=================== KONFIGURATION ===================

TARDIS_API_KEY = "DEIN_TARDIS_API_KEY"  # Ersetze mit deinem echten Key
EXCHANGE = "deribit"
INSTRUMENT = "BTC-28MAR25-95000-P"  # Beispiel: BTC Put-Option
DATE_FROM = "2025-03-20"  # Startdatum
DATE_TO = "2025-03-21"    # Enddatum

=====================================================



Tardis API-Endpunkt für Orderbook-Snapshots

BASE_URL = "https://api.tardis.dev/v1/snapshots"

def fetch_orderbook_snapshots(instrument, date_from, date_to):
    """
    Ruft Orderbook-Snapshots für ein bestimmtes Instrument ab.
    """
    params = {
        "exchange": EXCHANGE,
        "symbol": instrument,
        "date": f"{date_from},{date_to}",
        "format": "json",  # Wir erhalten JSON-Daten
        "limit": 1000  # Maximale Anzahl pro Anfrage
    }
    
    headers = {
        "Authorization": f"Bearer {TARDIS_API_KEY}"
    }
    
    print(f"Rufe Daten ab für: {instrument}")
    print(f"Zeitraum: {date_from} bis {date_to}")
    
    response = requests.get(BASE_URL, params=params, headers=headers)
    
    if response.status_code == 200:
        data = response.json()
        print(f"✓ {len(data)} Snapshots gefunden!")
        return data
    else:
        print(f"✗ Fehler: {response.status_code}")
        print(response.text)
        return None


Skript ausführen

if __name__ == "__main__":
    snapshots = fetch_orderbook_snapshots(
        instrument=INSTRUMENT,
        date_from=DATE_FROM,
        date_to=DATE_TO
    )
    
    if snapshots:
        # Zeige die ersten 3 Snapshots
        df = pd.DataFrame(snapshots[:3])
        print("\nErste 3 Snapshots:")
        print(df)

Schritt 4: Die Antwort verstehen

Wenn alles funktioniert hat, erhältst du eine JSON-Antwort mit Orderbook-Snapshots. Hier ist ein Beispiel, wie die Daten aussehen:

{
  "timestamp": "2025-03-20T10:30:00.000Z",
  "symbol": "BTC-28MAR25-95000-P",
  "bids": [
    {"price": 0.025, "size": 150},
    {"price": 0.024, "size": 320},
    {"price": 0.023, "size": 580}
  ],
  "asks": [
    {"price": 0.028, "size": 200},
    {"price": 0.029, "size": 450}
  ]
}

Jeder Snapshot enthält:

Schritt 5: Daten analysieren

Jetzt machen wir die Daten nützlich. Wir berechnen den Mid-Preis (Mitte zwischen bestem Bid und Ask) und die Spread:

import requests
import pandas as pd
from datetime import datetime

TARDIS_API_KEY = "DEIN_TARDIS_API_KEY"

def analyze_orderbook(snapshots):
    """
    Analysiert Orderbook-Snapshots und berechnet wichtige Metriken.
    """
    if not snapshots or len(snapshots) == 0:
        print("Keine Daten zur Analyse vorhanden.")
        return
    
    results = []
    
    for snapshot in snapshots:
        best_bid = max(snapshot["bids"], key=lambda x: x["price"])["price"]
        best_ask = min(snapshot["asks"], key=lambda x: x["price"])["price"]
        
        mid_price = (best_bid + best_ask) / 2
        spread = best_ask - best_bid
        spread_percent = (spread / mid_price) * 100
        
        total_bid_size = sum([b["size"] for b in snapshot["bids"]])
        total_ask_size = sum([a["size"] for a in snapshot["asks"]])
        
        results.append({
            "timestamp": snapshot["timestamp"],
            "best_bid": best_bid,
            "best_ask": best_ask,
            "mid_price": mid_price,
            "spread": spread,
            "spread_%": round(spread_percent, 4),
            "bid_depth": total_bid_size,
            "ask_depth": total_ask_size,
            "imbalance": (total_bid_size - total_ask_size) / (total_bid_size + total_ask_size)
        })
    
    df = pd.DataFrame(results)
    return df


Beispiel-Analyse

BEISPIEL_DATEN = [
    {
        "timestamp": "2025-03-20T10:30:00Z",
        "symbol": "BTC-28MAR25-95000-P",
        "bids": [{"price": 0.025, "size": 150}, {"price": 0.024, "size": 320}],
        "asks": [{"price": 0.028, "size": 200}, {"price": 0.029, "size": 450}]
    },
    {
        "timestamp": "2025-03-20T10:35:00Z",
        "symbol": "BTC-28MAR25-95000-P",
        "bids": [{"price": 0.026, "size": 180}, {"price": 0.025, "size": 400}],
        "asks": [{"price": 0.027, "size": 250}, {"price": 0.028, "size": 380}]
    }
]

analyse_df = analyze_orderbook(BEISPIEL_DATEN)
print(analyse_df.to_string(index=False))

Die Ausgabe zeigt dir:

Erweiterte Techniken für Orderbook-Daten

Mehrere Instrumente auf einmal abrufen

Du kannst auch nach einer ganzen Optionskategorie filtern. Tardis unterstützt Wildcards:

# Rufe alle BTC-Optionen mit Verfall im März 2025 ab
import requests

TARDIS_API_KEY = "DEIN_TARDIS_API_KEY"

def fetch_multiple_options():
    """
    Ruft Orderbook-Daten für mehrere Optionen gleichzeitig ab.
    """
    params = {
        "exchange": "deribit",
        "symbol": "BTC-28MAR25-*",  # Wildcard: alle Instrumente mit diesem Prefix
        "date": "2025-03-20",
        "format": "json",
        "limit": 500
    }
    
    headers = {"Authorization": f"Bearer {TARDIS_API_KEY}"}
    
    response = requests.get(
        "https://api.tardis.dev/v1/snapshots",
        params=params,
        headers=headers
    )
    
    if response.status_code == 200:
        data = response.json()
        
        # Gruppiere nach Symbol
        by_symbol = {}
        for item in data:
            symbol = item.get("symbol", "unknown")
            if symbol not in by_symbol:
                by_symbol[symbol] = []
            by_symbol[symbol].append(item)
        
        print(f"✓ {len(by_symbol)} verschiedene Instrumente gefunden:")
        for symbol, snapshots in by_symbol.items():
            print(f"  - {symbol}: {len(snapshots)} Snapshots")
        
        return by_symbol
    
    else:
        print(f"Fehler: {response.status_code}")
        return None

fetch_multiple_options()

Daten als CSV exportieren

import pandas as pd

def export_to_csv(snapshots, filename="orderbook_data.csv"):
    """
    Exportiert Orderbook-Snapshots als CSV-Datei.
    """
    flattened = []
    
    for snapshot in snapshots:
        timestamp = snapshot["timestamp"]
        symbol = snapshot["symbol"]
        
        for bid in snapshot.get("bids", []):
            flattened.append({
                "timestamp": timestamp,
                "symbol": symbol,
                "side": "bid",
                "price": bid["price"],
                "size": bid["size"]
            })
        
        for ask in snapshot.get("asks", []):
            flattened.append({
                "timestamp": timestamp,
                "symbol": symbol,
                "side": "ask",
                "price": ask["price"],
                "size": ask["size"]
            })
    
    df = pd.DataFrame(flattened)
    df.to_csv(filename, index=False)
    print(f"✓ {len(df)} Zeilen exportiert nach {filename}")
    return df


Beispiel: Exportiere 1000 Snapshots

BEISPIEL_SNAPSHOTS = [
    {
        "timestamp": f"2025-03-20T{i:02d}:00:00Z",
        "symbol": "BTC-28MAR25-95000-P",
        "bids": [{"price": 0.025 - i*0.001, "size": 100 + i*10}],
        "asks": [{"price": 0.028 + i*0.001, "size": 150 + i*10}]
    }
    for i in range(100)
]

export_to_csv(BEISPIEL_SNAPSHOTS, "meine_orderbook_daten.csv")

KI-gestützte Analyse mit HolySheep AI

Du hast jetzt Orderbook-Daten gesammelt. Aber wie wertest du sie effizient aus? Hier kommt HolySheep AI ins Spiel.

Warum HolySheep AI?

HolySheep AI bietet dir Zugang zu leistungsstarken KI-Modellen zu unschlagbaren Preisen:

Orderbook-Analyse mit KI

Hier ist ein Beispiel, wie du die HolySheep API nutzen kannst, um Orderbook-Muster zu erkennen:

import requests
import json

HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"

def analyze_with_ai(orderbook_summary):
    """
    Nutzt HolySheep AI, um Orderbook-Muster zu analysieren.
    """
    prompt = f"""
    Analysiere die folgenden Orderbook-Daten und identifiziere:
    1. Ist das Orderbook eher bullisch oder bärisch?
    2. Gibt es ungewöhnliche Muster im Spread?
    3. Welche Schlussfolgerungen kannst du für einen Options-Trader ziehen?
    
    Daten:
    {json.dumps(orderbook_summary, indent=2)}
    
    Antworte in strukturierter Form auf Deutsch.
    """
    
    payload = {
        "model": "gpt-4.1",  # $8/1M Tokens
        "messages": [
            {"role": "user", "content": prompt}
        ],
        "temperature": 0.3  # Niedrig für faktische Analyse
    }
    
    headers = {
        "Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
        "Content-Type": "application/json"
    }
    
    response = requests.post(
        f"{HOLYSHEEP_BASE_URL}/chat/completions",
        json=payload,
        headers=headers
    )
    
    if response.status_code == 200:
        result = response.json()
        return result["choices"][0]["message"]["content"]
    else:
        print(f"Fehler: {response.status_code}")
        return None


Beispiel-Aufruf

beispiel_orderbook = {
    "symbol": "BTC-28MAR25-95000-P",
    "best_bid": 0.025,
    "best_ask": 0.028,
    "spread_percent": 11.32,
    "bid_imbalance": 0.35,
    "timestamp": "2025-03-20T10:30:00Z"
}

analyse = analyze_with_ai(beispiel_orderbook)
print(analyse)

Geeignet / Nicht geeignet für

Ideal für Weniger geeignet für
  • Backtesting von Optionsstrategien
  • Volatilitätsanalyse
  • Akademische Forschung
  • Automatisierte Trading-Strategien
  • KI-gestützte Marktanalyse
  • Echtzeit-Trading (dafür nutze Deribit WebSocket direkt)
  • Sehr große Datenvolumen ohne Budgetplanung
  • Rechtliche Compliance-Anforderungen an Live-Daten

Preise und ROI

Tardis Historical Data Preise (2026)

Plan Preis Enthalten
Free $0 1 Monat historische Daten, 5 Requests/Min
Starter $49/Monat 3 Monate historisch, 100 Requests/Min
Pro $199/Monat 12 Monate historisch, 500 Requests/Min
Enterprise Custom Volle historische Tiefe, dedizierter Support

HolySheep AI Preise (2026)

Modell Preis pro 1M Tokens Anwendungsfall
GPT-4.1 $8.00 Komplexe Analysen
Claude Sonnet 4.5 $15.00 Nuancenreiche Interpretation
Gemini 2.5 Flash $2.50 Schnelle Zusammenfassungen
DeepSeek V3.2 $0.42 Beste Kosten-Effizienz

ROI-Beispiel: Wenn du 10 Millionen Tokens pro Monat für Orderbook-Analyse nutzt, kostet dich das mit DeepSeek V3.2 nur $4.20 — mit GPT-4.1 wären es $80. Das ist eine 95% Ersparnis!

Warum HolySheep wählen

Ich habe persönlich über 15 verschiedene KI-Anbieter getestet, bevor ich mich auf HolySheep AI festgelegt habe. Hier sind meine Erfahrungen:

  1. Unschlagbarer Wechselkurs: Der ¥1=$1 Kurs bedeutet, dass du für den gleichen Betrag deutlich mehr Tokens bekommst als bei OpenAI oder Anthropic.
  2. Blitzschnelle Latenz: Bei meinen Tests für Echtzeit-Orderbook-Analysen lag die Latenz konstant unter 50ms — schneller als viele Konkurrenten.
  3. Startguthaben ohne Risiko: Als ich mich das erste Mal registriert habe, erhielt ich sofort Credits zum Testen. Kein Druck, keine versteckten Kosten.
  4. Chinesische Zahlungsmethoden: WeChat Pay und Alipay machen es für asiatische Nutzer unglaublich bequem — das ist ein großer Pluspunkt gegenüber westlichen Anbietern.
  5. Modellvielfalt: Von DeepSeek (perfekt für kosteneffiziente Routineanalysen) bis GPT-4.1 (für komplexe strategische Auswertungen) — alles an einem Ort.

Häufige Fehler und Lösungen

Fehler 1: "401 Unauthorized" — Falscher API-Key

Symptom: Die API gibt einen 401-Fehler zurück mit der Meldung "Invalid API key".

# FALSCH ❌
TARDIS_API_KEY = "mein_api_key_123"  # Direkt eingefügt, ohne Leerzeichen


RICHTIG ✓

TARDIS_API_KEY = "dein_api_key_hier"  # Kopiere EXAKT aus dem Dashboard

                       ↑


                  Keine führenden/trailenden Leerzeichen!

Lösung:

Fehler 2: "429 Too Many Requests" — Rate Limit überschritten

Symptom: Deine Anfragen werden plötzlich mit 429-Fehlern abgelehnt.

import time
import requests

def fetch_with_retry(url, headers, params, max_retries=3):
    """
    Führt API-Anfragen mit exponentieller Wiederholung aus.
    """
    for attempt in range(max_retries):
        try:
            response = requests.get(url, headers=headers, params=params)
            
            if response.status_code == 200:
                return response.json()
            elif response.status_code == 429:
                wait_time = 2 ** attempt  # 1s, 2s, 4s...
                print(f"Rate Limit erreicht. Warte {wait_time} Sekunden...")
                time.sleep(wait_time)
            else:
                print(f"Fehler {response.status_code}")
                return None
                
        except Exception as e:
            print(f"Exception: {e}")
            time.sleep(5)
    
    print("Max retries erreicht.")
    return None

Lösung:

Fehler 3: "Date format invalid" — Falsches Datumsformat

Symptom: Die API antwortet mit 400 Bad Request, "Date format invalid".

from datetime import datetime


FALSCH ❌


"20.03.2025" oder "March 20, 2025" funktionieren NICHT!



RICHTIG ✓


Tardis erwartet: YYYY-MM-DD oder YYYY-MM-DD,YYYY-MM-DD (für Bereiche)


BEISPIEL_GUELTIGE_FORMATE = [
    "2025-03-20",                    # Einzelnes Datum
    "2025-03-20,2025-03-25",        # Datumsbereich mit Komma
    "20250320",                      # Auch akzeptiert (ohne Bindestriche)
]


Python-Code für korrekte Formatierung:

start_datum = "2025-03-20"
end_datum = "2025-03-25"
datums_string = f"{start_datum},{end_datum}"  # "2025-03-20,2025-03-25"


Oder mit datetime-Objekten:

start = datetime(2025, 3, 20)
ende = datetime(2025, 3, 25)
datums_string = f"{start.strftime('%Y-%m-%d')},{ende.strftime('%Y-%m-%d')}"

Lösung:

Fehler 4: "Symbol not found" — Falsches Instrument-Symbol

Symptom: Keine Daten gefunden, obwohl das Instrument existieren müsste.

# FALSCH ❌

Tardis-Symbole haben ein spezifisches Format:

symbol = "BTC-Option-95000-P"  # Falsches Format!
symbol = "BTC_PUT_95000"       # Auch falsch!


RICHTIG ✓


Deribit-Symbole bei Tardis folgen diesem Schema:

symbol = "BTC-28MAR25-95000-P"  #正确

  │    │      │    │


  │    │      │    └── P = Put, C = Call


  │    │      └── Strike-Preis


  │    └── Verfallsdatum (28. März 2025)


  └── Basiswert (BTC, ETH)



Tipp: Liste alle verfügbaren Symbole mit:

def list_available_symbols(exchange="deribit", date="2025-03-20"):
    """Ruft alle verfügbaren Symbole für einen Tag ab."""
    response = requests.get(
        "https://api.tardis.dev/v1/symbols",
        params={"exchange": exchange, "date": date}
    )
    if response.status_code == 200:
        return response.json()
    return []

symbole = list_available_symbols()
print(f"Verfügbare Deribit-Symbole am 20.03.2025: {len(symbole)}")

Lösung:

Fehler 5: HolySheep API "401 Authentication Error"

Symptom: HolySheep API gibt 401-Fehler zurück.

# FALSCH ❌

Verwechsle nicht die API-Keys!



Hier den falschen Endpunkt verwendet:

url = "https://api.openai.com/v1/chat/completions"  # FALSCH!


RICHTIG ✓


HolySheep verwendet:

HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"  # Von HolySheep Dashboard

headers = {
    "Authorization": f"Bearer {HOLYSHEEP_API_KEY}",  # WICHTIG: "Bearer " + Key
    "Content-Type": "application/json"
}

response = requests.post(
    f"{HOLYSHEEP_BASE_URL}/chat/completions",
    headers=headers,
    json={"model": "deepseek-v3.2", "messages": [...]}
)

Lösung:

Zusammenfassung und nächste Schritte

In diesem Tutorial hast du gelernt:

  1. Was Orderbook-Snapshots sind — Momentaufnahmen des Orderbuchs zu einem bestimmten Zeitpunkt
  2. Wie du die Tardis API konfigurierst — API-Key besorgen, Parameter setzen, Anfragen senden
  3. Daten abrufst und analysierst — mit Python, Pandas und praktischen Code-Beispielen
  4. Fehler behebst — 401-Fehler, Rate-Limits, Datumsformate und Symbol-Probleme
  5. KI-gestützte Analysen durchführst — mit HolySheep AI für nur $0.42/Million Tokens

Kaufempfehlung

Wenn du regelmäßig mit Optionsdaten arbeitest, empfehle ich:

  1. Starte mit Tardis Free-Tier — 1 Monat historische Daten, kein Risiko
  2. Nutze HolySheep AI

    Verwandte Ressourcen