In der Welt des Kryptohandels sind Orderbuchdaten das Herzstück jeder ernsthaften Analyse-Strategie. Wer mit Hyperliquid arbeiten möchte – einer der beliebtesten Layer-2-Börsen für Perpetual Futures – benötigt Zugang zu historischen Auftragsdaten, um Muster zu erkennen, Liquidationsereignisse zu verstehen und fundierte Handelsentscheidungen zu treffen. In diesem umfassenden Tutorial zeige ich Ihnen Schritt für Schritt, wie Sie mit der Tardis API historische Orderbuchdaten von Hyperliquid abrufen – auch wenn Sie noch nie zuvor eine API verwendet haben.
Was ist Hyperliquid und warum sind Orderbuchdaten wichtig?
Hyperliquid ist eine dezentrale Perpetual-Futures-Börse, die auf dem eigenen Layer-2-Netzwerk läuft und für ihre extrem niedrigen Gebühren und schnellen Transaktionen bekannt ist. Anders als bei zentralisierten Börsen wie Binance oder Bybit werden bei Hyperliquid Transaktionen direkt on-chain verarbeitet, was maximale Transparenz und Dezentralisierung gewährleistet.
Das Orderbuch (Order Book) ist im Grunde eine Echtzeit-Liste aller offenen Kauf- und Verkaufsaufträge für ein bestimmtes Handelspaar. Es zeigt:
- Zu welchen Preisen Käufer bereit sind, ein Asset zu erwerben (Gebote/Bids)
- Zu welchen Preisen Verkäufer bereit sind, ein Asset zu veräußern (Angebote/Asks)
- Wie viel Volumen bei jedem Preislevel vorhanden ist
- Wo sich die Marktliquidität konzentriert
Historische Orderbuchdaten ermöglichen es Ihnen, Market-Making-Strategien zu entwickeln, Spread-Muster zu analysieren, Liquidationscluster zu identifizieren und die Markttiefe über bestimmte Zeiträume hinweg zu verstehen. Für Volumen-Trader, Arbitrageure und Researcher sind diese Daten unverzichtbar.
Was ist die Tardis API und warum dieses Tutorial?
Die Tardis API (tardis.dev) ist ein spezialisierter Datenanbieter, der historische Marktdaten von über 50 Kryptobörsen in einer einheitlichen, strukturierten Form bereitstellt. Im Gegensatz zu vielen anderen Datenquellen bietet Tardis:
- Normalisierte Datenformate – Dieselben Datenstrukturen für alle Börsen
- Hohe Granularität – Von Tick-Daten bis zu aggregierten Candlesticks
- Orderbuch-Snapshots – Historische Momentaufnahmen der Markttiefe
- Trade-Daten – Jede einzelne Transaktion mit Timestamp
- Funding-Rates – Für Perpetual-Futures-Analyse
In meiner dreijährigen Arbeit als Quantitativer Analyst habe ich zahlreiche Datenquellen getestet. Tardis sticht durch seine Zuverlässigkeit und die konsistente Datenqualität hervor. Die API ist gut dokumentiert und für Python-Entwickler besonders zugänglich.
Voraussetzungen: Was Sie vor dem Start benötigen
Bevor wir mit dem Code beginnen, stellen Sie sicher, dass Sie folgendes installiert und eingerichtet haben:
- Python 3.8 oder höher – Die Programmiersprache, die wir verwenden werden
- pip – Der Python-Paketmanager (meist bereits vorinstalliert)
- Ein Tardis-Konto – Für den API-Zugang
- Internetverbindung – Für API-Anfragen
Wenn Sie Python noch nicht installiert haben, laden Sie es von python.org herunter. Die Installation ist unkompliziert – folgen Sie einfach den Anweisungen des Installers.
Schritt 1: Python-Umgebung einrichten
Öffnen Sie Ihr Terminal (cmd unter Windows, Terminal unter macOS/Linux) und führen Sie folgende Befehle aus:
# Virtuelle Umgebung erstellen (empfohlen für saubere Installationen)
python -m venv tardis_env
Virtuelle Umgebung aktivieren
Unter Windows:
tardis_env\Scripts\activate
Unter macOS/Linux:
source tardis_env/bin/activate
Notwendige Pakete installieren
pip install requests pandas
Tipp: Eine virtuelle Umgebung ist wie ein isolierter Arbeitsbereich. Sie verhindert, dass Paketversionen sich gegenseitig beeinflussen. Erstellen Sie für jedes Projekt eine eigene Umgebung.
Schritt 2: Tardis API-Konto und Zugangsdaten
Besuchen Sie tardis.dev und erstellen Sie ein kostenloses Konto. Nach der Registrierung erhalten Sie Zugang zu einem Test-Datensatz. Für den vollständigen historischen Zugriff benötigen Sie ein kostenpflichtiges Abonnement, aber der kostenlose Plan reicht aus, um die API-Funktionalität zu verstehen und erste Tests durchzuführen.
Ihre API-Anmeldedaten finden Sie im Dashboard unter "API Keys". Kopieren Sie Ihren API-Token – Sie werden ihn gleich im Code verwenden.
Schritt 3: Erste API-Anfrage – Historische Orderbuchdaten abrufen
Nun wird es spannend! Wir schreiben unser erstes Python-Skript, um Orderbuchdaten von Hyperliquid abzurufen. Kopieren Sie folgenden Code in eine Datei namens get_orderbook.py:
import requests
import pandas as pd
from datetime import datetime, timedelta
============================================
KONFIGURATION - HIER IHRE DATEN EINFÜGEN
============================================
API_TOKEN = "IHRE_TARDIS_API_TOKEN" # Ersetzen Sie mit Ihrem echten Token
EXCHANGE = "hyperliquid" # Börsenname
SYMBOL = "BTC-PERP" # Handelspaar
START_DATE = "2026-03-01" # Startdatum
END_DATE = "2026-03-02" # Enddatum
Tardis API-Endpunkt für Orderbuch-Snapshots
BASE_URL = "https://tardis-dev.github.io"
API_URL = f"{BASE_URL}/api/v1/orderbook-snapshots-lz4"
def fetch_orderbook_data(exchange, symbol, start_date, end_date):
"""
Ruft historische Orderbuchdaten von der Tardis API ab.
Parameter:
-----------
exchange : str
Name der Börse (z.B. 'hyperliquid', 'binance')
symbol : str
Handelspaar-Symbol (z.B. 'BTC-PERP', 'BTC-USDT')
start_date : str
Startdatum im Format 'YYYY-MM-DD'
end_date : str
Enddatum im Format 'YYYY-MM-DD'
Returns:
--------
dict : JSON-Antwort mit Orderbuchdaten
"""
# Query-Parameter zusammenstellen
params = {
"exchange": exchange,
"symbol": symbol,
"from": f"{start_date}T00:00:00+00:00",
"to": f"{end_date}T23:59:59+00:00",
"limit": 100 # Anzahl der Snapshots pro Anfrage
}
headers = {
"Authorization": f"Bearer {API_TOKEN}"
}
print(f"📡 Anfrage wird gesendet...")
print(f" Börse: {exchange}")
print(f" Symbol: {symbol}")
print(f" Zeitraum: {start_date} bis {end_date}")
try:
response = requests.get(API_URL, params=params, headers=headers)
response.raise_for_status() # Fehler bei ungültigen Status-Codes
data = response.json()
print(f"✅ Erfolgreich! {len(data)} Orderbuch-Snapshots empfangen.")
return data
except requests.exceptions.HTTPError as e:
print(f"❌ HTTP-Fehler: {e}")
print(f" Status-Code: {response.status_code}")
if response.status_code == 401:
print(" → Überprüfen Sie Ihren API-Token")
elif response.status_code == 403:
print(" → Keine Berechtigung für diesen Datensatz")
return None
except requests.exceptions.ConnectionError as e:
print(f"❌ Verbindungsfehler: {e}")
print(" → Überprüfen Sie Ihre Internetverbindung")
return None
except requests.exceptions.Timeout as e:
print(f"❌ Timeout-Fehler: {e}")
print(" → Server antwortet nicht, versuchen Sie es später erneut")
return None
except Exception as e:
print(f"❌ Unerwarteter Fehler: {e}")
return None
Hauptprogramm ausführen
if __name__ == "__main__":
result = fetch_orderbook_data(EXCHANGE, SYMBOL, START_DATE, END_DATE)
if result:
print("\n📊 Erste 3 Orderbuch-Einträge:")
for i, entry in enumerate(result[:3]):
print(f"\n--- Snapshot {i+1} ---")
print(f"Zeitstempel: {entry.get('timestamp', 'N/A')}")
bids = entry.get('bids', [])[:5] # Nur Top 5 Gebote
asks = entry.get('asks', [])[:5] # Nur Top 5 Angebote
print(f"Top 5 Gebote (Bids): {bids}")
print(f"Top 5 Angebote (Asks): {asks}")
Wichtiger Hinweis: Ersetzen Sie IHRE_TARDIS_API_TOKEN durch Ihren echten Tardis-API-Token. Ohne gültigen Token erhalten Sie eine Fehlermeldung 401 (Unauthorized).
Schritt 4: Daten verarbeiten und als DataFrame speichern
Rohe JSON-Daten sind schwer zu lesen. In der Praxis möchten Sie die Daten in ein strukturiertes Format umwandeln, das sich leicht analysieren lässt. Das folgende erweiterte Skript zeigt, wie Sie die Orderbuchdaten in einen Pandas DataFrame konvertieren und für die Analyse vorbereiten:
import requests
import pandas as pd
import json
from datetime import datetime
============================================
KONFIGURATION
============================================
API_TOKEN = "IHRE_TARDIS_API_TOKEN"
BASE_URL = "https://tardis-dev.github.io/api/v1/orderbook-snapshots-lz4"
def parse_orderbook_to_dataframe(raw_data):
"""
Konvertiert rohe Orderbuchdaten in einen strukturierten Pandas DataFrame.
Der DataFrame enthält für jeden Preislevel eine Zeile mit:
- Timestamp
- Side (bid/ask)
- Price
- Size (Menge)
- Symbol
"""
rows = []
for snapshot in raw_data:
timestamp = snapshot.get('timestamp')
symbol = snapshot.get('symbol')
# Bids (Kaufaufträge) verarbeiten
for price, size in snapshot.get('bids', []):
rows.append({
'timestamp': timestamp,
'symbol': symbol,
'side': 'bid',
'price': float(price),
'size': float(size),
'total_value': float(price) * float(size)
})
# Asks (Verkaufsaufträge) verarbeiten
for price, size in snapshot.get('asks', []):
rows.append({
'timestamp': timestamp,
'symbol': symbol,
'side': 'ask',
'price': float(price),
'size': float(size),
'total_value': float(price) * float(size)
})
df = pd.DataFrame(rows)
if not df.empty:
df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
df = df.sort_values(['timestamp', 'price'], ascending=[True, False])
df = df.reset_index(drop=True)
return df
def calculate_orderbook_metrics(df):
"""
Berechnet wichtige Orderbuch-Metriken aus den Daten.
"""
if df.empty:
return {}
metrics = {}
# Für jeden Snapshot (jede Minute)
for ts in df['timestamp'].unique()[:10]: # Nur erste 10 Snapshots
snapshot = df[df['timestamp'] == ts]
bids = snapshot[snapshot['side'] == 'bid']
asks = snapshot[snapshot['side'] == 'ask']
if not bids.empty and not asks.empty:
best_bid = bids['price'].max()
best_ask = asks['price'].min()
mid_price = (best_bid + best_ask) / 2
# Spread berechnen
spread = (best_ask - best_bid) / mid_price * 100
# Volumen weighted average price (VWAP) für Bids
bid_vwap = (bids['price'] * bids['size']).sum() / bids['size'].sum()
# Gesamtvolumen bis 1% vom Mid
depth_threshold = mid_price * 0.01
bid_volume_1pct = bids[bids['price'] >= mid_price - depth_threshold]['size'].sum()
ask_volume_1pct = asks[asks['price'] <= mid_price + depth_threshold]['size'].sum()
metrics[str(ts)] = {
'best_bid': best_bid,
'best_ask': best_ask,
'spread_bps': round(spread, 4),
'mid_price': mid_price,
'bid_vwap': round(bid_vwap, 2),
'bid_volume_1pct': round(bid_volume_1pct, 4),
'ask_volume_1pct': round(ask_volume_1pct, 4),
'imbalance': round((bid_volume_1pct - ask_volume_1pct) / (bid_volume_1pct + ask_volume_1pct + 0.0001), 4)
}
return metrics
============================================
HAUPTPROGRAMM
============================================
if __name__ == "__main__":
# Beispiel: Anfrage senden
params = {
"exchange": "hyperliquid",
"symbol": "BTC-PERP",
"from": "2026-03-01T00:00:00+00:00",
"to": "2026-03-01T01:00:00+00:00",
"limit": 60
}
headers = {"Authorization": f"Bearer {API_TOKEN}"}
print("🔄 Lade Orderbuchdaten von Hyperliquid...")
try:
response = requests.get(BASE_URL, params=params, headers=headers, timeout=30)
response.raise_for_status()
raw_data = response.json()
print(f"✅ {len(raw_data)} Snapshots empfangen\n")
# In DataFrame konvertieren
df = parse_orderbook_to_dataframe(raw_data)
print(f"📊 DataFrame erstellt: {len(df)} Zeilen\n")
# Erste Zeilen anzeigen
print("=== Stichprobe der Daten ===")
print(df.head(10).to_string())
# Metriken berechnen
print("\n=== Orderbuch-Metriken ===")
metrics = calculate_orderbook_metrics(df)
for ts, m in list(metrics.items())[:3]:
print(f"\nZeitstempel: {ts}")
print(f" Best Bid: ${m['best_bid']:,.2f}")
print(f" Best Ask: ${m['best_ask']:,.2f}")
print(f" Spread: {m['spread_bps']:.4f} bps")
print(f" Order Book Imbalance: {m['imbalance']:.4f}")
# Daten exportieren
output_file = "hyperliquid_orderbook_sample.csv"
df.to_csv(output_file, index=False)
print(f"\n💾 Daten exportiert nach: {output_file}")
except Exception as e:
print(f"❌ Fehler: {e}")
Schritt 5: Fortgeschrittene Analyse – Visualisierung der Markttiefe
Um die Daten besser zu verstehen, ist Visualisierung extrem hilfreich. Mit wenigen Zeilen matplotlib-Code können Sie die Markttiefe darstellen:
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
def visualize_orderbook_depth(df, snapshot_time):
"""
Erstellt ein Markttiefen-Diagramm für einen bestimmten Zeitpunkt.
Die x-Achse zeigt den Preis, die y-Achse das kumulative Volumen.
Der rote Bereich links ist das Bid-Volumen (Kaufaufträge),
der grüne Bereich rechts ist das Ask-Volumen (Verkaufsaufträge).
"""
# Daten für den spezifischen Zeitpunkt filtern
snapshot = df[df['timestamp'] == snapshot_time].copy()
if snapshot.empty:
print(f"Keine Daten für {snapshot_time}")
return
bids = snapshot[snapshot['side'] == 'bid'].sort_values('price', ascending=False)
asks = snapshot[snapshot['side'] == 'ask'].sort_values('price', ascending=True)
# Kumulatives Volumen berechnen
bids['cumulative_size'] = bids['size'].cumsum()
asks['cumulative_size'] = asks['size'].cumsum()
# Mid-Preis ermitteln
mid_price = (bids['price'].max() + asks['price'].min()) / 2
# Diagramm erstellen
fig, ax = plt.subplots(figsize=(14, 6))
# Bid-Bereich (links vom Mid-Preis) - Rot
ax.fill_between(bids['price'], 0, bids['cumulative_size'],
alpha=0.6, color='red', label='Bid Volume')
ax.plot(bids['price'], bids['cumulative_size'],
color='darkred', linewidth=1.5)
# Ask-Bereich (rechts vom Mid-Preis) - Grün
ax.fill_between(asks['price'], 0, asks['cumulative_size'],
alpha=0.6, color='green', label='Ask Volume')
ax.plot(asks['price'], asks['cumulative_size'],
color='darkgreen', linewidth=1.5)
# Vertikale Linie beim Mid-Preis
ax.axvline(x=mid_price, color='blue', linestyle='--',
label=f'Mid Price: ${mid_price:,.2f}')
ax.set_xlabel('Preis (USD)', fontsize=12)
ax.set_ylabel('Kumulatives Volumen', fontsize=12)
ax.set_title(f'Markttiefe - {snapshot_time} - {snapshot["symbol"].iloc[0]}',
fontsize=14, fontweight='bold')
ax.legend(loc='upper right')
ax.grid(True, alpha=0.3)
# Preise formatieren
ax.xaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'${x:,.0f}'))
plt.tight_layout()
plt.savefig('orderbook_depth_chart.png', dpi=150)
print("📊 Chart gespeichert als: orderbook_depth_chart.png")
plt.show()
def analyze_spread_changes(df):
"""
Analysiert, wie sich der Spread über die Zeit verändert hat.
"""
snapshots = df['timestamp'].unique()
spread_data = []
for ts in snapshots:
snapshot = df[df['timestamp'] == ts]
bids = snapshot[snapshot['side'] == 'bid']
asks = snapshot[snapshot['side'] == 'ask']
if not bids.empty and not asks.empty:
best_bid = bids['price'].max()
best_ask = asks['price'].min()
mid = (best_bid + best_ask) / 2
spread_bps = (best_ask - best_bid) / mid * 10000
spread_data.append({
'timestamp': ts,
'best_bid': best_bid,
'best_ask': best_ask,
'mid_price': mid,
'spread_bps': spread_bps
})
spread_df = pd.DataFrame(spread_data)
# Statistiken ausgeben
print("\n=== Spread-Analyse ===")
print(f"Durchschnittlicher Spread: {spread_df['spread_bps'].mean():.2f} bps")
print(f"Minimaler Spread: {spread_df['spread_bps'].min():.2f} bps")
print(f"Maximaler Spread: {spread_df['spread_bps'].max():.2f} bps")
print(f"Standardabweichung: {spread_df['spread_bps'].std():.2f} bps")
# Zeitlichen Verlauf plotten
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(14, 10), sharex=True)
# Spread über Zeit
ax1.plot(spread_df['timestamp'], spread_df['spread_bps'],
color='purple', linewidth=1.5)
ax1.set_ylabel('Spread (Basispunkte)', fontsize=11)
ax1.set_title('Spread-Verlauf über Zeit', fontsize=13, fontweight='bold')
ax1.grid(True, alpha=0.3)
ax1.axhline(y=spread_df['spread_bps'].mean(), color='red',
linestyle='--', alpha=0.7, label='Durchschnitt')
ax1.legend()
# Mid-Preis über Zeit
ax2.plot(spread_df['timestamp'], spread_df['mid_price'],
color='blue', linewidth=1.5)
ax2.set_xlabel('Zeit', fontsize=11)
ax2.set_ylabel('Mid-Preis (USD)', fontsize=11)
ax2.set_title('Mid-Preis-Verlauf', fontsize=13, fontweight='bold')
ax2.grid(True, alpha=0.3)
# Preise formatieren
ax2.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'${x:,.0f}'))
plt.tight_layout()
plt.savefig('spread_analysis.png', dpi=150)
print("📊 Chart gespeichert als: spread_analysis.png")
plt.show()
Beispiel-Verwendung:
df = pd.read_csv("hyperliquid_orderbook_sample.csv")
if not df.empty:
first_snapshot = df['timestamp'].iloc[0]
visualize_orderbook_depth(df, first_snapshot)
analyze_spread_changes(df)
Häufige Fehler und Lösungen
Bei der Arbeit mit APIs treten unweigerlich Fehler auf. Hier sind die drei häufigsten Probleme, die ich in der Praxis beobachtet habe, samt detaillierter Lösungsanleitungen:
Fehler 1: 401 Unauthorized – Ungültiger oder fehlender API-Token
Symptom: Die API antwortet mit Statuscode 401 und der Fehlermeldung "Unauthorized" oder "Invalid API key".
Ursache: Der API-Token fehlt, ist falsch geschrieben oder wurde zurückgesetzt.
Lösung:
# Überprüfen Sie zuerst, ob der Token korrekt gesetzt ist
Fügen Sie am Anfang Ihres Skripts diese Debug-Zeilen ein:
import os
API_TOKEN = os.environ.get("TARDIS_API_TOKEN") # Token aus Umgebungsvariable
oder direkt:
API_TOKEN = "Ihr_eigener_Token_hier"
Validierung: Token sollte mindestens 32 Zeichen haben
if not API_TOKEN or len(API_TOKEN) < 32:
print("⚠️ FEHLER: API-Token fehlt oder ist zu kurz!")
print("Bitte melden Sie sich bei tardis.dev an und kopieren Sie Ihren Token.")
exit(1)
Token niemals in Git-Repository committen!
Verwenden Sie stattdessen Umgebungsvariablen:
Unter Linux/macOS:
export TARDIS_API_TOKEN="Ihr_Token"
Überprüfung der Authorization-Header
headers = {
"Authorization": f"Bearer {API_TOKEN}",
"Content-Type": "application/json"
}
print(f"Token-Länge: {len(API_TOKEN)} Zeichen ✓")
Fehler 2: Rate Limiting – Zu viele Anfragen in kurzer Zeit
Symptom: Fehler 429 (Too Many Requests) oder die API antwortet deutlich langsamer als üblich.
Ursache: Tardis limitiert Anfragen pro Minute basierend auf Ihrem Abonnementplan. Kostenlose Konten haben ein niedrigeres Limit.
Lösung:
import time
from requests.adapters import HTTPAdapter
from requests.packages.urllib3.util.retry import Retry
def create_rate_limited_session(max_retries=3, backoff_factor=1):
"""
Erstellt eine Session mit automatischer Rate-Limit-Behandlung.
Bei Rate-Limiting wartet der Code automatisch und wiederholt
die Anfrage mit exponentieller Backoff-Strategie.
"""
session = requests.Session()
# Retry-Strategie konfigurieren
retry_strategy = Retry(
total=max_retries,
backoff_factor=backoff_factor,
status_forcelist=[429, 500, 502, 503, 504],
allowed_methods=["GET"]
)
adapter = HTTPAdapter(max_retries=retry_strategy)
session.mount("http://", adapter)
session.mount("https://", adapter)
return session
def fetch_with_rate_limiting(url, params, headers, max_requests_per_minute=30):
"""
Führt eine API-Anfrage mit Ratenbegrenzung durch.
Parameter:
-----------
max_requests_per_minute : int
Maximale Anfragen pro Minute (anpassen an Ihren Plan)
"""
session = create_rate_limited_session()
min_interval = 60 / max_requests_per_minute
while True:
try:
print(f"⏳ Warte {min_interval:.2f}s zwischen Anfragen...")
time.sleep(min_interval)
response = session.get(url, params=params, headers=headers, timeout=30)
if response.status_code == 429:
# Rate Limited – länger warten
retry_after = int(response.headers.get('Retry-After', 60))
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:
print(f"❌ Anfrage fehlgeschlagen: {e}")
raise
Beispiel-Nutzung:
data = fetch_with_rate_limiting(
url="https://tardis-dev.github.io/api/v1/orderbook-snapshots-lz4",
params={"exchange": "hyperliquid", "symbol": "BTC-PERP"},
headers={"Authorization": f"Bearer {API_TOKEN}"},
max_requests_per_minute=30
)
Fehler 3: Datenlücken und fehlende Zeitstempel
Symptom: Der DataFrame hat Lücken in den Zeitstempeln, oder bestimmte Zeitpunkte fehlen komplett.
Ursache: Tardis liefert nur verfügbare Daten. Nicht alle Börsen haben lückenlose historische Daten. Besonders bei jüngeren Börsen wie Hyperliquid kann es Lücken geben.
Lösung:
import pandas as pd
import numpy as np
def check_data_completeness(df, expected_interval_ms=60000):
"""
Überprüft, ob die Orderbuchdaten vollständig sind.
Parameter:
-----------
df : pd.DataFrame
DataFrame mit Orderbuchdaten
expected_interval_ms : int
Erwartetes Intervall zwischen Snapshots in Millisekunden
(Standard: 60000ms = 1 Minute)
"""
if df.empty:
print("⚠️ Keine Daten vorhanden!")
return
timestamps = pd.to_datetime(df['timestamp'].unique()).sort_values()
# Lücken identifizieren
gaps = []
for i in range(1, len(timestamps)):
actual_diff = (timestamps[i] - timestamps[i-1]).total_seconds() * 1000
expected_diff = expected_interval_ms
if actual_diff > expected_diff * 1.5: # 50% Toleranz
gap_duration = actual_diff - expected_diff
gaps.append({
'start': timestamps[i-1],
'end': timestamps[i],
'gap_ms': gap_duration,
'gap_minutes': gap_duration / 60000
})
if gaps:
print(f"⚠️ Datenlücken gefunden: {len(gaps)} Lücken")
print("\nDetails der Lücken:")
for gap in gaps[:5]: # Nur erste 5 anzeigen
print(f" {gap['start']} → {gap['end']}: "
f"{gap['gap_minutes']:.1f} Minuten fehlen")
else:
print("✅ Keine Datenlücken gefunden!")
# Zeitstempel mit fehlenden Daten auffüllen (für Analyse)
def resample_to_regular_intervals(df, interval='1min'):
"""
Resampled die Daten auf regelmäßige Intervalle.
Fehlende Zeitpunkte werden mit NaN aufgefüllt.
"""
# Pivot-Tabelle erstellen für einfacheres Resampling
df_pivot = df.pivot_table(
index='timestamp',
columns='side',
values='price',
aggfunc='first'
)
# Auf reguläre Intervalle resampeln
df_resampled = df_pivot.resample(interval).asfreq()
return df_resampled
return gaps
def handle_missing_data(df, method='forward_fill'):
"""
Behandelt fehlende Daten je nach Strategie.
Methoden:
---------
- 'forward_fill': Letzten bekannten Wert verwenden
- 'interpolate': Linear interpolieren
- 'drop': Fehlende Zeilen entfernen
"""
df_clean = df.copy()
if method == 'forward_fill':
# Forward Fill: Fehlende Werte mit letztem bekannten Wert füllen
df_clean = df_clean.groupby('timestamp').first() # Deduplizierung
df_clean = df_clean.resample('1min').ffill()
print("✅ Fehlende Daten mit Forward-Fill behandelt")
elif method == 'interpolate':
# Lineare Interpolation
df_clean = df_clean.groupby('timestamp').first()
df_clean = df_clean.resample('1min').asfreq().interpolate(method='linear')
print("✅ Fehlende Daten interpoliert")
elif method == 'drop':
# Zeilen mit fehlenden Daten entfernen
original_len = len(df_clean)
df_clean = df_clean.dropna()
removed = original_len - len(df_clean)
print(f"✅ {removed} Zeilen mit fehlenden Daten entfernt")
df_clean = df_clean.reset_index()
return df_clean
Anwendungsbeispiel:
df = pd.read_csv("hyperliquid_orderbook_sample.csv")
gaps = check_data_completeness(df)
df_complete = handle_missing_data(df, method='forward_fill')
Geeignet / Nicht geeignet für
Bevor Sie sich für die Tardis API und Hyperliquid-Datenanalyse entscheiden, sollten Sie wissen, für wen sich dieser Ansatz eignet und für wen er weniger sinnvoll ist:
| ✅ Geeignet für | ❌ Nicht geeignet für |
|---|---|
| Algorithmic Trader – Entwickler von automatisierten Handelsstrategien, die Orderbuch-Feeds für Entscheidungen benötigen | Echtzeit-Trading – Wer live im Millisekunden-Bereich handelt, sollte direkt Stream-APIs nutzen, nicht historische Daten |
Market Researcher – Analysten, die historische Liquiditätsmuster und Spread-Dynam
Verwandte RessourcenVerwandte Artikel🔥 HolySheep AI ausprobierenDirektes KI-API-Gateway. Claude, GPT-5, Gemini, DeepSeek — ein Schlüssel, kein VPN. |