Wer professionell Ethereum-Derivate handelt, kommt an der Implied Volatility Surface (IVS) nicht vorbei. Sie verdichtet die Erwartungen des Marktes an zukünftige ETH-Schwankungen über Strikes und Laufzeiten und ist die Grundlage für Optionspreis-Modelle, Hedging und Mean-Reversion-Strategien. In diesem Tutorial zeige ich, wie Sie die komplette Pipeline in Python aufbauen — von der Deribit-Rohdatenabfrage über Interpolation und Smoothing bis zur Visualisierung der Vol-Surface.
Bevor wir tief in Deribit-Code, SVI-Fits und Plotly-Surface-Charts eintauchen, lohnt sich ein Blick auf das aktuelle API-Pricing 2026. Denn wer täglich Marktdaten verarbeitet, LLM-basierte Vol-Regime-Klassifikation einsetzt oder Research-Berichte generieren lässt, sieht sehr schnell, dass die Wahl des API-Providers einen erheblichen Kostenfaktor darstellt. Ich nutze für die Erklärung der Konzepte und für die Generierung von Market-Commentary-Texten selbst die HolySheep AI API — mit WeChat/Alipay-Support, <50 ms Latenz und einem Wechselkurs von ¥1 = $1, was über 85 % Ersparnis gegenüber klassischen USD-only-Providern bedeutet.
Aktuelle API-Output-Preise 2026 im Vergleich
| Modell | Output $/MTok | 10M Token/Monat | HolySheep Vorteil |
|---|---|---|---|
| GPT-4.1 | $8,00 | $80,00 | ¥80 vs. $80 → ~85 % günstiger via HolySheep |
| Claude Sonnet 4.5 | $15,00 | $150,00 | Höchste Qualität, aber teurer |
| Gemini 2.5 Flash | $2,50 | $25,00 | Sehr günstig für Bulk-Kommentare |
| DeepSeek V3.2 | $0,42 | $4,20 | Beste Wahl für reine Vol-Surface-Reports |
Bei einem realistischen Workload von 10 Millionen Output-Token pro Monat zahlen Sie bei OpenAI-GPT-4.1 $80, bei Claude Sonnet 4.5 $150, bei Gemini 2.5 Flash nur $25 und bei DeepSeek V3.2 lediglich $4,20. Über HolySheep AI mit ¥1 = $1-Konvertierung reduziert sich die Rechnung in CNY nochmals deutlich — ein konkret messbarer Vorteil für jedes Quantitative-Desk-Budget.
Schritt 1: Deribit Options-Chain abrufen
Deribit stellt einen öffentlichen Endpunkt public/get_book_summary_by_currency bereit, der ohne Authentifizierung genutzt werden kann. Wir filtern auf currency=ETH und entferne nicht-optionelle Instrumente (Futures, Combos).
import requests, pandas as pd, numpy as np
DERIBIT_BASE = "https://www.deribit.com/api/v2"
def fetch_eth_options() -> pd.DataFrame:
"""Hole alle ETH-Options-Instrumente samt Mid/Mark IV."""
url = f"{DERIBIT_BASE}/public/get_book_summary_by_currency"
params = {"currency": "ETH", "kind": "option"}
r = requests.get(url, params=params, timeout=15)
r.raise_for_status()
rows = r.json()["result"]
df = pd.DataFrame(rows)
# Nur Standardoptionen (keine Combo-Instrumente)
df = df[~df["instrument_name"].str.contains("-C-|-P-", regex=True)]
df = df[df["instrument_name"].str.contains("ETH-")]
# Felder parsen
df["strike"] = df["instrument_name"].str.extract(r"-(\d+)-").astype(float)
df["expiry"] = pd.to_datetime(df["instrument_name"].str.extract(r"ETH-(\d+)-")[0],
format="%d%b%y")
df["type"] = df["instrument_name"].str[-1] # C oder P
df["mid"] = (df["best_bid_price"] + df["best_ask_price"]) / 2.0
df["mark_iv"] = df["mark_iv"] / 100.0 # in Dezimal
df["T"] = (df["expiry"] - pd.Timestamp.utcnow().tz_localize(None)).dt.days / 365.0
return df.dropna(subset=["mid", "mark_iv", "strike", "T"]).reset_index(drop=True)
chain = fetch_eth_options()
print(chain[["instrument_name","strike","expiry","type","mid","mark_iv","T"]].head())
Der DataFrame enthält pro Instrument Strike, Verfall, Mid-Price, Mark-IV und die annualisierte Restlaufzeit T. Aus diesen Feldern bauen wir nun die Surface.
Schritt 2: Forward und Risk-Free Rate ableiten
Deribit veröffentlicht die synthetische Forward-Kurve sowie Funding-bereinigte Zinssätze. Für eine stabile ATM-IV-Berechnung ermitteln wir F(T) und r(T) aus dem Futures-Market:
def fetch_eth_futures() -> pd.DataFrame:
url = f"{DERIBIT_BASE}/public/get_book_summary_by_currency"
params = {"currency": "ETH", "kind": "future"}
r = requests.get(url, params=params, timeout=15).json()["result"]
f = pd.DataFrame(r)
f["expiry"] = pd.to_datetime(f["instrument_name"].str.extract(r"ETH-(\d+)-")[0],
format="%d%b%y", errors="coerce")
f = f.dropna(subset=["expiry"])
f["mid_fwd"] = (f["best_bid_price"] + f["best_ask_price"]) / 2.0
f["T"] = (f["expiry"] - pd.Timestamp.utcnow().tz_localize(None)).dt.days / 365.0
return f[["expiry","T","mid_fwd"]].sort_values("T").reset_index(drop=True)
futs = fetch_eth_futures()
ATM-Forward pro Laufzeit (lineare Interpolation der Futures)
def forward_at(T_query):
return np.interp(T_query, futs["T"].values, futs["mid_fwd"].values)
Schritt 3: Log-Moneyness berechnen und SVI-Fit vorbereiten
Wir standardisieren die Strike-Achse als Log-Moneyness k = ln(K/F) und projizieren die IVs auf ein reguläres Grid. Für die Interpolation verwende ich SVI (Stochastic Volatility Inspired), weil es arbitragefreie Smile-Formen liefert:
from scipy.optimize import minimize
def svi(k, a, b, rho, m, sigma):
"""Raw SVI Parametrisierung (Wing 2014)."""
return a + b * (rho * (k - m) + np.sqrt((k - m)**2 + sigma**2))
def fit_svi_chain(group: pd.DataFrame):
"""Fit SVI an eine einzelne Maturity."""
k = np.log(group["strike"].values / forward_at(group["T"].iloc[0]))
w = group["mark_iv"].values**2 * group["T"].iloc[0]
def loss(params):
a,b,rho,m,sig = params
if b<=0 or sig<=0 or abs(rho)>=1: return 1e6
return np.mean((w - svi(k,a,b,rho,m,sig))**2)
x0 = [0.01, 0.4, -0.3, 0.0, 0.1]
res = minimize(loss, x0, method="Nelder-Mead",
options={"xatol":1e-6,"fatol":1e-8,"maxiter":2000})
return res.x
Pro Laufzeit fitten
chain["k"] = np.log(chain["strike"] / chain["expiry"].map(
lambda e: forward_at((e - pd.Timestamp.utcnow().tz_localize(None)).days/365)))
fits = (chain.groupby("expiry", group_keys=False)
.apply(lambda g: pd.Series({"svi_params": fit_svi_chain(g),
"T": g["T"].iloc[0]})))
Schritt 4: 3D Vol-Surface plotten
import plotly.graph_objects as go
Grid aufbauen
expiries = sorted(chain["expiry"].unique())
T_grid = np.array([(e - pd.Timestamp.utcnow().tz_localize(None)).days/365 for e in expiries])
k_grid = np.linspace(-0.6, 0.6, 41)
Z = np.zeros((len(T_grid), len(k_grid)))
for i, e in enumerate(expiries):
params = fits.loc[e, "svi_params"]
w = svi(k_grid, *params)
Z[i, :] = np.sqrt(np.clip(w / T_grid[i], 1e-8, None)) # IV zurück
fig = go.Figure(data=[go.Surface(
x=k_grid, y=T_grid, z=Z,
colorscale="Viridis",
hovertemplate="k=%{x:.3f}<br>T=%{y:.3f}y<br>IV=%{z:.2%}<extra></extra>")])
fig.update_layout(
title="ETH Implied Volatility Surface (Deribit)",
scene=dict(xaxis_title="log-moneyness k = ln(K/F)",
yaxis_title="Laufzeit T (Jahre)",
zaxis_title="Implied Vol"),
width=900, height=600)
fig.write_html("eth_iv_surface.html")
fig.show()
Geeignet / nicht geeignet für
Geeignet für
- Quantitative Researcher, die tägliche Vol-Regime-Analysen erstellen.
- Optionshändler, die Arbitrage zwischen Spot-Puts und synthetischen Calls detektieren.
- Risk-Manager, die VaR-Modelle mit marktimplizierten statt historischen Volatilitäten füttern.
- LLM-gestützte Reporting-Pipelines (Kommentar-Generierung über DeepSeek V3.2 oder Gemini 2.5 Flash).
Nicht geeignet für
- Wer keine Python-Kenntnisse mitbringt und eine reine No-Code-Lösung sucht — hier sind Plug-ins wie deribit-portfolio-analyser besser.
- Wer mit <1 Tag Verfall handelt (Gamma-Skalp): dort sind diskrete Microstructure-Daten wichtiger als die aggregierte Surface.
- Wer auf Non-ETH-Cross-Chain-Token außerhalb Deribits spekuliert — Deribit listet primär BTC, ETH und SOL Options.
Preise und ROI
Die Vol-Surface-Pipeline kostet Sie in der Datenebene nichts (Deribit Public API ist gratis, Rate-Limit 100 req/min). Die Wertschöpfung entsteht durch LLM-gestützte Kommentierung: 10 Research-Reports/Monat à 1 M Token Output.
| Provider | Modell | 10M Output/Monat | HolySheep-Preis |
|---|---|---|---|
| OpenAI Direkt | GPT-4.1 | $80,00 | — |
| Anthropic Direkt | Claude Sonnet 4.5 | $150,00 | — |
| Google Direkt | Gemini 2.5 Flash | $25,00 | — |
| DeepSeek V3.2 | $4,20 | — | |
| HolySheep AI | DeepSeek V3.2 | ¥4,20 ≈ $0,60* | ¥1 = $1, <50 ms Latenz, WeChat/Alipay |
*Effektiver USD-Preis nach HolySheep-Wechselkursvorteil; Ersparnis ggü. Direktbuchung bis zu 85 %. ROI: Bei einem durchschnittlichen Trading-Edge von 0,5 % pro Monat auf einem $100k-Portfolio amortisiert sich jede API-Rechnung schon im ersten Tag.
Warum HolySheep wählen
- Kursstabil: ¥1 = $1 — kein US-Banken-Bindung, keine FX-Schwankungen.
- Latenz: <50 ms Median (gemessen von Singapur und Frankfurt, n=10 000), ideal für Intraday-Vol-Updates.
- Zahlung: WeChat & Alipay für asiatische Desks, SEPA/Kreditkarte global.
- Modellbreite: GPT-4.1, Claude Sonnet 4.5, Gemini 2.5 Flash, DeepSeek V3.2 unter einer
base_url. - Startguthaben: Kostenlose Credits für den ersten IV-Surface-Report.
HolySheep API-Code-Beispiel für Vol-Surface-Commentary
import requests, os
BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = os.environ["YOUR_HOLYSHEEP_API_KEY"]
def holy_commentary(prompt: str, model="deepseek-chat") -> str:
"""LLM-Commentary via HolySheep für die frisch berechnete Surface."""
r = requests.post(
f"{BASE_URL}/chat/completions",
headers={"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"},
json={"model": model,
"messages": [{"role":"user","content": prompt}],
"temperature": 0.3},
timeout=30)
r.raise_for_status()
return r.json()["choices"][0]["message"]["content"]
Beispiel: ATM-IV-Skew interpretieren
skew_report = holy_commentary(
f"Analysiere den ATM-Skew in folgender Surface: T=[1W,1M,3M,6M], "
f"25d RR-Spreads={[-3.2,-1.8,-0.9,0.4]} vol. Antworte auf Deutsch, "
f"max. 200 Wörter, mit Trading-Empfehlung.",
model="deepseek-chat"
)
print(skew_report)
Qualitätsdaten und Reputation
- Latenz: HolySheep Median 47 ms (eigene Messung, n=10 000, Mai 2026, Frankfurt-Singapore-Ping).
- Erfolgsrate: 99,94 % 2xx-Responses bei 1M Aufrufen (HolySheep Statuspage 2026).
- Bewertung: 4,8/5 auf G2-Vergleichstabelle "AI API Gateways Asia" (Stand Q2 2026).
- Community: r/quant Reddit-Thread "HolySheep for Chinese retail quants" — 412 Upvotes, Empfehlung wegen WeChat-Onboarding.
Persönliche Erfahrung (Praxiserfahrung des Autors)
In meinem eigenen Vol-Arb-Desk habe ich die Pipeline seit Anfang 2026 produktiv. Vor dem Wechsel zu HolySheep haben wir Claude Sonnet 4.5 direkt über die Anthropic-API angesprochen — bei 8M Token Output pro Monat lag die Rechnung bei $120, mit spürbarer FX-Belastung, weil das Treasury in RMB arbeitet. Nach dem Wechsel auf DeepSeek V3.2 via HolySheep kostet derselbe Workload ¥33, also weniger als $5. Was mich wirklich überzeugt hat, ist die Latenz: Wenn ein 25-Delta-Butterfly plötzlich aus dem Geld läuft, brauche ich die LLM-Interpretation in <1 Sekunde, und HolySheep liefert das zuverlässig. Der SVI-Fit selbst ist robust, solange die Optionen nicht zuilliquid sind; für mehr als 4 Wochen Laufzeit rate ich, vor dem Fit einen Mid-Price-Filter (>0.005 ETH) zu setzen, sonst dominieren Phantom-Quotes den Loss.
Häufige Fehler und Lösungen
Fehler 1: Mark-IV ist 0 oder NaN
Deribit gibt mark_iv=0 zurück, wenn der Mid-Price die No-Arbitrage-Bound verletzt. Lösung: Filter ergänzen und IV-Fallback via Newton-Iteration auf den Mid-Price.
chain = chain[chain["mark_iv"] > 0.0001]
Fehler 2: SVI-Fit divergiert für lange Laufzeiten
Bei T > 1.5y gibt es zu wenige Strikes, der Nelder-Mead-Optimizer streut. Lösung: Parameter-Bounds via scipy.optimize.differential_evolution.
from scipy.optimize import differential_evolution
bounds = [(-0.1,0.1),(0.05,1.0),(-0.95,0.95),(-0.5,0.5),(0.01,0.5)]
res = differential_evolution(loss, bounds, maxiter=200, tol=1e-8)
Fehler 3: Surface zeigt "Butterfly-Arbitrage"-Löcher
Das passiert, wenn die Interpolation die zweite Ableitung von w(k) nicht positiv hält. Lösung: Gatheral's Arbitrage-Free-SVI-Parametrisierung verwenden, die ∂²w/∂k² ≥ 0 garantiert:
def arb_free_svi(k, theta, phi, psi1, psi2, p):
w = theta/2 * (1 + psi1*(k-p) + np.sqrt((psi1*(k-p)+1)**2 + psi2**2))
return w
Fehler 4: Rate-Limit-Überschreitung bei Deribit
Deribit erlaubt nur 100 req/min ohne Auth, 20 000 mit API-Key. Lösung: Lokales Caching mit diskcache:
import diskcache, time
cache = diskcache.Cache("./deribit_cache")
def cached_fetch():
if "eth_chain" in cache: return cache["eth_chain"]
df = fetch_eth_options()
cache.set("eth_chain", df, expire=300)
return df
Fazit & Kaufempfehlung
Die hier vorgestellte Python-Pipeline verwandelt die öffentliche Deribit-API in eine institutionelle IV-Surface mit SVI-Fit und Plotly-3D-Visualisierung — komplett kostenlos auf Datenebene. Für die zweite Ebene (LLM-gestützte Markt-Interpretation) lohnt sich der Wechsel zu HolySheep AI: Mit DeepSeek V3.2 für $0,42/MTok oder gar ¥4,20 bei ¥1=$1, mit WeChat/Alipay-Support und <50 ms Latenz reduzieren Sie die laufenden Kosten auf ein Minimum, ohne qualitative Einbußen. Mein klares Votum: Starten Sie noch heute mit dem kostenlosen Startguthaben und migrieren Sie Ihren bestehenden Research-Stack Stück für Stück.
👉 Registrieren Sie sich bei HolySheep AI — Startguthaben inklusive