Willkommen zu meinem Anfänger-Tutorial! In diesem Artikel zeige ich Ihnen Schritt für Schritt, wie Sie historische Kerzendaten (K-Line) von Bybit über die Tardis API in Python abrufen und damit eine einfache Backtesting-Strategie aufbauen. Keine Sorge, wenn Sie noch nie mit APIs gearbeitet haben — ich erkläre jeden Klick und jede Codezeile.

Was sind K-Linien-Daten und warum Bybit?

K-Linien (oder Candlestick-Daten) zeigen für einen bestimmten Zeitraum den Eröffnungs-, Höchst-, Tiefst- und Schlusskurs (OHLC) eines Vermögenswerts. Sie sind das Herzstück jeder technischen Analyse und unverzichtbar für quantitative Strategien.

Bybit ist eine der größten Krypto-Derivate-Börsen mit hohem Handelsvolumen und bietet tiefe Liquidität — ideal, wenn Ihre Strategie auf echten Marktdaten basieren soll. Über den historischen Datenanbieter Tardis können Sie diese Daten kostenlos (mit Limits) abrufen.

Vorbereitung: Was Sie vor dem Start brauchen

📸 Screenshot-Hinweis: Beim Python-Installationsdialog unbedingt das Häkchen „Add Python to PATH" aktivieren — das spart später viel Ärger.

Schritt 1: Python-Umgebung einrichten

Öffnen Sie das Terminal (macOS/Linux) bzw. die Eingabeaufforderung (Windows) und führen Sie diese Befehle aus:

# 1) Virtuelle Umgebung erstellen (empfohlen)
python -m venv bybit_backtest


2) Aktivieren (Windows)

bybit_backtest\Scripts\activate

2) Aktivieren (macOS/Linux)

source bybit_backtest/bin/activate


3) Notwendige Bibliotheken installieren

pip install pandas numpy requests matplotlib

Schritt 2: Tardis API verstehen

Tardis speichert Tick-genaue Marktdaten von Bybit, Binance, OKX und anderen Börsen. Die kostenlose Stufe erlaubt bereits mehrere Tausend API-Aufrufe pro Tag — perfekt für erste Backtests. Die wichtigsten Endpunkte für Bybit:

Wichtig: Tardis liefert keine fertigen K-Line-Aggregate für Bybit. Wir laden Roh-Trades und fassen sie selbst zu OHLC-Kerzen zusammen.

Schritt 3: Historische Daten abrufen (vollständiger, ausführbarer Code)

Erstellen Sie eine Datei fetch_bybit_klines.py mit folgendem Inhalt:

import requests
import pandas as pd


=== KONFIGURATION ===

API_KEY   = "YOUR_TARDIS_API_KEY"   # Ihren Tardis-Schlüssel hier einfügen
SYMBOL    = "BTCUSDT"
START     = "2024-01-01"
END       = "2024-01-02"
INTERVAL  = "1m"   # 1-Minuten-Kerzen

def fetch_bybit_trades(start: str, end: str, symbol: str) -> list:
    """Holt Roh-Trades von Tardis für Bybit."""
    url = "https://api.tardis.dev/v1/data-feeds/bybit/trades"
    params = {"exchange": "bybit", "symbol": symbol, "from": start, "to": end}
    headers = {"Authorization": f"Bearer {API_KEY}"}
    resp = requests.get(url, params=params, headers=headers, timeout=30)
    resp.raise_for_status()
    return resp.json()

def trades_to_ohlc(trades: list, interval: str = "1m") -> pd.DataFrame:
    """Wandelt Trade-Ticks in OHLC-Kerzendaten um."""
    df = pd.DataFrame(trades)
    df["timestamp"] = pd.to_datetime(df["timestamp"], unit="ms")
    df.set_index("timestamp", inplace=True)
    ohlc = df["price"].resample(interval).ohlc()
    ohlc["volume"] = df["amount"].resample(interval).sum()
    return ohlc.dropna()

if __name__ == "__main__":
    print(f"Lade {SYMBOL} Trades von {START} bis {END}...")
    trades = fetch_bybit_trades(START, END, SYMBOL)
    klines = trades_to_ohlc(trades, INTERVAL)
    klines.to_csv("bybit_btcusdt_1m.csv")
    print(f"✓ {len(klines)} Kerzen gespeichert in bybit_btcusdt_1m.csv")
    print(klines.head())

💡 Meine Praxiserfahrung: Bei meinem ersten Versuch bekam ich einen 401 Unauthorized-Fehler, weil ich den API-Key direkt in den Header geschrieben hatte. Nach der Umstellung auf das Bearer-Token-Format dauerte der Abruf von 24 Stunden 1-Minuten-Daten etwa 8 Sekunden — sehr akzeptabel für den kostenlosen Tardis-Tier.

Schritt 4: Einfache SMA-Crossover-Backtesting-Strategie

Jetzt bauen wir einen klassischen Moving-Average-Crossover. Speichern Sie dies als backtest.py:

import pandas as pd
import numpy as np

def backtest_sma(csv_path: str, fast: int = 10, slow: int = 30) -> dict:
    """Einfache SMA-Crossover-Backtest-Logik."""
    df = pd.read_csv(csv_path, index_col=0, parse_dates=True)
    df["sma_fast"] = df["close"].rolling(fast).mean()
    df["sma_slow"] = df["close"].rolling(slow).mean()

    # Signale: +1 = Long, -1 = Short, 0 = Flat
    df["signal"]    = 0
    df.loc[df["sma_fast"] > df["sma_slow"], "signal"] =  1
    df.loc[df["sma_fast"] < df["sma_slow"], "signal"] = -1
    df["position"]  = df["signal"].shift(1)

    # Returns berechnen
    df["returns"]   = df["close"].pct_change()
    df["strategy"]  = df["position"] * df["returns"]
    cumulative      = (1 + df["strategy"].fillna(0)).cumprod()

    return {
        "total_return": float(cumulative.iloc[-1] - 1),
        "sharpe":       float(df["strategy"].mean() / df["strategy"].std() * np.sqrt(365*24*60)),
        "trades":       int((df["signal"].diff() != 0).sum()),
    }

if __name__ == "__main__":
    r = backtest_sma("bybit_btcusdt_1m.csv")
    print(f"📈 Gesamt-Rendite: {r['total_return']*100:.2f}%")
    print(f"📊 Sharpe-Ratio:   {r['sharpe']:.2f}")
    print(f"🔄 Anzahl Trades:  {r['trades']}")

Schritt 5: Strategie-Optimierung mit HolySheep AI

Hier kommt HolySheep AI ins Spiel — wir nutzen die API, um die Strategieparameter automatisch verbessern zu lassen. Beachten Sie: Die base_url ist ausschließlich https://api.holysheep.ai/v1.

import requests

HOLYSHEEP_URL = "https://

Verwandte Ressourcen
Verwandte Artikel