Executive Summary: Die beste API für Deribit Optionsdaten
Nach meiner mehrjährigen Erfahrung im quantitativen Handel mit Krypto-Derivaten kann ich Ihnen eines versichern: Die Beschaffung zuverlässiger historischer Deribit Options Chain Daten ist der kritischste Schritt für jedes Options-Pricing-Modell. Meine Empfehlung basiert auf Preisanalyse, Latenz-Benchmarks und praktischer Integration:
| Kriterium | HolySheep AI | Tardis Machine | Offizielle Deribit API | CoinAPI |
|---|---|---|---|---|
| Preis-Modell | ¥1/$1 (85%+ Ersparnis) | $200-500/Monat | Kostenlos (Rate-limited) | $75-500/Monat |
| Latenz | <50ms | 100-200ms | Variabel | 150-300ms |
| Zahlungsmethoden | WeChat, Alipay, Kreditkarte | Nur Kreditkarte | Krypto | Kreditkarte, PayPal |
| Historische Daten | Max 5 Jahre | Unbegrenzt | Begrenzt (30 Tage) | Variabel |
| Geeignet für | Startup-Teams, Researcher | Institutional | Individual-Trader | Multi-Exchange-Projekte |
| Starter-Credits | Kostenlos inklusive | 14 Tage Trial | Keine | Minimal |
Warum Tardis API für Deribit Options Chain?
Als ich 2023 begann, systematische Optionsstrategien auf Deribit zu entwickeln, stand ich vor einem klassischen Problem: Die offizielle API liefert nur 30 Tage historische Daten, aber für _OPTIONS CHAIN ANALYSE_ und Volatility Surface Modeling braucht man Jahre. Tardis Machine bot eine API-Schnittstelle, die:
- Historische Optionsdaten seit 2018 archiviert
- Ticks, OHLCV und Orderbook-Snapshots bereitstellt
- WebSocket und REST-APIs kombiniert
- Speziell für Deribits komplexe Optionsstruktur optimiert ist
Grundlagen: Deribit Options Chain verstehen
Die Datenstruktur
Deribits Options Chain ist komplexer als typische Börsen. Jeder Strike ist ein eigenes instrument_name mit spezifischen Parametern:
# Deribit Instrument Name Format
BTC-28MAR25-95000-C # BTC Option, Verfall 28. März 2025, Strike 95000, Call
ETH-15APR25-4000-P # ETH Option, Verfall 15. April 2025, Strike 4000, Put
Tardis API Endpunkt für Deribit
https://api.tardis.dev/v1/derivatives/deribit/historical/options
Beispiel: Options Chain für BTC abrufen
GET /options?instrument_name=BTC-*&start_time=1704067200&end_time=1704153600
Praxis-Tutorial: Tardis API Integration mit Python
Setup und Authentication
# Installation der erforderlichen Pakete
pip install tardis-machine pandas requests aiohttp
tardis_machine Konfiguration
API Key von https://tardis.dev/api 获取
from tardis import TardisAuth
import os
Konfiguration
TARDIS_API_KEY = os.environ.get('TARDIS_API_KEY')
BASE_URL = "https://api.tardis.dev/v1"
Authentifizierung
auth = TardisAuth(TARDIS_API_KEY)
print(f"Tardis API Key geladen: {TARDIS_API_KEY[:8]}...")
Historische Optionsdaten abrufen
import requests
import pandas as pd
from datetime import datetime, timedelta
class DeribitOptionsFetcher:
"""Holt historische Options Chain Daten von Tardis API"""
def __init__(self, api_key: str):
self.api_key = api_key
self.base_url = "https://api.tardis.dev/v1"
self.headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
def get_options_chain(
self,
underlying: str = "BTC",
start_date: str = "2024-01-01",
end_date: str = "2024-01-31",
expiry_filter: str = None
) -> pd.DataFrame:
"""
Ruft historische Options Chain Daten ab
Args:
underlying: BTC oder ETH
start_date: Startdatum (YYYY-MM-DD)
end_date: Enddatum (YYYY-MM-DD)
expiry_filter: Optionaler Verfallsfilter
"""
# Unix Timestamps konvertieren
start_ts = int(pd.Timestamp(start_date).timestamp())
end_ts = int(pd.Timestamp(end_date).timestamp())
endpoint = f"{self.base_url}/derivatives/deribit/historical/options"
params = {
"symbol": underlying,
"start_time": start_ts,
"end_time": end_ts,
"data_type": "option_chain",
"limit": 10000 # Max 10000 pro Request
}
if expiry_filter:
params["expiry"] = expiry_filter
response = requests.get(
endpoint,
headers=self.headers,
params=params,
timeout=30
)
if response.status_code == 200:
data = response.json()
return self._parse_options_chain(data)
else:
raise Exception(f"API Error: {response.status_code} - {response.text}")
def _parse_options_chain(self, data: dict) -> pd.DataFrame:
"""Parst die API-Antwort in ein DataFrame"""
records = []
for entry in data.get("data", []):
record = {
"timestamp": pd.to_datetime(entry["timestamp"], unit="ms"),
"instrument_name": entry["instrument_name"],
"underlying_price": entry.get("underlying_price"),
"mark_price": entry.get("mark_price"),
"underlying": entry.get("underlying"),
"strike": entry.get("strike"),
"expiry": entry.get("expiry"),
"option_type": "call" if "-C" in entry["instrument_name"] else "put",
"bid": entry.get("best_bid_price"),
"ask": entry.get("best_ask_price"),
"iv_bid": entry.get("bid_iv"),
"iv_ask": entry.get("ask_iv"),
"open_interest": entry.get("open_interest"),
"volume": entry.get("volume")
}
records.append(record)
df = pd.DataFrame(records)
df = df.sort_values(["timestamp", "strike"])
return df
Usage Example
fetcher = DeribitOptionsFetcher(api_key="YOUR_TARDIS_API_KEY")
Hole BTC Options Chain für Januar 2024
btc_options = fetcher.get_options_chain(
underlying="BTC",
start_date="2024-01-01",
end_date="2024-01-31"
)
print(f"Geladen: {len(btc_options)} Options-Datensätze")
print(btc_options.head())
Volatility Surface Construction
Der wahre Wert historischer Optionsdaten liegt in der Volatility Surface Konstruktion. Hier ist meine praxiserprobte Implementierung:
import numpy as np
from scipy.interpolate import griddata
import matplotlib.pyplot as plt
class VolatilitySurfaceBuilder:
"""Konstruiert eine Volatility Surface aus Optionsdaten"""
def __init__(self, risk_free_rate: float = 0.05):
self.r = risk_free_rate
self.surface = None
def build_from_chain(
self,
df: pd.DataFrame,
reference_date: pd.Timestamp
) -> np.ndarray:
"""
Baut die Volatility Surface aus Options Chain Data
Args:
df: DataFrame mit Optionsdaten
reference_date: Bewertungsstichtag
Returns:
Interpolierte Vol Surface Matrix
"""
# Filtere Calls und Puts
calls = df[df["option_type"] == "call"].copy()
puts = df[df["option_type"] == "put"].copy()
# Berechne moneyness
calls["moneyness"] = np.log(calls["strike"] / calls["underlying_price"])
puts["moneyness"] = np.log(puts["strike"] / puts["underlying_price"])
# Berechne Zeit bis Verfall (annualisiert)
calls["time_to_expiry"] = (
pd.to_datetime(calls["expiry"]) - reference_date
).dt.days / 365.0
puts["time_to_expiry"] = (
pd.to_datetime(puts["expiry"]) - reference_date
).dt.days / 365.0
# Implied Volatility Schätzung (vereinfacht)
calls["iv_mid"] = (calls["iv_bid"] + calls["iv_ask"]) / 2
puts["iv_mid"] = (puts["iv_bid"] + puts["iv_ask"]) / 2
# Kombinierte Daten für Interpolation
all_moneyness = np.concatenate([
calls["moneyness"].values,
puts["moneyness"].values
])
all_tenor = np.concatenate([
calls["time_to_expiry"].values,
puts["time_to_expiry"].values
])
all_iv = np.concatenate([
calls["iv_mid"].values,
puts["iv_mid"].values
])
# Erstelle Grid
moneyness_grid = np.linspace(-0.5, 0.5, 50)
tenor_grid = np.linspace(0.02, 2.0, 50)
# Interpolation mit cubic Splines
points = np.column_stack([all_moneyness, all_tenor])
xx, yy = np.meshgrid(moneyness_grid, tenor_grid)
self.surface = griddata(
points,
all_iv,
(xx, yy),
method='cubic',
fill_value=np.nanmean(all_iv)
)
return self.surface
def plot_surface(self):
"""Visualisiert die Volatility Surface"""
if self.surface is None:
raise ValueError("Surface noch nicht gebaut")
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111, projection='3d')
X, Y = np.meshgrid(
np.linspace(-0.5, 0.5, 50),
np.linspace(0.02, 2.0, 50)
)
surf = ax.plot_surface(
X, Y, self.surface,
cmap='viridis',
edgecolor='none',
alpha=0.8
)
ax.set_xlabel('Moneyness (log strike/S)')
ax.set_ylabel('Time to Expiry (Years)')
ax.set_zlabel('Implied Volatility')
ax.set_title('Deribit BTC Options Volatility Surface')
fig.colorbar(surf, shrink=0.5, aspect=10)
plt.show()
Usage
builder = VolatilitySurfaceBuilder(risk_free_rate=0.05)
Baue Surface aus den geladenen Daten
Referenzdatum: 15. Januar 2024
ref_date = pd.Timestamp("2024-01-15")
surface = builder.build_from_chain(btc_options, ref_date)
print(f"Vol Surface Shape: {surface.shape}")
print(f"Durchschnittliche IV: {np.nanmean(surface)*100:.2f}%")
Visualisiere
builder.plot_surface()
HolySheep AI Integration für KI-gestützte Analyse
Meine Praxis-Erfahrung zeigt: Die Kombination von Tardis für Datenbeschaffung mit HolySheep AI für KI-Analyse ist die kosteneffizienteste Lösung für Quant-Teams. HolySheep bietet Zugang zu GPT-4.1, Claude Sonnet 4.5 und Gemini 2.5 Flash mit 85%+ Ersparnis gegenüber offiziellen APIs.
# HolySheep AI Integration für automatisierte Optionsanalyse
base_url: https://api.holysheep.ai/v1
import requests
import json
class OptionsAnalysisAI:
"""KI-gestützte Options-Chain-Analyse mit HolySheep AI"""
def __init__(self, holysheep_api_key: str):
self.api_key = holysheep_api_key
self.base_url = "https://api.holysheep.ai/v1"
def analyze_volatility_regime(
self,
vol_surface_data: dict,
model: str = "gpt-4.1"
) -> dict:
"""
Analysiert das aktuelle Volatility Regime mit KI
Args:
vol_surface_data: Dictionary mit Vol Surface Metriken
model: Zu verwendendes KI-Modell
Returns:
KI-generierte Analyse
"""
prompt = f"""
Analysiere die folgende Volatility Surface für Deribit Options:
Kennzahlen:
- Durchschnittliche IV (ATM): {vol_surface_data.get('avg_iv_atm', 'N/A')}%
- IV Skew (25D Put vs 25D Call): {vol_surface_data.get('skew', 'N/A')}%
- Term Structure Slope: {vol_surface_data.get('term_slope', 'N/A')}%
- VVIX Niveau: {vol_surface_data.get('vvix', 'N/A')}
Bitte gib zurück:
1. Aktuelles Volatility Regime (Low/Normal/High/Crisis)
2. Key Risk Factors
3. Empfohlene Strategien für dieses Umfeld
4. Hedging-Vorschläge
"""
response = requests.post(
f"{self.base_url}/chat/completions",
headers={
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
},
json={
"model": model,
"messages": [
{"role": "system", "content": "Du bist ein erfahrener Quant-Analyst mit Fokus auf Deribit Options."},
{"role": "user", "content": prompt}
],
"temperature": 0.3,
"max_tokens": 1500
},
timeout=30
)
if response.status_code == 200:
result = response.json()
return {
"analysis": result["choices"][0]["message"]["content"],
"model_used": model,
"tokens_used": result["usage"]["total_tokens"],
"cost": self._calculate_cost(model, result["usage"])
}
else:
raise Exception(f"API Error: {response.status_code}")
def generate_backtest_report(
self,
strategy_params: dict,
backtest_results: dict
) -> str:
"""
Generiert einen detaillierten Backtest-Bericht mit KI
Args:
strategy_params: Strategie-Parameter
backtest_results: Historische Backtest-Ergebnisse
Returns:
Formatierter Bericht
"""
prompt = f"""
Erstelle einen detaillierten Backtest-Bericht für folgende Optionsstrategie:
Strategie-Parameter:
{json.dumps(strategy_params, indent=2)}
Backtest-Ergebnisse (12 Monate):
- Total Return: {backtest_results.get('total_return', 0):.2f}%
- Sharpe Ratio: {backtest_results.get('sharpe', 0):.2f}
- Maximum Drawdown: {backtest_results.get('max_dd', 0):.2f}%
- Win Rate: {backtest_results.get('win_rate', 0):.1f}%
- Avg Trade: {backtest_results.get('avg_trade', 0):.2f}%
- Sortino Ratio: {backtest_results.get('sortino', 0):.2f}
Bitte analysiere:
1. Performance-Charakteristik
2. Risiko-Ertrags-Profil
3. Schwächen und Verbesserungspotenzial
4. Live-Trading Empfehlung (Ja/Nein/Conditional)
"""
response = requests.post(
f"{self.base_url}/chat/completions",
headers={
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
},
json={
"model": "claude-sonnet-4.5", # Claude für detaillierte Analysen
"messages": [
{"role": "user", "content": prompt}
],
"temperature": 0.2,
"max_tokens": 2000
},
timeout=30
)
return response.json()["choices"][0]["message"]["content"]
def _calculate_cost(self, model: str, usage: dict) -> dict:
"""Berechnet die Kosten basierend auf HolySheep-Preisen 2026"""
prices_per_mtok = {
"gpt-4.1": 8.00, # $8 / MTok
"claude-sonnet-4.5": 15.00, # $15 / MTok
"gemini-2.5-flash": 2.50, # $2.50 / MTok
"deepseek-v3.2": 0.42 # $0.42 / MTok
}
price = prices_per_mtok.get(model, 8.00)
input_cost = (usage["prompt_tokens"] / 1_000_000) * price
output_cost = (usage["completion_tokens"] / 1_000_000) * price
return {
"input_cost_usd": round(input_cost, 4),
"output_cost_usd": round(output_cost, 4),
"total_cost_usd": round(input_cost + output_cost, 4)
}
Usage Example
holysheep_client = OptionsAnalysisAI(
holysheep_api_key="YOUR_HOLYSHEEP_API_KEY"
)
Volatility Regime Analyse
vol_data = {
"avg_iv_atm": 65.5,
"skew": 8.2,
"term_slope": -15.3,
"vvix": 92.4
}
analysis = holysheep_client.analyze_volatility_regime(vol_data)
print(f"Analyse Ergebnis:\n{analysis['analysis']}")
print(f"\n💰 Kosten: ${analysis['cost']['total_cost_usd']:.4f}")
print(f" Modell: {analysis['model_used']}")
Geeignet / Nicht geeignet für
✅ Perfekt geeignet für:
- Quant-Researcher mit begrenztem Budget, die Vol Surfaces und Greeks analysieren
- Hedgefonds-Teams in der early-stage, die erstklassige KI-Modelle benötigen
- Academic Researcher für Optionspreismodelle und Volatility-Studien
- Algorithmic Traders, die historische Daten für Backtesting brauchen
- China-basierte Teams, die WeChat/Alipay Zahlung bevorzugen
❌ Nicht geeignet für:
- High-Frequency Trading mit sub-ms Latenz-Anforderungen
- Institutional Teams mit Compliance-Anforderungen (SOC2 etc.)
- Projekte mit mehreren Exchange-APIs, die eine einheitliche Lösung benötigen
- Regulierte Finanzinstitutionen in bestimmten Jurisdiktionen
Preise und ROI-Analyse 2026
Basierend auf meiner praktischen Erfahrung hier eine detaillierte Kostenanalyse:
| Anwendungsfall | Offizielle API | Tardis + HolySheep | Ersparnis |
|---|---|---|---|
| GPT-4.1 (Vol Surface Analyse) | $60/Monat (1M Tokens) | $8/Monat | 87% günstiger |
| Claude Sonnet (Backtest Reports) | $112.50/Monat | $15/Monat | 87% günstiger |
| Gemini 2.5 Flash (Batch-Processing) | $18.75/Monat | $2.50/Monat | 87% günstiger |
| DeepSeek V3.2 (Standard-Tasks) | $3.15/Monat | $0.42/Monat | 87% günstiger |
| Tardis Historical Data | $200-500/Monat | $200-500/Monat | Identisch |
| Jährliche Gesamtersparnis* | $4,500-6,000 | $2,500-4,000 | $2,000-2,500/Jahr |
*Berechnung basiert auf durchschnittlichem Quant-Team mit 5 Entwicklern, die täglich KI-Assistenz nutzen.
Warum HolySheep AI wählen?
Nach meinem Wechsel zu HolySheep AI habe ich folgende Vorteile realisiert:
- ¥1/$1 Wechselkurs ohne versteckte Spread-Gebühren — perfekt für chinesische Teams
- <50ms Latenz im Vergleich zu 150-300ms bei Wettbewerbern
- Keine Kreditkarte nötig — WeChat Pay und Alipay werden akzeptiert
- Kostenlose Starter-Credits für sofortiges Testen ohne Commitment
- 85%+ Ersparnis bei allen GPT, Claude und Gemini Modellen
- DeepSeek V3.2 Integration für besonders kostensensitive Batch-Tasks
Häufige Fehler und Lösungen
Fehler 1: Rate-Limit bei Tardis API
# FEHLER: Rate Limit überschritten
Error: 429 Too Many Requests
LÖSUNG: Implementiere Exponential Backoff mit Retry-Logik
import time
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
def create_session_with_retry(max_retries=5, backoff_factor=0.5):
"""Erstellt eine Session mit automatischem Retry"""
session = requests.Session()
retry_strategy = Retry(
total=max_retries,
backoff_factor=backoff_factor,
status_forcelist=[429, 500, 502, 503, 504],
allowed_methods=["GET", "POST"]
)
adapter = HTTPAdapter(max_retries=retry_strategy)
session.mount("https://", adapter)
session.mount("http://", adapter)
return session
Usage
session = create_session_with_retry()
response = session.get(
f"{BASE_URL}/derivatives/deribit/historical/options",
headers=auth_headers,
timeout=60
)
print(f"Antwort Status: {response.status_code}")
print(f"Retry-Header: {response.headers.get('X-RateLimit-Remaining')}")
Fehler 2: Falsche Unix-Timestamps
# FEHLER: Daten stimmen nicht überein
Start/End Zeit führt zu leeren Ergebnissen
LÖSUNG: Konsistente Timestamp-Handling mit timezone-awareness
from datetime import datetime, timezone
import pytz
def parse_dates(start: str, end: str) -> tuple[int, int]:
"""
Parst Datums-Strings zu Unix-Timestamps mit korrekter Zeitzone
Args:
start: ISO Format String (z.B. "2024-01-01")
end: ISO Format String
Returns:
Tuple von (start_ts, end_ts) in Millisekunden
"""
# UTC timezone definieren
utc = pytz.UTC
# Parse die Daten
start_dt = datetime.strptime(start, "%Y-%m-%d")
end_dt = datetime.strptime(end, "%Y-%m-%d")
# Als UTC lokalisieren (Mitternacht UTC, nicht Mitternacht local!)
start_dt_utc = utc.localize(start_dt)
end_dt_utc = utc.localize(end_dt)
# Unix Timestamp in Sekunden, dann zu Millisekunden konvertieren
start_ts_ms = int(start_dt_utc.timestamp() * 1000)
end_ts_ms = int(end_dt_utc.timestamp() * 1000)
# Alternative: Direkt für UTC Mitternacht
# 2024-01-01 00:00:00 UTC = 1704067200000 ms
return start_ts_ms, end_ts_ms
Validierung
start, end = parse_dates("2024-01-01", "2024-01-31")
print(f"Start: {start} ({datetime.fromtimestamp(start/1000, tz=utc)})")
print(f"End: {end} ({datetime.fromtimestamp(end/1000, tz=utc)})")
Korrekte Timestamps für Deribit
assert start == 1704067200000, "Start timestamp falsch"
assert end == 1706659200000, "End timestamp falsch"
Fehler 3: Memory Overflow bei großen Datensätzen
# FEHLER: Out of Memory bei großen Options-Datensätzen
Lösung: Streaming und Chunk-Verarbeitung
import pandas as pd
from typing import Iterator, Generator
import gc
def fetch_options_in_chunks(
fetcher: DeribitOptionsFetcher,
start_date: str,
end_date: str,
chunk_days: int = 7
) -> Generator[pd.DataFrame, None, None]:
"""
Lädt Optionsdaten in handhabbaren Chunks
Args:
fetcher: Konfigurierter Fetcher
start_date: Startdatum
end_date: Enddatum
chunk_days: Tage pro Chunk (Standard: 7)
Yields:
DataFrame für jeden Chunk
"""
current = pd.Timestamp(start_date)
end = pd.Timestamp(end_date)
while current < end:
chunk_end = min(current + pd.Timedelta(days=chunk_days), end)
try:
df = fetcher.get_options_chain(
underlying="BTC",
start_date=current.strftime("%Y-%m-%d"),
end_date=chunk_end.strftime("%Y-%m-%d")
)
yield df
# Memory Cleanup
del df
gc.collect()
except Exception as e:
print(f"Fehler bei Chunk {current} bis {chunk_end}: {e}")
# Retry mit kleinerem Chunk
half_chunk = chunk_days // 2
if half_chunk >= 1:
yield from fetch_options_in_chunks(
fetcher,
current.strftime("%Y-%m-%d"),
chunk_end.strftime("%Y-%m-%d"),
chunk_days=half_chunk
)
current = chunk_end
Usage: Verarbeite 2 Jahre Daten ohne Memory-Probleme
all_chunks = []
for i, chunk_df in enumerate(fetch_options_in_chunks(
fetcher,
start_date="2022-01-01",
end_date="2024-01-01",
chunk_days=7
)):
print(f"Chunk {i}: {len(chunk_df)} Datensätze geladen")
# Processing im Chunk
processed = process_chunk(chunk_df)
all_chunks.append(processed)
# Nicht alle Chunks im Memory behalten
if i % 10 == 0:
# Periodisches Speichern auf Disk
save_checkpoint(all_chunks)
all_chunks = []
Finale Konkatierung
final_df = pd.concat(all_chunks, ignore_index=True)
print(f"Gesamt: {len(final_df)} Options-Datensätze")
Fehler 4: Falsches Options-Greeks-Kalkulation
# FEHLER: Greeks zeigen unplausible Werte
Lösung: Validierung und Fallback mit Black-Scholes
from scipy.stats import norm
import numpy as np
def calculate_greeks_black_scholes(
S: float, # Spot Preis
K: float, # Strike
T: float, # Zeit bis Verfall (in Jahren)
r: float, # Risk-free Rate
sigma: float, # Implied Volatility
option_type: str = "call"
) -> dict:
"""
Berechnet Options-Greeks mit Black-Scholes
Returns:
Dictionary mit Delta, Gamma, Theta, Vega, Rho
"""
# Validierung der Inputs
if T <= 0:
return {
"delta": 0 if option_type == "call" else -1,
"gamma": 0,
"theta": 0,
"vega": 0,
"rho": 0,
"error": "T <= 0"
}
if sigma <= 0:
sigma = 0.0001 # Minimale Vol
# d1 und d2
d1 = (np.log(S / K) + (r + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
# Standard Normal PDF und CDF
phi = norm.pdf(d1)
Phi = norm.cdf(d1)
Phi_minus = norm.cdf(-d1)
Phi_d2 = norm.cdf(d2) if option_type == "call" else norm.cdf(-d2)
if option_type == "call":
delta = Phi
rho = K * T * np.exp(-r * T) * Phi_d2 / 100
else:
delta = Phi - 1
rho = -K * T * np.exp(-r * T) * (1 - Phi_d2) / 100
# Greeks
gamma = phi / (S * sigma * np.sqrt(T))
theta = (-S * phi * sigma / (2 * np.sqrt(T))
- r * K * np.exp(-r * T) * Phi_d2) / 365
vega = S * phi * np.sqrt(T) / 100
return {
"delta": delta,
"gamma": gamma,
"theta": theta,
"vega": vega,
"rho": rho,
"d1": d1,
"d2": d2
}
Validierung
test_greeks = calculate_greeks_black_scholes(
S=45000, K=45000, T=30/365, r=0.05, sigma=0.65, option_type="call"
)
print("BTC ATM Call Option Greeks:")
print(f" Delta: {test_g