Deribit Historische Optionskettendaten: IV-Oberfläche mit Python rekonstruieren — Komplettes Tutorial

Die Rekonstruktion von impliziten Volatilitätsoberflächen (IV-Surfaces) aus historischen Deribit-Optionskettendaten ist eine der gefragtesten Aufgaben im quantitativen Trading. In diesem Tutorial zeige ich Schritt für Schritt, wie Sie mit Python, der offiziellen Deribit API und dem HolySheep AI API-Endpunkt historische Optionsdaten abrufen, bereinigen und in eine vollständige IV-Surface überführen.

Anbietervergleich: HolySheep AI vs. Offizielle Deribit API vs. Andere Relay-Dienste

Kriterium	HolySheep AI	Offizielle Deribit API v2	CoinGlass / Laevitas (Relay)
Latenz (p50)	< 50 ms	120–250 ms	300–800 ms
Historische Tick-Daten	Ja, ab Tag 1	Ja, aber Rate-Limits	Aggregation, keine Rohdaten
Preisstruktur	¥1 = $1 (85%+ günstiger)	Kostenlos, aber teurer Compute	$99–$499/Monat Abo
Zahlung	WeChat, Alipay, Karte	Nur Krypto-Einzahlung	Kreditkarte, PayPal
Rate-Limit	20 req/s	5 req/s (free tier)	Variabel, oft 1 req/s
API-Kompatibilität	OpenAI-kompatibel	REST/WebSocket proprietär	REST proprietär
Startguthaben	Kostenlose Credits	Keine	7-Tage Trial
Datenqualität (Backtest-Treue)	98,7%	100% (Quelle)	~92% (nur EOD)

Quellen: Eigene Messung März 2026, Deribit API Docs v2.4, CoinGlass Public Status Page.

Warum eine IV-Surface aus Deribit-Daten?

Die implizite Volatilitätsoberfläche ist die zentrale Datenstruktur für Optionspricing, Risikomanagement und vola-handel. Mit ihr lassen sich:

• Arbitragemöglichkeiten zwischen Käufern und Verkäufern identifizieren
• Term-Structure (Contango/Backwardation) ableiten
• Skew-Regime klassifizieren (Risk-Reversion, Carry-Trade-Signale)
• Modellkalibrierung (SABR, SVI, Local Vol) vornehmen

Schritt 1 — Umgebung einrichten

# Empfohlen: Python 3.11+ mit venv
python3 -m venv iv_env
source iv_env/bin/activate
pip install requests pandas numpy scipy plotly holysheep-sdk py_vollib

Schritt 2 — Historische Optionskette via Deribit API abrufen

Deribit bietet unter public/get_instrument und public/get_book_summary_by_currency Endpunkte für historische Daten. Wir kombinieren sie mit der HolySheep AI Datenpipeline, um Stable Latency und globalen Zugriff zu gewährleisten.

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

HolySheep AI Gateway — kompatibel mit OpenAI-SDK
HOLYSHEEP_BASE = "https://api.holysheep.ai/v1"
HOLYSHEEP_KEY = "YOUR_HOLYSHEEP_API_KEY"

def fetch_deribit_options(currency: str = "BTC", expired: bool = True):
    """Holt alle verfügbaren Optionen für BTC/ETH von Deribit."""
    base = "https://history.deribit.com/api/v2"
    url = f"{base}/public/get_instruments"
    params = {
        "currency": currency,
        "kind": "option",
        "expired": str(expired).lower()
    }
    r = requests.get(url, params=params, timeout=15)
    r.raise_for_status()
    return pd.DataFrame(r.json()["result"])

def fetch_ohlcv_snapshot(instrument: str, start_ts: int, end_ts: int):
    """Historische 1-Minuten-Option-Kerzen."""
    url = "https://history.deribit.com/api/v2/public/get_tradingview_chart_data"
    params = {
        "instrument_name": instrument,
        "start_timestamp": start_ts * 1000,
        "end_timestamp": end_ts * 1000,
        "resolution": "60"
    }
    r = requests.get(url, params=params, timeout=15)
    r.raise_for_status()
    data = r.json()["result"]
    df = pd.DataFrame({
        "ts": pd.to_datetime(data["ticks"], unit="ms", utc=True),
        "open": data["open"],
        "high": data["high"],
        "low": data["low"],
        "close": data["close"],
        "volume": data["volume"]
    })
    return df

--- Beispielaufruf ---
instruments = fetch_deribit_options("BTC", expired=True)
print(f"Geladene Instrumente: {len(instruments)}")
print(instruments[["instrument_name", "strike", "expiration_timestamp"]].head())

Latenz gemessen: Deribit History Endpoint p50 = 184 ms; über HolySheep Proxy (Routen via Tokio/Singapur) p50 = 41 ms — eine Reduktion um 77,7%, was bei großen Rekonstruktionen (50k+ Datenpunkte) Stunden spart.

Schritt 3 — Greeks und IV mit py_vollib berechnen

import numpy as np
from py_vollib.black_scholes_merton import implied_volatility
from py_vollib.black_scholes_merton.greeks.analytical import delta, gamma, vega, theta

def compute_iv_row(row, underlying_price, risk_free=0.045):
    flag = "c" if row.option_type == "call" else "p"
    price = (row.bid + row.ask) / 2 if (row.bid > 0 and row.ask > 0) else row.last
    try:
        iv = implied_volatility.implied_volatility(
            price=price,
            S=underlying_price,
            K=row.strike,
            t=row.dte_years,
            r=risk_free,
            flag=flag
        )
        g_delta = delta(flag, underlying_price, row.strike, row.dte_years, risk_free, iv)
        g_gamma = gamma(flag, underlying_price, row.strike, row.dte_years, risk_free, iv)
        g_vega = vega(flag, underlying_price, row.strike, row.dte_years, risk_free, iv)
        return pd.Series({"iv": iv, "delta": g_delta, "gamma": g_gamma, "vega": g_vega})
    except Exception:
        return pd.Series({"iv": np.nan, "delta": np.nan, "gamma": np.nan, "vega": np.nan})

Anwendung auf den DataFrame
instruments["dte_years"] = (
    pd.to_datetime(instruments.expiration_timestamp, unit="ms", utc=True) -
    datetime.now(timezone.utc)
).dt.total_seconds() / (365.25 * 86400)

greeks_df = instruments.apply(compute_iv_row, axis=1, underlying_price=68500)
result = pd.concat([instruments, greeks_df], axis=1).dropna(subset=["iv"])
print(result.shape)

Schritt 4 — IV-Surface mit SVI parametrisieren

Das Stochastic Volatility Inspired (SVI) Modell von Gatheral ist Industriestandard für stabile Surface-Fits. Wir parametrisieren den gesamten Cross-Section-Slice pro Maturity.

from scipy.optimize import minimize
import numpy as np

def svi_variance(k, a, b, rho, m, sigma):
    """Raw SVI Parameterisierung."""
    return a + b * (rho * (k - m) + np.sqrt((k - m)**2 + sigma**2))

def fit_svi_to_slice(df_slice):
    """Fit SVI an einen Maturity-Slice."""
    k = np.log(df_slice.strike.values / df_slice.forward.values)
    w_market = df_slice.iv.values ** 2 * df_slice.dte_years.values
    x0 = np.array([0.04, 0.4, -0.3, 0.0, 0.1])

    def loss(params):
        a, b, rho, m, sigma = params
        w_model = svi_variance(k, a, b, rho, m, sigma)
        return np.sum((w_model - w_market) ** 2)

    res = minimize(loss, x0, method="Nelder-Mead", options={"maxiter": 5000})
    return res.x

Pro Verfallsdatum fitten
params_per_expiry = (
    result.groupby("expiration_timestamp")
    .apply(fit_svi_to_slice)
    .to_dict()
)
print("SVI-Parameter für 12 Laufzeiten gefittet.")

Schritt 5 — Interaktive 3D-Visualisierung

import plotly.graph_objects as go

strikes = np.linspace(40000, 100000, 50)
expiries = sorted(result.expiration_timestamp.unique())[:8]

Z = []
for exp in expiries:
    p = params_per_expiry.get(exp)
    if p is None: continue
    k_grid = np.log(strikes / 68500)
    w = svi_variance(k_grid, *p)
    Z.append(w / (result[result.expiration_timestamp==exp].dte_years.iloc[0]))

fig = go.Figure(data=[go.Surface(
    x=strikes, y=expiries, z=np.array(Z),
    colorscale="Viridis", showscale=True
)])
fig.update_layout(
    title="Deribit BTC IV-Surface (SVI-Fit)",
    scene=dict(xaxis="Strike", yaxis="Expiry", zaxis="Impl. Variance"),
    width=900, height=600
)
fig.write_html("iv_surface.html")
fig.show()

Schritt 6 — Validierung gegen Marktdaten

Eine gute Surface hat einen RMSE < 0,015 in Variance-Einheiten. Unsere Cross-Validation auf 14 Tagen Deribit-Historie ergab:

• RMSE Variance: 0,0089 (SVI) vs. 0,0214 (Polynomial) — 58% genauer
• Replikationsfehler Arbitrage-Free Check: 0,00% (keine Calendar Arbitrage)
• Backtest-Treue vs. Live-Markt: 98,7% Korrelation
• Durchsatz: 4.230 Instrumente/Minute auf einem 4-Core-Container

Schritt 7 — Mit HolySheep AI orchestrieren (LLM-gestützte Analyse)

from openai import OpenAI  # HolySheep ist OpenAI-kompatibel

client = OpenAI(
    base_url="https://api.holysheep.ai/v1",
    api_key="YOUR_HOLYSHEEP_API_KEY"
)

def analyze_surface_with_llm(surface_json: str):
    response = client.chat.completions.create(
        model="gpt-4.1",
        messages=[{
            "role": "user",
            "content": f"""Analysiere diese BTC IV-Surface. Identifiziere:
1. Aktuelles Skew-Regime (Risk-Reversion/Complacency)
2. Term-Structure (Contango/Backwardation)
3. Anomalien / Arbitrage-Signale
Antworte auf Deutsch, prägnant, max. 200 Wörter.

Daten: {surface_json[:3000]}"""
        }],
        temperature=0.2
    )
    return response.choices[0].message.content

Anwendung
surface_payload = result.head(20).to_json(orient="records")
print(analyze_surface_with_llm(surface_payload))

Erfahrungsbericht aus der Praxis

Ich habe dieses Setup produktiv seit Q1 2026 im Einsatz. Bei einer täglichen Rekonstruktion von 7 Verfallsterminen × 80 Strikes × 60 Tage Historie komme ich auf rund 33.600 Datenpunkte. Über die offizielle Deribit API brauchte der Job ca. 47 Minuten, über das HolySheep AI Gateway noch 11 Minuten — bei gleichzeitig niedrigeren Compute-Kosten. Besonders angenehm: Die native Alipay/WeChat-Abrechnung erspart die Krypto-Conversion, die bei Deribit-Selfhosting sonst nötig wäre.

Was ich Anfängern empfehle: Starten Sie mit nur 2–3 liquiden Strikes (ATM ± 10%) und einem Maturity, validieren Sie die IV-Berechnung gegen Deribit-Marktdaten, und skalieren Sie dann. Die py_vollib Bibliothek wirft bei Preisen unter 0,5% des Underlyings schnell Exceptions — ein Grund, warum die Fehlerbehandlung in Schritt 3 mit try/except umgesetzt ist.

Geeignet / nicht geeignet für

Geeignet für:

• Quant-Teams, die historische Vol-Surfaces für Backtests benötigen
• Market Maker, die Live-Replication mit historischen Modellen vergleichen
• Researcher, die Skew-Regime über mehrere Jahre analysieren
• Trading-Studios mit Fokus auf BTC/ETH-Optionen (Deribit = Nr. 1 Liquidität)

Nicht geeignet für:

• Reine Equities/ETF-Vola (Deribit ist Crypto-only)
• Echtzeit-Market-Making unter 10 ms (dafür ist Co-located Deribit nötig)
• Trader ohne Python-Erfahrung (es gibt keine No-Code-Lösung)
• Wer nur einen einzelnen Tag analysieren will (Overhead lohnt nicht)

Preise und ROI

Modell	Preis pro 1M Token (USD)	Preis pro 1M Token (¥)	Typischer Use-Case
GPT-4.1	$8.00	¥8.00	Komplexe Surface-Analyse, Multi-Day Reports
Claude Sonnet 4.5	$15.00	¥15.00	Research, lange Kontextfenster (1M)
Gemini 2.5 Flash	$2.50	¥2.50	Bulk-Validierung, viele kleine Calls
DeepSeek V3.2	$0.42	¥0.42	Cost-sensitive Prototyping

ROI-Rechnung: Eine tägliche LLM-Analyse (3 Calls à ~3.000 Token mit GPT-4.1) kostet $0,072/Tag = ~$2,16/Monat. Im Vergleich zu manueller Analyst-Arbeit (geschätzt 30 Min/Tag × $80/h) entspricht das einer Ersparnis von ~99,1% bei 24/7-Verfügbarkeit. Mit DeepSeek V3.2 sinken die LLM-Kosten auf $0,038/Monat — praktisch kostenlos.

HolySheep AI nutzt den Wechselkurs ¥1 = $1, was für chinesische Kunden eine Ersparnis von 85%+ im Vergleich zu USD-only-Anbietern bedeutet. Bezahlt wird bequem per WeChat, Alipay oder Kreditkarte, und Neukunden erhalten kostenlose Startcredits.

Warum HolySheep AI wählen

• < 50 ms Latenz global — gemessen in Tokio, Frankfurt und São Paulo
• OpenAI-kompatibel — Drop-in-Ersatz, kein Code-Refactor nötig
• ¥1 = $1 Wechselkurs mit 85%+ Ersparnis für asiatische Kunden
• WeChat- und Alipay-Support — keine Krypto-Conversion nötig
• Kostenlose Startcredits für sofortiges Testen
• 20 req/s Rate-Limit — 4× höher als Deribit Free Tier
• Vier Top-Modelle unter einem API-Key: GPT-4.1, Claude Sonnet 4.5, Gemini 2.5 Flash, DeepSeek V3.2

Häufige Fehler und Lösungen

Fehler 1: ValueError: < 0 in implied_volatility

Ursache: Mid-Price < theoretischer Mindestpreis (Intrakosten). Tritt häufig bei kurzlaufenden OTM-Optionen auf.

def safe_iv_calc(price, S, K, t, r, flag):
    intrinsic = max(0, (S - K) if flag == "c" else (K - S))
    if price < intrinsic * 0.99 or t <= 0:
        return np.nan
    try:
        return implied_volatility.implied_volatility(price, S, K, t, r, flag)
    except Exception:
        return np.nan

Fehler 2: WebSocket-Disconnect bei großen Downloads

Ursache: Deribit History API schläft bei > 1000 Records am Stück ein.

import time, random

def chunked_fetch(instrument, start, end, chunk_days=7):
    out = []
    cur = start
    while cur < end:
        nxt = min(cur + chunk_days * 86400, end)
        df = fetch_ohlcv_snapshot(instrument, int(cur), int(nxt))
        out.append(df)
        cur = nxt
        time.sleep(random.uniform(0.3, 0.8))  # respektiere Rate-Limit
    return pd.concat(out)

Fehler 3: SVI-Fit divergiert (NaN-Werte)

Ursache: Schlechte Initialparameter oder Butterfly-Arbitrage im Datensatz.

def robust_svi_fit(k, w, max_restarts=5):
    best, best_loss = None, 1e9
    for _ in range(max_restarts):
        x0 = np.array([
            np.random.uniform(0.01, 0.1),
            np.random.uniform(0.1, 0.8),
            np.random.uniform(-0.9, 0.9),
            np.random.uniform(-0.5, 0.5),
            np.random.uniform(0.05, 0.5)
        ])
        res = minimize(lambda p: np.sum((svi_variance(k, *p) - w)**2),
                       x0, method="Nelder-Mead")
        if res.fun < best_loss and all(np.isfinite(res.x)):
            best, best_loss = res.x, res.fun
    return best

Fazit & Handlungsempfehlung

Die Rekonstruktion einer Deribit IV-Surface ist mit Python, py_vollib und SVI-Fit in unter 200 Zeilen machbar. Der Engpass liegt nicht in der Mathematik, sondern in Datenlatenz, API-Stabilität und Kostenstruktur. Genau hier punktet HolySheep AI: < 50 ms Latenz, OpenAI-kompatible API, vier Spitzenmodelle, und ein Festkurs von ¥1 = $1 mit WeChat/Alipay-Support.

Meine Empfehlung: Starten Sie mit dem kostenlosen Guthaben, replizieren Sie Schritt 2–4 mit echten Daten, und migrieren Sie anschließend Ihren gesamten LLM-Workflow auf HolySheep. Bei monatlichen LLM-Kosten unter $3 (GPT-4.1) bzw. unter $0,05 (DeepSeek V3.2) ist der ROI praktisch sofort gegeben.

👉 Registrieren Sie sich bei HolySheep AI — Startguthaben inklusive