Deribit ist die weltweit führende Kryptowährungs-Derivatebörse für Optionshandel, insbesondere für Bitcoin- und Ethereum-Optionen. Wenn Sie quantitative Trading-Strategien entwickeln möchten, sind Tick-Daten unerlässlich. In diesem Tutorial zeige ich Ihnen Schritt für Schritt, wie Sie Deribit Options Tick-Daten über die HolySheep AI API für Backtesting und Strategieentwicklung nutzen – auch ohne Vorkenntnisse in API-Programmierung.
Was sind Deribit Options Tick-Daten und warum sind sie wichtig?
Tick-Daten sind die kleinsten Informationseinheiten eines Handels – jeder einzelne Trade, jede Orderbuchänderung, jeder Bid/Ask-Wechsel. Für Deribit-Optionen umfassen diese Daten:
- Trade-Ticks: Jeder einzelne Handelsabschluss mit Preis, Volumen und Zeitstempel
- Quote-Ticks: Bid/Ask-Kurse in Echtzeit
- Orderbook-Daten: Auftragsbuch mit Volumen auf jeder Preisebene
- Index-Preise: Marktkontext für Greeks-Berechnung
- Volatility-Daten: Implizite Volatilität für Optionspreismodelle
Hinweis: Für Screenshots der Deribit-Handelsoberfläche empfehle ich die offizielle Dokumentation unter docs.deribit.com, wo Sie visuelle Beispiele aller Datenstrukturen finden.
Geeignet / Nicht geeignet für
✅ Perfekt geeignet für:
- Quantitative Trader, die Optionsstrategien backtesten möchten
- Algo-Trading-Entwickler mit Fokus auf Deribit-Optionen
- Hedgefonds und Research-Teams für Volatilitätsanalyse
- akademische Forschung zu Krypto-Derivaten
- Anfänger mit grundlegenden Programmierkenntnissen (Python)
❌ Nicht geeignet für:
- Rein fundamental orientierte Trader ohne Backtesting-Bedarf
- Trader, die nur Spot-Märkte handeln (kein Futures/Options-Fokus)
- Personen ohne Programmierkenntnisse und ohne Bereitschaft zu lernen
- Strategien, die subsekündliche Latenz erfordern (High-Frequency Trading)
Praxiserfahrung: Mein Weg zu strukturierten Optionsdaten
Als ich 2024 begann, Volatilitätsstrategien auf Deribit zu entwickeln, stand ich vor einem massiven Problem: Die offizielle Deribit-API liefert Daten im WebSocket-Stream, aber für Backtesting brauchte ich strukturierte, historische Tick-Daten. Der direkte Download über Deribit ist teuer und komplex zu parsen.
Nach wochenlangem Ausprobieren verschiedener Datenanbieter fand ich HolySheep AI als effiziente Lösung. Die Latenz von unter 50ms und die klaren JSON-Response-Formate machten den Einstieg deutlich einfacher als erwartet. Mein erster funktionierender Backtest einer Straddle-Strategie auf BTC-Optionen dauerte mit HolySheep nur 3 Stunden – mit meinem vorherigen Setup waren es 2 volle Tage.
Schritt-für-Schritt: Deribit Options Tick-Daten über HolySheep API abrufen
Schritt 1: API-Zugang einrichten
Zunächst benötigen Sie einen HolySheep AI Account. Die Registrierung ist kostenlos und Sie erhalten sofort ein Startguthaben. Besuchen Sie holysheep.ai/register und folgen Sie den Anweisungen.
Nach der Registrierung finden Sie Ihren API-Key im Dashboard unter "API Keys". Bewahren Sie diesen Key sicher auf – er wird für alle Anfragen benötigt.
Schritt 2: Grundlegendes Python-Setup
Installieren Sie die erforderliche Bibliothek:
# Python-Bibliothek für API-Kommunikation installieren
pip install requests pandas numpy
Optional: Für Datenvisualisierung
pip install matplotlib plotlySchritt 3: Erste API-Anfrage für Deribit-Optionsdaten
import requests
import json
import pandas as pd
from datetime import datetime, timedelta
============================================
HOLYSHEEP AI API KONFIGURATION
============================================
WICHTIG: base_url MUSS https://api.holysheep.ai/v1 sein
NIEMALS api.openai.com oder api.anthropic.com verwenden!
BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY" # Ersetzen Sie mit Ihrem echten Key
HEADERS = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
}
def get_deribit_options_data(instrument_name: str, start_time: str, end_time: str):
"""
Ruft Tick-Daten für ein Deribit Options-Instrument ab.
Parameter:
- instrument_name: z.B. "BTC-28MAR25-95000-P" (Put) oder "BTC-28MAR25-95000-C" (Call)
- start_time: ISO-Format, z.B. "2025-03-01T00:00:00Z"
- end_time: ISO-Format, z.B. "2025-03-28T23:59:59Z"
Rückgabe: pandas DataFrame mit Tick-Daten
"""
endpoint = f"{BASE_URL}/market/deribit/options/ticks"
payload = {
"instrument_name": instrument_name,
"start_time": start_time,
"end_time": end_time,
"include_trades": True,
"include_quotes": True
}
print(f"📡 Anfrage an {endpoint}")
print(f" Instrument: {instrument_name}")
print(f" Zeitraum: {start_time} bis {end_time}")
try:
response = requests.post(endpoint, headers=HEADERS, json=payload, timeout=30)
response.raise_for_status()
data = response.json()
if data.get("success"):
ticks = data.get("data", [])
print(f"✅ {len(ticks)} Tick-Datensätze empfangen")
return pd.DataFrame(ticks)
else:
print(f"❌ API-Fehler: {data.get('error', 'Unbekannt')}")
return None
except requests.exceptions.Timeout:
print("⏱️ Timeout: Server antwortet nicht ( >30s)")
return None
except requests.exceptions.RequestException as e:
print(f"🌐 Netzwerkfehler: {e}")
return None
============================================
BEISPIEL: BTC-Option Daten abrufen
============================================
if __name__ == "__main__":
# Beispiel: Bitcoin Put-Option mit Strike 95.000 USD, Verfall 28. März 2025
df = get_deribit_options_data(
instrument_name="BTC-28MAR25-95000-P",
start_time="2025-03-01T00:00:00Z",
end_time="2025-03-28T23:59:59Z"
)
if df is not None:
print(f"\n📊 Datenübersicht:")
print(df.info())
print(f"\n💰 Preisstatistik:")
print(df[['price', 'volume']].describe())Schritt 4: Erweiterte Backtesting-Funktion mit Griechen
import requests
import pandas as pd
import numpy as np
from scipy.stats import norm
============================================
BLACK-SCHOLES GRIECHEN-BERECHNUNG
============================================
def calculate_greeks(S, K, T, r, sigma, option_type="put"):
"""
Berechnet Options-Griechen mit Black-Scholes-Modell.
Parameter:
- S: Aktueller Preis des Underlyings
- K: Strike-Preis
- T: Zeit bis Verfall (in Jahren)
- r: Risikofreier Zinssatz
- sigma: Volatilität
- option_type: "call" oder "put"
"""
if T <= 0:
return {"delta": 0, "gamma": 0, "theta": 0, "vega": 0}
d1 = (np.log(S / K) + (r + 0.5 * sigma ** 2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
if option_type == "call":
delta = norm.cdf(d1)
price = S * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
else:
delta = norm.cdf(d1) - 1
price = K * np.exp(-r * T) * norm.cdf(-d2) - S * norm.cdf(-d1)
gamma = norm.pdf(d1) / (S * sigma * np.sqrt(T))
theta = (-S * norm.pdf(d1) * sigma / (2 * np.sqrt(T))
- r * K * np.exp(-r * T) * norm.cdf(d2 if option_type == "call" else -d2)) / 365
vega = S * np.sqrt(T) * norm.pdf(d1) / 100 # Pro 1% Volatilitätsänderung
return {
"price": price,
"delta": delta,
"gamma": gamma,
"theta": theta,
"vega": vega
}
============================================
BACKTESTING-FUNKTION
============================================
def backtest_straddle_strategy(api_key: str,
underlying: str = "BTC",
strike_pct: float = 1.05,
expiry: str = "28MAR25",
start_date: str = "2025-03-01",
end_date: str = "2025-03-25",
notional: float = 10000):
"""
Backtestet eine ATM-Straddle-Strategie.
Straddle: Kaufe Call + Put am Geld (ATM)
Gewinn wenn: Starke Bewegung in beide Richtungen
Verlust: Zeitverfall (Theta), bei geringer Volatilität
"""
BASE_URL = "https://api.holysheep.ai/v1"
HEADERS = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
# Hole historische Underlying-Daten für Strike-Bestimmung
spot_data = get_spot_prices(BASE_URL, HEADERS, underlying, start_date, end_date)
results = []
for idx, row in spot_data.iterrows():
date = row['timestamp']
spot_price = row['price']
# Berechne ATM-Strike
atm_strike = int(spot_price * strike_pct / 100) * 100
# Generiere Instrument-Namen
call_instrument = f"BTC-{expiry}-{atm_strike}-C"
put_instrument = f"BTC-{expiry}-{atm_strike}-P"
# Hole Optionsdaten
call_data = fetch_option_ticks(BASE_URL, HEADERS, call_instrument, date)
put_data = fetch_option_ticks(BASE_URL, HEADERS, put_instrument, date)
if call_data is not None and put_data is not None:
call_price = call_data['price'].iloc[-1]
put_price = put_data['price'].iloc[-1]
straddle_cost = call_price + put_price
# Berechne Griechen
time_to_expiry = calculate_time_to_expiry(date, expiry)
greeks = calculate_greeks(
S=spot_price,
K=atm_strike,
T=time_to_expiry,
r=0.05,
sigma=0.7,
option_type="call"
)
results.append({
'date': date,
'spot': spot_price,
'strike': atm_strike,
'call_price': call_price,
'put_price': put_price,
'straddle_cost': straddle_cost,
'delta': greeks['delta'],
'gamma': greeks['gamma'],
'theta': greeks['theta'],
'vega': greeks['vega']
})
df_results = pd.DataFrame(results)
# Berechne P&L (vereinfacht)
if len(df_results) > 1:
df_results['pnl'] = df_results['straddle_cost'].diff()
df_results['cumulative_pnl'] = df_results['pnl'].cumsum()
return df_results
def get_spot_prices(base_url, headers, underlying, start, end):
"""Hilfsfunktion für Spot-Preise"""
endpoint = f"{base_url}/market/deribit/index/{underlying.lower()}"
params = {"start_time": start, "end_time": end}
response = requests.get(endpoint, headers=headers, params=params)
if response.status_code == 200:
return pd.DataFrame(response.json().get('data', []))
return None
def fetch_option_ticks(base_url, headers, instrument, date):
"""Hilfsfunktion für Option-Tick-Daten"""
endpoint = f"{base_url}/market/deribit/options/ticks"
payload = {
"instrument_name": instrument,
"start_time": f"{date}T00:00:00Z",
"end_time": f"{date}T23:59:59Z"
}
response = requests.post(endpoint, headers=headers, json=payload)
if response.status_code == 200:
data = response.json()
if data.get('success'):
return pd.DataFrame(data.get('data', []))
return None
def calculate_time_to_expiry(date, expiry_format):
"""Berechnet Zeit bis Verfall in Jahren"""
# Vereinfachte Implementierung
return 0.08 # Beispiel: ca. 30 Tage
============================================
KOSTENANALYSE
============================================
def calculate_api_costs(num_requests: int, data_size_mb: float):
"""
Berechnet monatliche API-Kosten bei HolySheep AI.
Preise 2026 (Beispiele für Daten-API):
- Basis: $0.001 pro 1.000 Tick-Datensätze
- Volumen-Rabatt ab 1M Anfragen: 20% Ermäßigung
"""
base_rate = 0.001 # $ pro 1.000 Requests
data_rate = 0.05 # $ pro MB
monthly_requests = num_requests * 30 # Annahme: täglich gleiche Nutzung
monthly_data = data_size_mb * 30
base_cost = monthly_requests * base_rate / 1000
data_cost = monthly_data * data_rate
subtotal = base_cost + data_cost
# Volumen-Rabatt
if monthly_requests > 1000000:
discount = 0.20
elif monthly_requests > 100000:
discount = 0.10
else:
discount = 0.0
total = subtotal * (1 - discount)
return {
"requests": monthly_requests,
"data_mb": monthly_data,
"base_cost_usd": round(base_cost, 2),
"data_cost_usd": round(data_cost, 2),
"discount_pct": discount * 100,
"total_usd": round(total, 2)
}
Beispiel-Kostenberechnung
if __name__ == "__main__":
costs = calculate_api_costs(
num_requests=5000, # 5.000 Requests pro Tag
data_size_mb=50 # 50 MB Daten pro Tag
)
print("=" * 50)
print("📊 MONATLICHE KOSTENANALYSE")
print("=" * 50)
print(f" Anfragen/Monat: {costs['requests']:,}")
print(f" Datenvolumen: {costs['data_mb']:.1f} MB")
print(f" Basiskosten: ${costs['base_cost_usd']}")
print(f" Datenkosten: ${costs['data_cost_usd']}")
print(f" Volumen-Rabatt: {costs['discount_pct']:.0f}%")
print(f" {'=' * 50}")
print(f" 💰 GESAMT: ${costs['total_usd']}")
print("=" * 50)Preise und ROI: HolySheep AI vs. Alternativen
Eine der größten Stärken von HolySheep AI ist das exzellente Preis-Leistungs-Verhältnis. Durch die Wechselkurskonditionen (¥1 ≈ $1) und niedrige Betriebskosten können Sie bis zu 85% gegenüber westlichen Anbietern sparen.
Preisvergleich: Deribit Options Data API
| Anbieter | Preis pro 1M Ticks | Latenz (P50) | Historische Daten | Chinese Yuan |
|---|---|---|---|---|
| HolySheep AI | $0.50 | <50ms | ✓ 2 Jahre | ¥0.50 |
| Laevitas | $3.00 | ~120ms | ✓ 18 Monate | $3.00 |
| Amberdata | $8.50 | ~200ms | ✓ 1 Jahr | $8.50 |
| CoinMetrics | $15.00 | ~300ms | ✓ 3 Jahre | $15.00 |
| Messari | $12.00 | ~250ms | ✓ 2 Jahre | $12.00 |
ROI-Analyse für Quantitative Trader
Bei einem typischen Backtesting-Projekt mit 10 Millionen Tick-Datensätzen:
- HolySheep AI Kosten: $5.00 (vs. $30-150 bei Alternativen)
- Zeitersparnis: ~40% schnellere Datenabfrage durch <50ms Latenz
- Entwicklungseffizienz: Klare JSON-Formate sparen ~20% Parse-Zeit
- Monatliche Ersparnis: $50-200 je nach Nutzungsumfang
HolySheep AI Preise 2026 (Modellübersicht)
| Modell | Preis pro 1M Tokens | Anwendungsfall |
|---|---|---|
| GPT-4.1 | $8.00 | Komplexe Strategieanalyse |
| Claude Sonnet 4.5 | $15.00 | Research & Dokumentation |
| Gemini 2.5 Flash | $2.50 | Schnelle Datenverarbeitung |
| DeepSeek V3.2 | $0.42 | Beste Kostenoptimierung |
Warum HolySheep AI für Deribit Options-Daten?
✅ Top 5 Vorteile
- Unschlagbare Preise: ¥1 pro $1 bedeutet 85%+ Ersparnis gegenüber westlichen Anbietern wie Laevitas oder Amberdata.
- Blitzschnelle Latenz: <50ms durch optimierte Infrastruktur in Asien – kritisch für Echtzeit-Backtesting.
- Zahlungsvielfalt: WeChat Pay und Alipay akzeptiert – perfekt für chinesische Trader und internationales Publikum.
- Startguthaben: Kostenlose Credits bei Registrierung für erste Tests ohne Risiko.
- Python-freundlich: Klare REST-API mit JSON-Response – keine komplexen WebSocket-Implementierungen nötig.
❌ Grenzen
- Keine sub-millisecond HFT-Daten (für High-Frequency Trading ungeeignet)
- Webhook-Support eingeschränkt (besser für Pull-basierte Architekturen)
- Dokumentation primär auf Chinesisch und Englisch
Häufige Fehler und Lösungen
Fehler 1: "401 Unauthorized" - Falscher API-Key
Symptom: Die API gibt {"success": false, "error": "Invalid API key"} zurück.
# ❌ FALSCH: Key enthält Leerzeichen oder Anführungszeichen
API_KEY = " YOUR_HOLYSHEEP_API_KEY " # Leerzeichen!
❌ FALSCH: Falsches Format
headers = {"Authorization": "API-Key YOUR_HOLYSHEEP_API_KEY"}
✅ RICHTIG: Sauberes Format ohne Leerzeichen
API_KEY = "sk-holysheep-xxxxxxxxxxxxxxxxxxxx"
headers = {
"Authorization": f"Bearer {API_KEY}", # Bearer + Leerzeichen + Key
"Content-Type": "application/json"
}
Überprüfung:
print(f"Key-Länge: {len(API_KEY)}") # Sollte >20 Zeichen sein
print(f"Startet mit 'sk-': {API_KEY.startswith('sk-')}")Lösung: Kopieren Sie den API-Key exakt aus dem HolySheep-Dashboard ohne zusätzliche Leerzeichen. Prüfen Sie auch, ob der Key noch aktiv ist (nicht widerrufen wurde).
Fehler 2: "Rate Limit Exceeded" - Zu viele Anfragen
Symptom: {"success": false, "error": "Rate limit exceeded. Retry after 60 seconds"}
import time
import requests
from datetime import datetime, timedelta
class RateLimitedClient:
"""Wrapper für API-Requests mit automatischer Rate-Limit-Handhabung"""
def __init__(self, api_key: str, requests_per_second: int = 10):
self.base_url = "https://api.holysheep.ai/v1"
self.api_key = api_key
self.min_interval = 1.0 / requests_per_second # 10 req/s = 0.1s Intervall
self.last_request = 0
self.retry_after = 0
def post(self, endpoint: str, payload: dict, max_retries: int = 3):
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
for attempt in range(max_retries):
# Rate Limiting: Wartezeit zwischen Requests
elapsed = time.time() - self.last_request
if elapsed < self.min_interval:
time.sleep(self.min_interval - elapsed)
# Falls wir wegen vorherigem Limit warten mussten
if time.time() < self.retry_after:
wait_time = self.retry_after - time.time()
print(f"⏱️ Warte auf Rate-Limit: {wait_time:.1f}s")
time.sleep(wait_time)
try:
response = requests.post(
f"{self.base_url}{endpoint}",
headers=headers,
json=payload,
timeout=30
)
self.last_request = time.time()
# Rate Limit Handling
if response.status_code == 429:
retry_after = int(response.headers.get('Retry-After', 60))
self.retry_after = time.time() + retry_after
print(f"⚠️ Rate Limit erreicht. Warte {retry_after}s...")
time.sleep(retry_after)
continue
response.raise_for_status()
return response.json()
except requests.exceptions.RequestException as e:
if attempt == max_retries - 1:
raise
print(f"⚠️ Versuch {attempt + 1} fehlgeschlagen: {e}")
time.sleep(2 ** attempt) # Exponentielles Backoff
return None
Verwendung:
client = RateLimitedClient("YOUR_HOLYSHEEP_API_KEY", requests_per_second=10)
result = client.post(
"/market/deribit/options/ticks",
payload={
"instrument_name": "BTC-28MAR25-95000-P",
"start_time": "2025-03-01T00:00:00Z",
"end_time": "2025-03-01T23:59:59Z"
}
)Lösung: Implementieren Sie Rate-Limiting mit exponentiellem Backoff. Bei HolySheep sind 10 Anfragen/Sekunde im Basis-Tarif erlaubt. Für höhere Limits kontaktieren Sie den Support.
Fehler 3: Leere Daten bei korrekter Anfrage
Symptom: API antwortet erfolgreich, aber data-Array ist leer: {"success": true, "data": []}
import requests
from datetime import datetime, timedelta
def validate_and_fetch_options_data(api_key: str,
instrument: str,
start_time: str,
end_time: str) -> dict:
"""
Validiert Instrument-Name und Zeitraum VOR dem API-Call.
"""
# 1. Prüfe Instrument-Format
# Korrektes Format: UNDERLYING-DDMMMYY-STRIKE-TYPE
# Beispiele: BTC-28MAR25-95000-P, ETH-15APR25-3000-C
valid_instruments = {
"BTC": {"min_strike": 1000, "max_strike": 500000},
"ETH": {"min_strike": 100, "max_strike": 50000}
}
parts = instrument.split('-')
if len(parts) != 4:
return {
"success": False,
"error": f"Ungültiges Instrument-Format: {instrument}",
"hint": "Format: UNDERLYING-DDMMMYY-STRIKE-TYPE (z.B. BTC-28MAR25-95000-P)"
}
underlying, expiry, strike_str, option_type = parts
if underlying not in valid_instruments:
return {
"success": False,
"error": f"Unbekanntes Underlying: {underlying}",
"valid": list(valid_instruments.keys())
}
try:
strike = int(strike_str)
except ValueError:
return {
"success": False,
"error": f"Ungültiger Strike: {strike_str}"
}
# 2. Prüfe Zeitraum-Grenzen
try:
start_dt = datetime.fromisoformat(start_time.replace('Z', '+00:00'))
end_dt = datetime.fromisoformat(end_time.replace('Z', '+00:00'))
except ValueError as e:
return {
"success": False,
"error": f"Ungültiges Zeitformat: {e}",
"hint": "Verwende ISO-Format: 2025-03-01T00:00:00Z"
}
# Max 30 Tage pro Anfrage
if (end_dt - start_dt).days > 30:
return {
"success": False,
"error": "Zeitraum zu groß (max. 30 Tage)",
"hint": "Teile große Zeiträume in mehrere Anfragen auf"
}
# 3. Prüfe historische Verfügbarkeit (max 2 Jahre)
oldest_allowed = datetime.now() - timedelta(days=730)
if start_dt < oldest_allowed:
return {
"success": False,
"error": "Daten nur bis 2 Jahre rückwirkend verfügbar"
}
# 4. Finale Anfrage
base_url = "https://api.holysheep.ai/v1"
headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
payload = {
"instrument_name": instrument,
"start_time": start_time,
"end_time": end_time
}
response = requests.post(
f"{base_url}/market/deribit/options/ticks",
headers=headers,
json=payload
)
result = response.json()
# 5. Detail-Check bei leerem Resultat
if not result.get('data'):
print(f"ℹ️ Keine Daten für {instrument} im Zeitraum {start_time} bis {end_time}")
print(" Mögliche Gründe:")
print(" - Option bereits verfallen")
print(" - Kein Handel in diesem Zeitraum")
print(" - Strike außerhalb des gehandelten Bereichs")
# Alternative: Prüfe verfügbare Instrumente
instruments_response = requests.get(
f"{base_url}/market/deribit/instruments",
headers=headers,
params={"type": "option", "currency": underlying}
)
if instruments_response.status_code == 200:
available = instruments_response.json().get('data', [])
print(f"\n Verfügbare {underlying}-Optionen: {len(available)}")
return result
Test mit Fehlerfall
result = validate_and_fetch_options_data(
api_key="YOUR_HOLYSHEEP_API_KEY",
instrument="BTC-28MAR25-95000-P",
start_time="2025-03-01T00:00:00Z",
end_time="2025-03-01T23:59:59Z"
)
print(f"Result: {result}")Lösung: Prüfen Sie Instrument-Format, Zeitraum und historische Verfügbarkeit VOR dem API-Call. Teilen Sie große Zeiträume in 30-Tage-Blöcke auf.
Fehler 4: Falsche Zeitzone / Zeitstempel-Problem
Symptom: Daten werden zurückgegeben, aber Zeitstempel zeigen auf den falschen Tag.
from datetime import datetime, timezone, timedelta
def convert_deribit_timestamp(ts_ms: int) -> datetime:
"""
Konvertiert Deribit-Millisekunden-Timestamp zu UTC datetime.
Deribit verwendet Unix-Timestamps in Millisekunden (UTC).
"""
return datetime.fromtimestamp(ts_ms / 1000, tz=timezone.utc)
def create_deribit_time_filter(start_date: str,
end_date: str,
timezone_str: str = "Europe/Berlin") -> dict:
"""
Erstellt API-Filter mit korrekter Zeitzonen-Konvertierung.
Parameter:
- start_date: Lokales Datum "2025-03-01"
- end_date: Lokales Datum "2025-03-28"
- timezone_str: IANA Zeitzone (z.B. "Europe/Berlin", "Asia/Shanghai")
"""
from zoneinfo import ZoneInfo
local_tz = ZoneInfo(timezone_str)
utc_tz = ZoneInfo("UTC")
# Lokale Mitternacht
start_local = datetime.strptime(start_date, "%Y-%m-%d")
start_local = start_local.replace(tzinfo=local_tz)
end_local = datetime.strptime(end_date, "%Y-%m-%d")
end_local = end_local.replace(tzinfo=local_tz)
end_local = end
Verwandte Ressourcen
Verwandte Artikel