Hyperliquid Analytics Dashboard bauen: Von null bis Praxis

6. Mai 2026

Für aktive Hyperliquid-Trader oder Quant-Researcher kann ein eigenes, laufend aktualisiertes Analytics-Dashboard die Entscheidungsfindung deutlich effizienter machen. In diesem Tutorial baust du Schritt für Schritt ein Hyperliquid Dashboard für Positions-Monitoring, Funding-Rate-Tracking und PnL-Analyse — von der Datenerfassung über die Verarbeitung bis zur Visualisierung im Frontend. Der Fokus liegt auf Open-Source-Tools, ohne zusätzliche kostenpflichtige Infrastruktur.

Welche Module sollte ein Hyperliquid Dashboard enthalten?

Ein praxisnahes Hyperliquid Dashboard deckt in der Regel diese Kernbereiche ab:

Kontostatus: Account Value, verfügbare Margin, Leverage, offene Positionen
Positionsüberwachung: Long/Short, Positionsgröße, Entry Price, unrealized PnL
Funding Rates: historische und aktuelle Funding-Daten pro Coin
Marktdaten: verfügbare Assets, Preise, Orderbook oder Trades
Alerts: z. B. bei ungewöhnlichen Funding Rates, hoher Auslastung der Margin oder starkem PnL-Swing

Die Hyperliquid-Dokumentation listet die verfügbaren Info-Endpoint-Typen und WebSocket-Subscriptions auf.

Tech-Stack auswählen

Ein bewährter Open-Source-Stack sieht so aus:

Backend-Datenerfassung: Python + requests oder aiohttp für asynchrone Requests
Datenspeicherung: SQLite für ein leichtes lokales Setup oder PostgreSQL + TimescaleDB für Time-Series-Daten
Dashboard-Framework: Grafana für robuste Dashboards oder Streamlit für schnelle Python-Prototypen
Realtime-Daten: Hyperliquid WebSocket API

Für schnelles Prototyping ist Streamlit meist die beste Wahl. Wenn du ein dauerhaftes Monitoring mit Historie, Alerts und mehreren Nutzern brauchst, ist Grafana + TimescaleDB stabiler.

Datenerfassung implementieren

Account State abrufen

import requests
import time

ENDPOINT = "https://api.hyperliquid.xyz/info"

def fetch_account_state(address: str) -> dict:
    payload = {"type": "clearinghouseState", "user": address}
    r = requests.post(ENDPOINT, json=payload, timeout=10)
    r.raise_for_status()
    return r.json()

def fetch_market_data() -> dict:
    payload = {"type": "metaAndAssetCtxs"}
    r = requests.post(ENDPOINT, json=payload, timeout=10)
    r.raise_for_status()
    return r.json()

Funding Rates gesammelt abrufen

def fetch_all_funding_rates(coins: list, days: int = 1) -> dict:
    end_ms = int(time.time() * 1000)
    start_ms = end_ms - days * 24 * 3600 * 1000
    results = {}

    for coin in coins:
        payload = {
            "type": "fundingHistory",
            "coin": coin,
            "startTime": start_ms,
        }
        r = requests.post(ENDPOINT, json=payload, timeout=10)
        if r.ok:
            results[coin] = r.json()

    return results

Realtime-Daten per WebSocket abonnieren

Wenn du Orderbook-Daten oder die neuesten Trades live anzeigen möchtest, nutzt du die WebSocket-Schnittstelle von Hyperliquid:

import asyncio
import websockets
import json

WS_URL = "wss://api.hyperliquid.xyz/ws"

async def subscribe_trades(coin: str):
    async with websockets.connect(WS_URL) as ws:
        sub_msg = {
            "method": "subscribe",
            "subscription": {"type": "trades", "coin": coin}
        }
        await ws.send(json.dumps(sub_msg))

        while True:
            msg = await ws.recv()
            data = json.loads(msg)
            print(data)

asyncio.run(subscribe_trades("BTC"))

Details zu den verfügbaren WebSocket-Subscription-Typen findest du in der WebSocket-Sektion der Hyperliquid-Dokumentation.

Dashboard UI mit Streamlit bauen

import streamlit as st
import pandas as pd
import plotly.express as px

st.set_page_config(page_title="Hyperliquid Dashboard", layout="wide")

ADDRESS = st.sidebar.text_input("Wallet-Adresse eingeben", value="0x...")

if ADDRESS.startswith("0x"):
    state = fetch_account_state(ADDRESS)
    margin = state.get("marginSummary", {})

    col1, col2, col3 = st.columns(3)
    col1.metric("Account Value (USDC)", f"${float(margin.get('accountValue', 0)):,.2f}")
    col2.metric("Verfügbare Margin", f"${float(margin.get('withdrawable', 0)):,.2f}")
    col3.metric(
        "Leverage",
        f"{float(margin.get('totalRawUsd', 0)) / max(float(margin.get('accountValue', 1)), 1):.1f}x"
    )

    positions = state.get("assetPositions", [])

    if positions:
        pos_data = []
        for p in positions:
            pos = p.get("position", {})
            pos_data.append({
                "Coin": pos.get("coin"),
                "Richtung": "Long" if float(pos.get("szi", 0)) > 0 else "Short",
                "Positionsgröße": abs(float(pos.get("szi", 0))),
                "Unrealized PnL": float(pos.get("unrealizedPnl", 0)),
                "Entry Price": float(pos.get("entryPx", 0)),
            })

        df = pd.DataFrame(pos_data)
        st.dataframe(df)

        fig = px.bar(
            df,
            x="Coin",
            y="Unrealized PnL",
            color="Richtung",
            title="Unrealized PnL nach Position"
        )
        st.plotly_chart(fig, use_container_width=True)

Dieses Setup reicht für ein lokales Dashboard bereits aus: Du gibst eine Wallet-Adresse ein, rufst den aktuellen Account State ab und visualisierst Margin, Positionen und PnL.

Produktionsnahes Dashboard mit Grafana bauen

Wenn du Team-Zugriff, historische Daten und Alerts brauchst, ist Grafana die robustere Variante:

Lokales Grafana starten: docker run -d -p 3000:3000 grafana/grafana
PostgreSQL + TimescaleDB als Datenquelle konfigurieren
Ein Python-Script schreiben, das jede Minute Hyperliquid-Daten abruft und in die Datenbank schreibt
In Grafana Panels erstellen und Charts per SQL-Abfrage bauen
Alert-Regeln konfigurieren, z. B. Benachrichtigung, wenn die Funding Rate einen definierten Schwellenwert überschreitet

Die Grafana-Dokumentation bietet ausführliche Anleitungen zur Panel- und Alert-Konfiguration.

OneKey Wallet: Die Sicherheitsbasis hinter deinem Dashboard

Die Wallet-Adresse im Dashboard dient nur zur Read-only-Abfrage. Sobald du aber auf Basis deiner Daten handeln möchtest, wird Private-Key-Sicherheit entscheidend. Eine OneKey Hardware Wallet speichert deine Private Keys in einem physischen Secure Chip. Selbst wenn dein Computer mit Malware infiziert ist, lassen sich die Private Keys nicht einfach aus dem Gerät extrahieren.

In Kombination mit OneKey Perps kannst du nach einem Signal aus deinem Dashboard Hyperliquid Perpetuals ausführen und Transaktionen per Hardware Wallet signieren. So entsteht ein sauberer Workflow aus Datenanalyse + sicherer Ausführung.

Wenn du dein Trading-Setup um Hardware-Sicherheit erweitern möchtest, lade OneKey herunter, richte deine Wallet ein und nutze OneKey Perps als praktische Oberfläche für Hyperliquid Perps. Prüfe vor jedem Trade die Parameter sorgfältig und handle nur mit Risiko, das du verstehst und tragen kannst.

Häufige Fragen

Q1: Gibt es ein offizielles Grafana-Datenquellen-Plugin für Hyperliquid?

Aktuell gibt es kein offizielles Grafana-Plugin für Hyperliquid. Du kannst Hyperliquid-Daten aber über Grafanas JSON API Data Source oder das Infinity-Plugin direkt abfragen. Alternativ speicherst du die Daten zuerst in einer eigenen Datenbank und nutzt Grafana dann auf dieser Zwischenschicht.

Q2: Können WebSocket-Verbindungen automatisch abbrechen?

Ja. WebSocket-Verbindungen können nach längerer Inaktivität oder bei Netzwerkproblemen timeouten. Implementiere deshalb Ping/Pong-Heartbeats und automatische Reconnect-Logik, damit deine Datenerfassung stabil bleibt.

Q3: Kann das Dashboard auch Kontodaten anderer Wallets anzeigen?

Ja. Hyperliquid-Kontodaten sind öffentlich einsehbare On-Chain-Daten. Du brauchst nur eine gültige Ethereum-Adresse, um die zugehörigen Informationen abzufragen. Das bedeutet gleichzeitig: Auch deine eigenen Daten sind öffentlich sichtbar.

Q4: Wie kann ich Alerts für ungewöhnliche Funding Rates einrichten?

Du kannst im Datenerfassungs-Script Bedingungen einbauen. Wenn eine Funding Rate einen von dir definierten Schwellenwert überschreitet, etwa 0,1 % pro Stunde, verschickst du eine Benachrichtigung per Telegram Bot API oder E-Mail. Grafana hat ebenfalls integrierte Alert-Funktionen.

Q5: Streamlit oder Grafana — was ist besser für Einsteiger?

Streamlit ist für Python-Entwickler oft einfacher, weil du mit wenigen Zeilen Code schnell Charts und Tabellen bauen kannst. Grafana eignet sich besser für langfristigen Betrieb, Team-Nutzung, Datenhistorie und komplexe Alerts. Die Lernkurve ist etwas steiler, dafür ist der Funktionsumfang größer.

Risikohinweis

Dieser Artikel ist ein technisches Tutorial und keine Anlage-, Finanz- oder Rechtsberatung. Kryptomärkte sind volatil, und Dashboard-Daten dienen nur als Informationsquelle. Sie sind keine Prognose zukünftiger Erträge. Triff Trading-Entscheidungen nur, wenn du die Risiken verstehst, und prüfe Daten sowie Transaktionen immer eigenständig.