Programmatic Trading mit dem Hyperliquid SDK

• hyperliquid sdk

• hyperliquid programmatic trade

• hyperliquid python sdk

• hyperliquid api programmatisches Trading

• On-Chain-Perpetuals-Bot

Programmatic Trading ist längst nicht mehr nur ein Tool für institutionelle Desks. Wer grundlegende Programmierkenntnisse mitbringt, kann heute eigene Trading-Workflows aufsetzen, Orders automatisieren und Risiken systematisch überwachen. Hyperliquid bietet als On-Chain-Perpetuals-Exchange vollständige REST- und WebSocket-Schnittstellen. Zusätzlich gibt es offizielle und Community-gepflegte SDKs in mehreren Sprachen, mit denen du zentrale Funktionen wie Order-Platzierung, Positionsabfrage und Fehlerbehandlung mit relativ wenig Code umsetzen kannst.

In diesem Artikel gehen wir von der Umgebungseinrichtung bis zu einem robusteren Python- oder JavaScript-Workflow durch die wichtigsten Bausteine. Außerdem zeigen wir, warum OneKey in einer produktiven Architektur als Signing-Layer eine wichtige Rolle spielen kann. Wenn du nicht selbst coden möchtest, ist OneKey Perps der praktischere Einstieg, um On-Chain-Perpetuals über eine Benutzeroberfläche zu handeln.

Warum Hyperliquid für programmatic Trading?

Im Vergleich zu zentralisierten Börsen liegt der Reiz von Hyperliquid vor allem in der Kombination aus Self-Custody und Trading-Performance: Die Abwicklung erfolgt on-chain, deine Funds müssen nicht klassisch bei einer Drittpartei verwahrt werden. Gleichzeitig nutzt Hyperliquid eine hybride Architektur mit Off-Chain-Matching und On-Chain-Settlement, um Geschwindigkeit und Transparenz zu verbinden.

Für quantitative Trader bedeutet das: Du kannst Strategien automatisieren, ohne die Kontrolle über deine Keys vollständig an eine zentrale Börse abzugeben. Die API ist vergleichsweise schlank, die Dokumentation wird laufend weiterentwickelt, und die Community ist aktiv.

Umgebung vorbereiten und SDK installieren

Python-Umgebung

Zum Zeitpunkt dieses Artikels kann das von der Community gepflegte Python SDK per pip installiert werden. Am besten arbeitest du in einer virtuellen Umgebung, um Dependency-Konflikte zu vermeiden:

python -m venv hl_env
source hl_env/bin/activate
pip install hyperliquid-python-sdk

Der SDK-Quellcode wird in relevanten Ecosystem-Repositories sowie unter Hyperliquid-nahen Organisationen gepflegt. Prüfe für aktuelle Repository-URLs und Installationshinweise immer die offizielle Dokumentation.

JavaScript-/TypeScript-Umgebung

Wenn du lieber mit Node.js arbeitest:

npm install @nktkas/hyperliquid
# oder ein offiziell gepflegtes Paket, je nach aktuellem Stand im npm registry

TypeScript-Nutzer profitieren zusätzlich von Type Definitions und besserer Autovervollständigung in der IDE.

API verbinden und Client initialisieren

Authentifizierung

Hyperliquid authentifiziert Trading-Requests über Private-Key-Signaturen. Jede Order muss mit dem Wallet Private Key als EIP-712 Structured Message signiert werden. Dadurch kann ein Request nicht einfach gefälscht werden.

Python-Beispiel als Pseudocode:

from hyperliquid.exchange import Exchange
from hyperliquid.info import Info
from eth_account import Account
import os

# Private Key aus Umgebungsvariable lesen, niemals hardcoden
private_key = os.environ["HL_PRIVATE_KEY"]
account = Account.from_key(private_key)

info = Info(base_url="https://api.hyperliquid.xyz")
exchange = Exchange(account, base_url="https://api.hyperliquid.xyz")

Für produktive Setups solltest du statt eines Software-Private-Keys eine OneKey Hardware Wallet als Signing-Layer nutzen. Der Private Key verlässt dabei nicht das sichere Hardware-Element. Selbst wenn ein Server kompromittiert wird, kann der Key nicht einfach aus einer Datei oder dem Arbeitsspeicher exportiert werden.

Marktdaten und Account-Status abfragen

Market Snapshot abrufen

# Meta-Informationen und aktuelle Daten aller Perpetual-Märkte abrufen
meta_and_asset_ctx = info.meta_and_asset_ctxs()

# Rückgabe enthält u. a. Felder wie markPx (Mark Price) und funding (Funding Rate)

Positionen und Balances abfragen

user_state = info.user_state(account.address)

# user_state enthält z. B. marginSummary und assetPositions
for pos in user_state["assetPositions"]:
    print(pos["position"]["coin"], pos["position"]["szi"])  # Markt und Positionsgröße

Orders platzieren

Market Order

order_result = exchange.market_open(
    coin="BTC",
    is_buy=True,
    sz=0.001,       # Ordergröße
    slippage=0.01   # maximal erlaubter Slippage: 1 %
)

print(order_result)

Limit Order

order_result = exchange.order(
    coin="ETH",
    is_buy=False,
    sz=0.1,
    limit_px=3200.0,  # Limitpreis
    order_type={"limit": {"tif": "Gtc"}}  # Good Till Cancel
)

Das Feld tif unterstützt Optionen wie Gtc (Good Till Cancel), Ioc (Immediate Or Cancel) und Alo (Add Liquidity Only). Welche Variante sinnvoll ist, hängt von deiner Strategie ab.

Batch Orders

Market-Making- oder Grid-Strategien müssen oft mehrere Orders gleichzeitig einreichen. SDKs unterstützen dafür Batch-Interfaces, um unnötige Netzwerk-Roundtrips zu reduzieren:

orders = [
    {"coin": "BTC", "is_buy": True,  "sz": 0.001, "limit_px": 60000, "order_type": {"limit": {"tif": "Gtc"}}},
    {"coin": "BTC", "is_buy": False, "sz": 0.001, "limit_px": 61000, "order_type": {"limit": {"tif": "Gtc"}}},
]

result = exchange.bulk_orders(orders)

Orders stornieren und ändern

# Für Cancel brauchst du coin und oid (Order ID)
cancel_result = exchange.cancel(coin="BTC", oid=123456789)

# Modify Order: intern häufig cancel + replace
modify_result = exchange.modify_order(
    oid=123456789,
    coin="BTC",
    is_buy=True,
    sz=0.002,
    limit_px=59500,
    order_type={"limit": {"tif": "Gtc"}}
)

Best Practices für Error Handling

Bei programmatic Trading ist Fehlerbehandlung kein Nebenthema, sondern Teil der Strategie. Netzwerkfehler, Rate Limits, ungültige Orderparameter, Slippage oder temporäre API-Probleme können sonst zu unerwartetem Verhalten führen.

Ein einfaches Retry-Muster mit Backoff kann so aussehen:

import time

def place_with_retry(exchange, max_retries=3, **kwargs):
    for attempt in range(max_retries):
        try:
            return exchange.order(**kwargs)
        except Exception as e:
            if attempt == max_retries - 1:
                raise
            wait = 2 ** attempt  # exponentieller Backoff: 1s, 2s, 4s
            time.sleep(wait)

In der Praxis solltest du zusätzlich unterscheiden, ob ein Fehler retrybar ist. Eine abgelehnte Order wegen falscher Parameter sollte nicht blind erneut gesendet werden. Ein temporärer Netzwerkfehler kann dagegen ein Retry-Kandidat sein.

Fills in Echtzeit per WebSocket überwachen

REST-Polling reicht für langsamere Strategien oft aus. Für schnellere Workflows oder präzisere Zustandsverwaltung sind WebSocket-Streams sinnvoll:

from hyperliquid.websocket_manager import WebsocketManager

def on_fill(data):
    print("Fill Callback:", data)

ws = WebsocketManager(base_url="wss://api.hyperliquid.xyz")

ws.subscribe(
    {"type": "userFills", "user": account.address},
    callback=on_fill
)

ws.start()

Die vollständigen WebSocket-Subscription-Formate findest du in der offiziellen Hyperliquid-Dokumentation.

Produktions-Bots mit OneKey Hardware Wallet absichern

Bei Software Wallets oder klassischen Hot Wallets liegt der Private Key typischerweise im Speicher, in einer Datei oder in einer Secret-Management-Umgebung. Wird der Server kompromittiert, können Angreifer unter Umständen direkt auf den Key zugreifen und Funds abziehen.

Für Bots mit echtem Kapital ist deshalb eine sicherere Architektur empfehlenswert:

1. Eine OneKey Hardware Wallet wird mit einem separaten Signing-Server verbunden.
2. Die Bot-Logik erzeugt die zu signierende Trading Message.
3. Die Message wird an OneKey übergeben und im sicheren Hardware-Element signiert.
4. Die Signatur wird an den Bot zurückgegeben und anschließend an Hyperliquid gesendet.

In diesem Modell bleibt der Private Key immer in der Hardware und kann nicht über die Software-Schicht exportiert werden. EIP-712 Structured Signing hilft außerdem dabei, die zu signierenden Inhalte klarer darzustellen, sodass kritische Vorgänge überprüfbar bleiben.

Zusätzlich ist es sinnvoll, für den Bot ein dediziertes API-Agent-Wallet oder eine entsprechend eingeschränkte Autorisierung zu verwenden, sofern Hyperliquid diese Account-Struktur unterstützt. So lässt sich das Risiko begrenzen, falls ein Teil der Trading-Infrastruktur kompromittiert wird.

Praktische Alternative: OneKey Perps statt eigener Bot

Nicht jeder braucht direkt eine eigene Trading-Engine. Wenn du On-Chain-Perpetuals handeln möchtest, ohne SDKs, WebSockets und Signing-Services selbst zu betreiben, ist OneKey Perps der einfachere Workflow. Du bekommst eine geführte Oberfläche für Perps-Trading und kannst deine Self-Custody-Sicherheitsarchitektur mit OneKey kombinieren.

Das ersetzt keine eigene Risikoprüfung, reduziert aber die technische Komplexität deutlich. Für viele Retail-Nutzer ist das ein sinnvollerer Startpunkt als ein selbst geschriebener Bot mit Hot-Key auf einem Server.

Nützliche Tools und Ressourcen

• Hyperliquid-Dokumentation: API-Spezifikation, Felder, Ordertypen und WebSocket-Formate
• OneKey: Informationen zu Hardware Wallets und Signatur-Workflows
• WalletConnect-Dokumentation: relevant, wenn du Signaturen über WalletConnect-Bridges einbinden möchtest

Häufige Fragen

Q1: Was ist der Unterschied zwischen SDK und direktem REST API Call?

Ein SDK kapselt typischerweise Signaturlogik, Request-Formatierung und teilweise auch gängige Fehlerbehandlung. Dadurch schreibst du weniger Boilerplate-Code. Direkte REST Calls geben dir mehr Flexibilität, verlangen aber, dass du EIP-712 Signing, Request-Struktur und Edge Cases selbst implementierst. Für den Einstieg ist ein SDK meist die bessere Wahl.

Q2: Brauche ich KYC für programmatic Trading auf Hyperliquid?

Hyperliquid ist ein dezentrales Protokoll und kann über Wallet-Adressen genutzt werden. Ob und welche regulatorischen Anforderungen für dich gelten, hängt jedoch von deinem Standort und deiner persönlichen Situation ab. Informiere dich selbst über die relevanten Regeln; dieser Artikel ist keine Rechts- oder Finanzberatung.

Q3: Wie verhindere ich, dass ein Bot in extremen Marktphasen zu viel verliert?

Wichtige Schutzmechanismen sind unter anderem:

• maximale Verlustgrenzen, bei deren Erreichen der Bot stoppt
• Monitoring von unrealisierten Verlusten im Verhältnis zur Account Equity
• Stop-Loss-Logik bzw. passende Ordertypen
• regelmäßige Prüfung, ob tatsächliche Positionen zur erwarteten Strategieposition passen
• Limits für Ordergröße, Hebel und maximale offene Exposition

Diese Mechanismen können Verluste nicht ausschließen, helfen aber, unkontrolliertes Verhalten zu reduzieren.

Q4: Wie lässt sich eine OneKey Hardware Wallet mit Automatisierung integrieren?

Je nach Setup kann die Integration über offizielle OneKey SDKs, USB/Bluetooth-Verbindungen oder Signaturinterfaces wie eth_sign erfolgen. In produktiven Umgebungen wird der Signing-Service häufig getrennt von der Trading-Logik betrieben. Das reduziert die Angriffsfläche und erleichtert Auditing sowie Zugriffskontrolle.

Q5: Gibt es Rate Limits für Batch Orders?

Die aktuellen Rate Limits solltest du immer in der offiziellen Hyperliquid-Dokumentation prüfen. In der Regel ist es sinnvoll, zwischen Requests kleine Delays einzubauen und Request-Frequenzen mit Token-Bucket- oder Sliding-Window-Mechanismen zu kontrollieren. So reduzierst du das Risiko, dass Orders wegen Rate Limits fehlschlagen.

Fazit: Vom Skript zum produktionsreifen System

Das Hyperliquid SDK senkt die Einstiegshürde für programmatic Trading erheblich. Der Weg von einem Skript, das lokal funktioniert, zu einem verlässlichen Produktionssystem erfordert aber deutlich mehr: sichere Signaturen, sauberes Error Handling, Monitoring, Limits, Positionsabgleich und klare Risk Controls.

Wenn du Perpetuals ohne eigenen Code ausprobieren möchtest, lade OneKey herunter und nutze OneKey Perps als übersichtlichen Einstieg in On-Chain-Perps-Trading. Wenn du ein Entwicklerteam bist und eigene Bots betreibst, kann OneKey als Hardware-basierter Signing-Layer ein wichtiger Baustein für besseres Key Management sein.

Risikohinweis: Programmatic Trading ist technisch und marktseitig komplex. Perpetuals sind gehebelte Produkte und können zu Verlusten führen, die über den ursprünglich eingesetzten Betrag hinausgehen. Dieser Artikel dient nur der technischen Information und ist keine Anlage-, Rechts- oder Finanzberatung. Handle nur, wenn du die Risiken verstehst und sie zu deiner persönlichen Risikotoleranz passen. Vergangene Performance ist kein Hinweis auf zukünftige Ergebnisse.