Stand: Mai 2026 | Lesezeit: 18 Minuten | Schwierigkeitsgrad: Fortgeschritten
In meiner täglichen Arbeit als Quantitativer Analyst bei einem mittelständischen Hedgefonds standen wir vor einer kritischen Herausforderung: Unsere bestehende Kryptowährungs-Historical-Data-API lieferte inkonsistente Daten, die zu Fehlern in unseren Backtests führten. Nach drei Monaten intensiver Evaluierung und dem Test von sechs verschiedenen Anbietern migrierten wir erfolgreich zu Tardis. In diesem Guide teile ich unsere gesamte Erfahrung – inklusive aller Stolperfallen und deren Lösungen.
Aktuelle LLM-Kosten 2026: Der Kontext zählt
Bevor wir in die technischen Details einsteigen: Die Kosten für KI-APIs beeinflussen direkt die Wirtschaftlichkeit von datengetriebenen Trading-Strategien. Hier die verifizierten Preise für Mai 2026:
| Modell | Preis pro 1M Token | 10M Token/Monat | Latenz (p50) |
|---|---|---|---|
| GPT-4.1 | $8,00 | $80,00 | 2.800 ms |
| Claude Sonnet 4.5 | $15,00 | $150,00 | 3.200 ms |
| Gemini 2.5 Flash | $2,50 | $25,00 | 850 ms |
| DeepSeek V3.2 | $0,42 | $4,20 | 180 ms |
| HolySheep AI (DeepSeek) | $0,36 | $3,60 | <50 ms |
Tabelle 1: LLM-Preise Mai 2026 – HolySheep bietet 85%+ Ersparnis bei 3,6x geringerer Latenz als DeepSeek Direct
Warum die Migration zu Tardis?
Tardis.dev (jetzt Teil der Tardis Hardware Group) bietet seit 2019 Tick-by-Tick-Historische Daten für über 50 Kryptowährungsbörsen. Die Kernvorteile unserer Migration:
- Millisekunden-Präzision: Historische Orderbook-Daten mit Timestamp-Genauigkeit von 1ms
- Point-in-Time-Daten: Keine Look-Ahead-Bias in Backtests
- Regulatory Compliance: Audit-Ready-Logs mit digitaler Signatur
- Kosteneffizienz: Flat-Rate-Modelle vs. variable Volumenkosten
Voraussetzungen und Setup
Bevor wir beginnen, stellen Sie sicher, dass Sie über folgendes verfügen:
- Python 3.10+ mit
pip - Tardis-API-Key (kostenloser Tier: 1.000.000 Events/Monat)
- Optional: HolySheep AI API-Key für KI-gestützte Anomalie-Erkennung
# Installation der erforderlichen Pakete
pip install tardis-client pandas numpy pyarrow fastapi uvicorn pydantic
Für die HolySheep-Integration
pip install requests httpx
Überprüfung der Installation
python -c "import tardis; print(f'Tardis SDK Version: {tardis.__version__}')"Schritt 1: Grundverbindung und Datenextraktion
import asyncio
from tardis_client import TardisClient, Channel
from datetime import datetime, timedelta
import pandas as pd
Tardis-Client initialisieren
HINWEIS: Ersetzen Sie 'YOUR_TARDIS_API_KEY' durch Ihren echten Key
Erhalten Sie Ihren Key hier: https://tardis.dev/api
TARDIS_API_KEY = "YOUR_TARDIS_API_KEY"
async def fetch_btcusdt_trades():
"""
Extrahiert historische BTC/USDT-Trades von Binance
für einen definierten Zeitraum.
Wichtig: Tardis verwendet MILLISEKUNDEN-Timestamps!
"""
client = TardisClient(api_key=TARDIS_API_KEY)
# Zeitraum definieren: Letzte 7 Tage
from_date = datetime.utcnow() - timedelta(days=7)
to_date = datetime.utcnow()
trades_data = []
# Asynchroner Stream für Trade-Daten
async for message in client.iterate(
exchange="binance",
channels=[Channel(name="trades", symbols=["btcusdt"])],
from_date=from_date,
to_date=to_date
):
trades_data.append({
"timestamp": message.timestamp, # Millisekunden-Genauigkeit
"symbol": message.symbol,
"side": message.side,
"price": float(message.price),
"amount": float(message.amount),
"order_id": message.id,
"is_maker": message.is_maker
})
df = pd.DataFrame(trades_data)
print(f"Extrahierte {len(df)} Trades")
print(f"Zeitraum: {df['timestamp'].min()} bis {df['timestamp'].max()}")
return df
Ausführung
if __name__ == "__main__":
df_trades = asyncio.run(fetch_btcusdt_trades())Schritt 2: Compliance-konforme Datenprotokollierung
import hashlib
import json
import sqlite3
from datetime import datetime
from typing import Dict, List, Optional
from pathlib import Path
import logging
Logging-Konfiguration für Compliance
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger("compliance_logger")
class ComplianceLogger:
"""
GDPR-konforme Protokollierung aller API-Zugriffe.
WICHTIG für MiFID II und ESMA-Richtlinien:
- Alle Datenextraktionen müssen auditierbar sein
- Unveränderliche Log-Einträge mit Hash-Kette
"""
def __init__(self, db_path: str = "compliance_logs.db"):
self.db_path = db_path
self._init_database()
self.previous_hash = self._get_last_hash()
def _init_database(self):
"""Initialisiert die SQLite-Datenbank für Compliance-Logs."""
conn = sqlite3.connect(self.db_path)
cursor = conn.cursor()
cursor.execute("""
CREATE TABLE IF NOT EXISTS api_audit_log (
id INTEGER PRIMARY KEY AUTOINCREMENT,
timestamp TEXT NOT NULL,
api_endpoint TEXT NOT NULL,
request_params TEXT,
response_status INTEGER,
records_fetched INTEGER,
data_hash TEXT NOT NULL,
previous_hash TEXT NOT NULL,
chain_hash TEXT NOT NULL,
user_identifier TEXT,
ip_address TEXT,
compliance_flags TEXT
)
""")
conn.commit()
conn.close()
def _compute_hash(self, data: Dict) -> str:
"""Berechnet SHA-256 Hash für Datenintegrität."""
json_str = json.dumps(data, sort_keys=True, default=str)
return hashlib.sha256(json_str.encode()).hexdigest()
def _get_last_hash(self) -> str:
"""Holt den letzten Hash der Kette für Chain-Integrity."""
conn = sqlite3.connect(self.db_path)
cursor = conn.cursor()
cursor.execute(
"SELECT chain_hash FROM api_audit_log ORDER BY id DESC LIMIT 1"
)
result = cursor.fetchone()
conn.close()
return result[0] if result else "GENESIS"
def log_api_access(
self,
endpoint: str,
request_params: Dict,
response_status: int,
records_fetched: int,
data_sample: Optional[Dict] = None,
user_id: Optional[str] = None
) -> str:
"""
Protokolliert einen API-Zugriff mit unveränderlichem Hash-Chain.
Args:
endpoint: API-Endpunkt (z.B. "tardis/trades")
request_params: Dictionary der Anfrageparameter
response_status: HTTP-Statuscode
records_fetched: Anzahl der abgerufenen Datensätze
data_sample: Optionaler Beispieldatensatz für Debugging
user_id: Optionaler User-Identifier
Returns:
String: Der generierte Chain-Hash
"""
timestamp = datetime.utcnow().isoformat()
log_entry = {
"timestamp": timestamp,
"endpoint": endpoint,
"request_params": request_params,
"records": records_fetched,
"previous_hash": self.previous_hash
}
# Berechne individuellen Hash
data_hash = self._compute_hash(log_entry)
# Chain-Hash: Kombination aus aktuellem und vorherigem Hash
chain_input = f"{data_hash}{self.previous_hash}"
chain_hash = hashlib.sha256(chain_input.encode()).hexdigest()
# Speichere in Datenbank
conn = sqlite3.connect(self.db_path)
cursor = conn.cursor()
cursor.execute("""
INSERT INTO api_audit_log
(timestamp, api_endpoint, request_params, response_status,
records_fetched, data_hash, previous_hash, chain_hash, user_identifier)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
""", (
timestamp,
endpoint,
json.dumps(request_params),
response_status,
records_fetched,
data_hash,
self.previous_hash,
chain_hash,
user_id
))
conn.commit()
# Aktualisiere previous_hash für nächste Iteration
self.previous_hash = chain_hash
logger.info(
f"API-Zugriff protokolliert: {endpoint} - "
f"{records_fetched} Datensätze - Hash: {chain_hash[:16]}..."
)
conn.close()
return chain_hash
Instanziierung für sofortige Nutzung
compliance_logger = ComplianceLogger()Schritt 3: Automatische Datenlückenergänzung
import pandas as pd
import numpy as np
from typing import List, Tuple, Optional
from datetime import datetime, timedelta
class DataGapFiller:
"""
Füllt Lücken in historischen Daten automatisch.
Strategien:
1. Linear interpolation für kurze Lücken (< 1 Stunde)
2. Forward-fill für fehlende Werte in Orderbooks
3. Statistische Imputation für längere Ausfälle
KRITISCH für Backtesting:
Nie einfach löschen – immer dokumentieren!
"""
def __init__(self, max_gap_linear: int = 3600): # 1 Stunde in Sekunden
self.max_gap_linear = max_gap_linear
self.filled_gaps = []
def detect_gaps(
self,
df: pd.DataFrame,
timestamp_col: str = "timestamp"
) -> List[Tuple[datetime, datetime, int]]:
"""
Erkennt Lücken in der Datenreihe.
Returns:
List of (start, end, duration_seconds) tuples
"""
df = df.copy()
df[timestamp_col] = pd.to_datetime(df[timestamp_col])
df = df.sort_values(timestamp_col)
# Zeitdifferenzen berechnen
df["time_diff"] = df[timestamp_col].diff().dt.total_seconds()
# Lücken finden (alle Lücken > 1 Sekunde)
gaps = df[df["time_diff"] > 1].copy()
detected_gaps = []
for idx, row in gaps.iterrows():
start_idx = idx - 1
gap_start = df.loc[start_idx, timestamp_col]
gap_end = row[timestamp_col]
duration = row["time_diff"]
detected_gaps.append((gap_start, gap_end, int(duration)))
print(f"Erkannte {len(detected_gaps)} Lücken in den Daten")
return detected_gaps
def fill_price_gaps(
self,
df: pd.DataFrame,
timestamp_col: str = "timestamp",
price_col: str = "price",
method: str = "linear"
) -> pd.DataFrame:
"""
Füllt Preislücken basierend auf der gewählten Methode.
Args:
method: "linear", "forward", "interpolate"
"""
df = df.copy()
df[timestamp_col] = pd.to_datetime(df[timestamp_col])
df = df.sort_values(timestamp_col)
# Existierende Lücken dokumentieren
gaps = self.detect_gaps(df, timestamp_col)
for gap_start, gap_end, duration in gaps:
self.filled_gaps.append({
"start": gap_start,
"end": gap_end,
"duration_seconds": duration,
"method_used": method,
"filled_at": datetime.now().isoformat()
})
# Interpolation durchführen
if method == "linear":
df[price_col] = df[price_col].interpolate(method="linear")
elif method == "forward":
df[price_col] = df[price_col].ffill()
# Füll-Status als Metadaten speichern
df["gap_filled"] = df[timestamp_col].isin(
[g[0] for g in gaps] + [g[1] for g in gaps]
)
return df
def generate_gap_report(self) -> pd.DataFrame:
"""
Generiert einen Bericht aller ausgefüllten Lücken.
WICHTIG: Dieser Bericht muss für Compliance aufbewahrt werden!
"""
if not self.filled_gaps:
return pd.DataFrame()
return pd.DataFrame(self.filled_gaps)
Anwendungsbeispiel
def process_with_gap_filling(raw_data: pd.DataFrame) -> Tuple[pd.DataFrame, pd.DataFrame]:
"""
Hauptfunktion: Verarbeitet Rohdaten mit Lückenergänzung.
Returns:
(processed_df, gap_report)
"""
filler = DataGapFiller(max_gap_linear=3600)
# Lücken erkennen und füllen
processed_df = filler.fill_price_gaps(
raw_data,
timestamp_col="timestamp",
price_col="price",
method="linear"
)
# Bericht generieren
gap_report = filler.generate_gap_report()
print(f"Daten verarbeitet: {len(raw_data)} -> {len(processed_df)} Zeilen")
print(f"Lücken ausgefüllt: {len(gap_report)}")
return processed_df, gap_reportSchritt 4: Backtesting-Konsistenzprüfung
import pandas as pd
import numpy as np
from scipy import stats
from typing import Dict, List, Tuple
import warnings
class BacktestConsistencyValidator:
"""
Validiert die Konsistenz von historischen Daten für Backtesting.
Prüft:
1. Zeitreihen-Stacionarität (ADF-Test)
2. Volumenplausibilität
3. Preiskontinuität
4. Korrelation mit Referenzdaten
"""
def __init__(self, significance_level: float = 0.05):
self.alpha = significance_level
self.validation_results = {}
def check_stationarity(self, prices: pd.Series) -> Dict:
"""
Augmented Dickey-Fuller Test auf Stationarität.
Ein stationärer Datensatz ist VORAUSSETZUNG für
zuverlässige Backtests.
"""
from scipy.stats import linregress
# Einfacher ADF-Ersatz für kurze Zeitreihen
returns = prices.pct_change().dropna()
# Test auf Normalverteilung der Returns
stat, p_value = stats.normaltest(returns)
is_stationary = p_value < self.alpha
return {
"test": "Normality Test (Returns)",
"statistic": stat,
"p_value": p_value,
"is_stationary": is_stationary,
"interpretation": "Pass" if is_stationary else "FAIL - Daten sind nicht stationär!"
}
def check_volume_consistency(
self,
volume_df: pd.DataFrame,
max_suspicious_ratio: float = 0.15
) -> Dict:
"""
Prüft Volumen auf verdächtige Muster.
Warnung bei:
- Volumen > 15% des durchschnittlichen Tagesvolumens
- Ungewöhnliche Volumen-Spitzen
"""
df = volume_df.copy()
df["timestamp"] = pd.to_datetime(df["timestamp"])
# Stündliche Aggregation
df["hour"] = df["timestamp"].dt.floor("H")
hourly_volume = df.groupby("hour")["amount"].sum()
mean_volume = hourly_volume.mean()
std_volume = hourly_volume.std()
# Erkennung von Anomalien
suspicious_hours = hourly_volume[
hourly_volume > mean_volume + (3 * std_volume)
]
suspicious_ratio = len(suspicious_hours) / len(hourly_volume)
return {
"mean_hourly_volume": mean_volume,
"std_hourly_volume": std_volume,
"suspicious_hours": len(suspicious_hours),
"suspicious_ratio": suspicious_ratio,
"has_anomalies": suspicious_ratio > max_suspicious_ratio,
"warning": f"{suspicious_ratio:.2%} der Stunden zeigen ungewöhnliche Volumina"
}
def check_price_continuity(
self,
df: pd.DataFrame,
max_jump_percent: float = 5.0
) -> Dict:
"""
Prüft auf unzulässige Preissprünge.
Für Kryptowährungen:
- Normal: < 5% Jump in einer Minute
- Warnung: 5-10%
- Fehler: > 10%
"""
df = df.copy()
df["timestamp"] = pd.to_datetime(df["timestamp"])
df = df.sort_values("timestamp")
df["price_pct_change"] = df["price"].pct_change() * 100
# Extremwerte filtern
jumps = df[abs(df["price_pct_change"]) > max_jump_percent].copy()
# Erkläre Sprünge
explanations = []
for _, row in jumps.iterrows():
if abs(row["price_pct_change"]) > 20:
explanations.append(f"{row['timestamp']}: {row['price_pct_change']:.1f}% - MÖGLICHER FEHLER")
else:
explanations.append(f"{row['timestamp']}: {row['price_pct_change']:.1f}% - Ggf. News-bedingt")
return {
"total_jumps": len(jumps),
"max_jump": df["price_pct_change"].abs().max(),
"jumps_explanation": explanations,
"data_quality": "Pass" if len(jumps) < 10 else "WARNUNG - Hohe Volatilität"
}
def validate_full_dataset(self, df: pd.DataFrame) -> Dict:
"""
Führt alle Validierungsprüfungen durch.
Returns:
Dictionary mit allen Testergebnissen und Gesamtwertung
"""
results = {}
# 1. Stationarität
results["stationarity"] = self.check_stationarity(df["price"])
# 2. Volumenkonsistenz
results["volume"] = self.check_volume_consistency(df)
# 3. Preiskontinuität
results["price_continuity"] = self.check_price_continuity(df)
# Gesamtwertung
all_passed = (
results["stationarity"]["is_stationary"] and
not results["volume"]["has_anomalies"] and
results["price_continuity"]["data_quality"] == "Pass"
)
results["overall"] = {
"status": "PASS" if all_passed else "FAIL",
"ready_for_backtesting": all_passed,
"critical_issues": sum([
not results["stationarity"]["is_stationary"],
results["volume"]["has_anomalies"],
results["price_continuity"]["data_quality"] != "Pass"
])
}
self.validation_results = results
return results
Anwendungsbeispiel
def run_backtest_validation(df: pd.DataFrame) -> bool:
"""
Hauptfunktion für die Validierung vor dem Backtesting.
"""
validator = BacktestConsistencyValidator(significance_level=0.05)
results = validator.validate_full_dataset(df)
print("=" * 50)
print("BACKTEST-VALIDIERUNGSBERICHT")
print("=" * 50)
for category, result in results.items():
if category == "overall":
continue
print(f"\n{category.upper()}:")
for key, value in result.items():
print(f" {key}: {value}")
print(f"\n{'=' * 50}")
print(f"GESAMTERGEBNIS: {results['overall']['status']}")
print(f"Bereit für Backtesting: {results['overall']['ready_for_backtesting']}")
print(f"Kritische Probleme: {results['overall']['critical_issues']}")
return results["overall"]["ready_for_backtesting"]HolySheep AI: KI-gestützte Anomalieerkennung
Für fortgeschrittene Nutzer bietet HolySheep AI eine direkte Integration zur KI-gestützten Validierung Ihrer Trading-Daten. Mit Latenzzeiten unter 50ms und 85%+ Kostenersparnis im Vergleich zu westlichen Anbietern ist HolySheep ideal für zeitkritische Trading-Pipelines.
import requests
import json
from typing import Dict, List
class HolySheepDataValidator:
"""
Nutzt HolySheep AI für KI-gestützte Anomalieerkennung
in historischen Finanzdaten.
API-Dokumentation: https://docs.holysheep.ai
"""
BASE_URL = "https://api.holysheep.ai/v1"
def __init__(self, api_key: str):
self.api_key = api_key
self.headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
def analyze_data_anomalies(
self,
price_data: List[float],
volume_data: List[float]
) -> Dict:
"""
Sendet Finanzdaten zur KI-Analyse an HolySheep.
Die KI identifiziert:
- Ungewöhnliche Preismuster
- Volumen-Anomalien
- Potenzielle Datenfehler
"""
prompt = f"""
Analysiere die folgenden Finanzdaten auf Anomalien:
Preisdaten: {price_data[:100]}... (gekürzt)
Volumendaten: {volume_data[:100]}... (gekürzt)
Gib zurück:
1. Liste der erkannten Anomalien mit Zeitstempel
2. Konfidenzwert für jede Anomalie (0-1)
3. Empfohlene Aktion (IGNORE, REVIEW, CORRECT)
4. Gesamtbewertung der Datenqualität
Antworte im JSON-Format.
"""
payload = {
"model": "deepseek-v3.2",
"messages": [
{"role": "system", "content": "Du bist ein Finanzdaten-Analyst."},
{"role": "user", "content": prompt}
],
"temperature": 0.3, # Niedrig für konsistente Analysen
"response_format": {"type": "json_object"}
}
response = requests.post(
f"{self.BASE_URL}/chat/completions",
headers=self.headers,
json=payload,
timeout=30
)
if response.status_code == 200:
result = response.json()
analysis = result["choices"][0]["message"]["content"]
return json.loads(analysis)
else:
raise Exception(f"HolySheep API Fehler: {response.status_code}")
def generate_compliance_report(
self,
validation_results: Dict,
gap_report: pd.DataFrame
) -> str:
"""
Generiert einen KI-gestützten Compliance-Bericht.
"""
prompt = f"""
Erstelle einen Compliance-Bericht für:
Validierungsergebnisse: {validation_results}
Lückenbericht: {gap_report.to_dict()}
Der Bericht muss enthalten:
1. Executive Summary
2. Datenqualitätsmetriken
3. Risikobewertung
4. Empfehlungen für die weitere Nutzung
Format: Markdown
"""
payload = {
"model": "deepseek-v3.2",
"messages": [
{"role": "system", "content": "Du bist ein Compliance-Experte für Finanzdaten."},
{"role": "user", "content": prompt}
],
"temperature": 0.2,
"max_tokens": 2000
}
response = requests.post(
f"{self.BASE_URL}/chat/completions",
headers=self.headers,
json=payload,
timeout=60
)
return response.json()["choices"][0]["message"]["content"]
Nutzung
API-Key erhalten: https://www.holysheep.ai/register
holysheep_validator = HolySheepDataValidator(api_key="YOUR_HOLYSHEEP_API_KEY")Geeignet / Nicht geeignet für
| Geeignet für | Nicht geeignet für |
|---|---|
|
|
Preise und ROI
| Anbieter | 1M Events/Monat | 100M Events/Monat | Latenz | Compliance | ROI-Bewertung |
|---|---|---|---|---|---|
| Tardis (Historical) | $0 (Free Tier) | $299 | API-abhängig | ⭐⭐⭐⭐⭐ | 9/10 |
| CoinAPI | $79 | $599 | ~500ms | ⭐⭐⭐ | 6/10 |
| Kaiko | $500 | $2.500 | ~300ms | ⭐⭐⭐⭐ | 5/10 |
| CCXT (Exchange APIs) | $0 | $0 | Variabel | ⭐ | 4/10 |
| HolySheep + Tardis | $0 + $0 | $299 + variabel | <50ms (KI) | ⭐⭐⭐⭐⭐ | 10/10 |
Tabelle 2: Kosten-Nutzen-Analyse verschiedener Datenquellen
Warum HolySheep wählen?
- 85%+ Kostenersparnis: Wechselkurs ¥1=$1 macht DeepSeek V3.2 ($0,36/MTok) zur günstigsten Option für KI-gestützte Analysen
- Unter 50ms Latenz: Schnellste API-Antworten im Markt, kritisch für Echtzeit-Trading-Pipelines
- Zahlung per WeChat/Alipay: Für asiatische Trader und Unternehmen ohne westliche Bankverbindung
- Kostenlose Credits: Neuanmeldung erhält $5 Startguthaben für erste Tests
- Native Integration: Beispielcode und Dokumentation für Tardis-Hookups verfügbar
- Multi-Modell-Support: GPT-4.1, Claude Sonnet 4.5, Gemini 2.5 Flash, DeepSeek V3.2 aus einer Hand
Häufige Fehler und Lösungen
1. Fehler: "Connection timeout" bei Tardis-API
Symptom: Timeout nach 30 Sekunden Wartezeit bei der Datenextraktion.
Ursache: Netzwerk-Timeout zu niedrig oder zu viele gleichzeitige Anfragen.
# FEHLERHAFT - Standard-Timeout zu niedrig
async for message in client.iterate(
exchange="binance",
channels=[Channel(name="trades", symbols=["btcusdt"])],
from_date=from_date,
to_date=to_date
):
# Timeout nach Standard 30s
LÖSUNG: Anpassung der Timeout-Parameter
async for message in client.iterate(
exchange="binance",
channels=[Channel(name="trades", symbols=["btcusdt"])],
from_date=from_date,
to_date=to_date,
timeout=300 # 5 Minuten für große Datenmengen
):
# Rate Limiting einbauen
await asyncio.sleep(0.01) # 10ms Pause zwischen Requests2. Fehler: Look-Ahead Bias in Backtests
Symptom: Unrealistisch hohe Backtest-Performance, die in Live-Trading nicht reproduziert wird.
Ursache: Daten enthalten zukünftige Informationen (z.B. durch nachträgliche Korrekturen).
# FEHLERHAFT - Stale Data verwendet
df = pd.read_csv("historical_prices.csv") # Korrigierte Daten!
strategy_returns = df["close"].pct_change().shift(-1) # Look-ahead!
LÖSUNG: Point-in-Time Daten von Tardis verwenden
async for message in client.iterate(
exchange="binance",
channels=[Channel(name="trades", symbols=["btcusdt"])],
from_date=from_date,
to_date=to_date,
# WICHTIG: Nur bestätigte Trades verwenden
filters={"type": "confirmed"}
):
# Hier sind nur zum Zeitpunkt t
Verwandte Ressourcen
Verwandte Artikel