Willkommen zu einem weiteren Tutorial aus der HolySheep AI Werkstatt! In diesem Beitrag zeige ich Ihnen, wie Sie mit Tardis-Daten mithilfe von Plotly beeindruckende Order-Book-Hitzbilder und成交-Verteilungen erstellen. Das Beste: Wir nutzen dafür die HolySheep API, die mit unter 50ms Latenz und über 85% Kostenersparnis im Vergleich zu großen Anbietern punktet.

Was ist ein Order Book und warum visualisieren?

Ein Order Book ist wie ein digitales Schwarzen Brett für ein Handelspaar. Auf der einen Seite stehen die 买价 (Kaufaufträge), auf der anderen die 卖价 (Verkaufsaufträge). Die Visualisierung hilft Tradern, Marktliquidität und Preisbewegungen sofort zu erfassen.

Voraussetzungen und Setup

Bevor wir starten, benötigen Sie:

# Installation der benötigten Pakete
pip install plotly pandas requests kaleido


Für Jupyter Notebook Benutzer:


pip install ipywidgets

Schritt 1: Tardis-Daten über HolySheep API abrufen

Die HolySheep API bietet Zugang zu Tardis-Daten (Exchange History Data). Mit dem Endpunkt /market_data/tardis können Sie Order-Book-Snapshots und Trades für über 30 Kryptobörsen abrufen.

import requests
import pandas as pd
import json


HolySheep API Konfiguration

BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY"  # Ersetzen Sie mit Ihrem Key

def get_tardis_orderbook(exchange, symbol, date):
    """
    Ruft Order Book Daten von Tardis über HolySheep API ab.
    
    Args:
        exchange: Börsenname (z.B. 'binance', 'bybit')
        symbol: Handelspaar (z.B. 'BTC-USDT')
        date: Datum im Format '2024-01-15'
    
    Returns:
        DataFrame mit Order Book Daten
    """
    endpoint = f"{BASE_URL}/market_data/tardis/orderbook"
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    payload = {
        "exchange": exchange,
        "symbol": symbol,
        "date": date,
        "limit": 1000  # Anzahl der Snapshots
    }
    
    try:
        response = requests.post(endpoint, headers=headers, json=payload, timeout=30)
        response.raise_for_status()
        data = response.json()
        
        # In DataFrame umwandeln
        bids = pd.DataFrame(data['bids'])
        asks = pd.DataFrame(data['asks'])
        
        return bids, asks
    
    except requests.exceptions.Timeout:
        print("⏰ Timeout: Server antwortet nicht innerhalb 30s")
        return None, None
    except requests.exceptions.RequestException as e:
        print(f"❌ API Fehler: {e}")
        return None, None


Beispielaufruf

bids_df, asks_df = get_tardis_orderbook(
    exchange="binance",
    symbol="BTC-USDT",
    date="2024-01-15"
)

Schritt 2: Order Book Heatmap erstellen

Die Heatmap zeigt die Liquiditätsverteilung im Order Book. Dichte Bereiche (viele Aufträge) erscheinen in warmen Farben, dünne Bereiche in kühlen Farben.

import plotly.graph_objects as go
import numpy as np

def create_orderbook_heatmap(bids_df, asks_df, symbol="BTC-USDT"):
    """
    Erstellt eine Heatmap-Visualisierung des Order Books.
    """
    # Daten aufbereiten
    bid_prices = bids_df['price'].astype(float).values
    bid_volumes = bids_df['volume'].astype(float).values
    
    ask_prices = asks_df['price'].astype(float).values
    ask_volumes = asks_df['volume'].astype(float).values
    
    # Gemeinsame Preisspanne erstellen
    min_price = min(bid_prices.min(), ask_prices.min())
    max_price = max(bid_prices.max(), ask_prices.max())
    
    # Preisbuckets erstellen (50 Ebenen)
    price_bins = np.linspace(min_price, max_price, 51)
    
    # Histogramme für Heatmap
    bid_hist, bid_edges = np.histogram(bid_prices, bins=price_bins, weights=bid_volumes)
    ask_hist, ask_edges = np.histogram(ask_prices, bins=price_bins, weights=ask_volumes)
    
    # Matrix für Heatmap (Zeit x Preis)
    # Simuliere 100 Zeitpunkte für Visualisierung
    n_times = 100
    bid_matrix = np.tile(bid_hist, (n_times, 1)) + np.random.rand(n_times, len(bid_hist)) * 0.1
    ask_matrix = np.tile(ask_hist, (n_times, 1)) + np.random.rand(n_times, len(ask_hist)) * 0.1
    
    # Heatmap erstellen
    fig = go.Figure()
    
    # Bid-Heatmap (unten/negativ)
    fig.add_trace(go.Heatmap(
        z=-bid_matrix,  # Negativ für Kaufseite
        x=[f"{p:.2f}" for p in bid_edges[:-1]],
        y=[f"t{i}" for i in range(n_times)],
        colorscale=[
            [0, 'rgb(0,100,0)'],      # Dunkelgrün (dünn)
            [0.5, 'rgb(144,238,144)'], # Hellgrün
            [1, 'rgb(0,200,0)']       # Neongrün (dicht)
        ],
        name='Kaufaufträge (Bids)',
        showscale=True,
        colorbar=dict(title="Volumen (Kauf)")
    ))
    
    # Ask-Heatmap (oben/positiv)
    fig.add_trace(go.Heatmap(
        z=ask_matrix,
        x=[f"{p:.2f}" for p in ask

Verwandte Ressourcen
Verwandte Artikel