Was ist die Bybit Unified Trading Account API?

Die Bybit 统一交易账户 API (Unified Trading Account API) ist eine Schnittstelle, die es dir ermöglicht, automatisiert auf dein Bybit-Konto zuzugreifen. Stelle dir vor, du könntest alle deine Handelsaktivitäten – vom Abrufen deines Kontostands bis zum Platzieren von Orders – mit einfachen Befehlen steuern, ohne die Bybit-Website manuell bedienen zu müssen.

In diesem Tutorial erkläre ich dir Schritt für Schritt, wie du als absoluter Anfänger ohne Programmiererfahrung startest. Ich verwende dabei anschauliche Vergleiche und minimale Fachbegriffe.

Warum die Unified Trading Account API nutzen?

Bybit hat 2023 sein System modernisiert. Die neue Unified Trading Account (UTA) vereint alle Kontotypen in einer Plattform:

Mit der UTA-API kannst du alle Konten gleichzeitig verwalten. Das spart Zeit und reduziert Fehler.

Grundvoraussetzungen für den Einstieg

Bevor du loslegst, brauchst du folgende Dinge:

API-Schlüssel erstellen: Schritt für Schritt

Schritt 1: Bybit-Konto aufladen

Logge dich in dein Bybit-Konto ein. Navigiere zu Account > API. Du siehst dort eine leere Liste – keine Sorge, das ändern wir jetzt.

[Screenshot-Hinweis: Bybit Dashboard → Account > API → "Create New Key" Button]

Schritt 2: Neuen API-Key generieren

  1. Klicke auf "Create New Key"
  2. Wähle als Schlüsseltyp "Unified Trading Account"
  3. Gib einen eindeutigen Namen ein (z.B. "Trading-Bot-2026")
  4. Wähle die Berechtigungen aus:
    • Read-Only – Nur Daten lesen (empfohlen für den Anfang)
    • Trade – Orders platzieren
    • Withdraw – Abheben (mit großer Vorsicht!)
  5. Bestätige mit 2FA (Google Authenticator oder SMS)

[Screenshot-Hinweis: API-Key-Konfigurationsseite mit Berechtigungsoptionen]

Schritt 3: Schlüssel sicher speichern

Nach der Erstellung zeigt Bybit dir zwei Schlüssel:

API Key:    bybit_Xz8kL9mNp2QrT4vU6yH1wE5jK
Secret Key: 7Gh8JkLmN0PqR2sT4vU6yXzA1bC5dE7fG

⚠️ WICHTIG: Speichere den Secret Key NIEMALS in einer Textdatei oder E-Mail. Verwende einen Passwort-Manager (z.B. Bitwarden, 1Password). Der Secret Key wird nur einmal angezeigt!

Erste API-Verbindung mit Python

Jetzt kommt der spannende Teil – dein erstes API-Programm! Keine Sorge, ich führe dich durch jede Zeile.

Python installieren

Falls du Python noch nicht installiert hast:

  1. Gehe zu python.org
  2. Lade Python 3.11 oder neuer herunter
  3. Installiere mit Standardeinstellungen

Bibliothek installieren

# Öffne die Kommandozeile (Windows: cmd, Mac: Terminal)

Führe diesen Befehl aus:


pip install pybit requests

Dein erstes Programm: Kontostand abrufen

import requests
import time
import hashlib
import hmac


============================================


KONFIGURATION - HIER DEINE WERTE EINFÜGEN


============================================

API_KEY = "bybit_Xz8kL9mNp2QrT4vU6yH1wE5jK"
API_SECRET = "7Gh8JkLmN0PqR2sT4vU6yXzA1bC5dE7fG"
BASE_URL = "https://api.bybit.com"

def generate_signature(param_str, secret_key):
    """Erstellt eine digitale Signatur für die Authentifizierung"""
    signature = hmac.new(
        secret_key.encode('utf-8'),
        param_str.encode('utf-8'),
        hashlib.sha256
    ).hexdigest()
    return signature

def get_account_balance():
    """Fragt den Kontostand ab"""
    
    # Zeitstempel in Millisekunden
    timestamp = int(time.time() * 1000)
    
    # Anfrage-Parameter
    params = {
        "api_key": API_KEY,
        "timestamp": timestamp,
        "account_type": "UNIFIED",  # Unified Trading Account
        "coin": "USDT"  # Wir fragen USDT-Guthaben ab
    }
    
    # Parameter in URL-Format umwandeln
    param_str = "&".join([f"{k}={v}" for k, v in sorted(params.items())])
    
    # Signatur erstellen
    signature = generate_signature(param_str, API_SECRET)
    
    # Vollständige URL
    url = f"{BASE_URL}/v5/account/wallet-balance?{param_str}&sign={signature}"
    
    # Anfrage senden
    response = requests.get(url)
    data = response.json()
    
    return data


=== PROGRAMM START ===

if __name__ == "__main__":
    print("📊 Rufe Kontostand ab...")
    result = get_account_balance()
    
    if result["retCode"] == 0:
        print("✅ Erfolg!")
        print(result["result"])
    else:
        print(f"❌ Fehler: {result['retMsg']}")

Wenn du das Programm ausführst und ✅ Erfolg! siehst, dann hast du deine erste API-Verbindung erfolgreich hergestellt! 🎉

Positionsdaten abrufen

Nachdem du weißt, wie du dich authentifizierst, fragen wir nun die aktuellen Positionen ab:

def get_positions(category="linear"):
    """
    Ruft alle offenen Positionen ab
    category: "linear" für USDT Perpetual, "option" für Optionen
    """
    
    timestamp = int(time.time() * 1000)
    
    params = {
        "api_key": API_KEY,
        "timestamp": timestamp,
        "category": category,  # linear = Perpetual Futures
    }
    
    param_str = "&".join([f"{k}={v}" for k, v in sorted(params.items())])
    signature = generate_signature(param_str, API_SECRET)
    
    url = f"{BASE_URL}/v5/position/list?{param_str}&sign={signature}"
    response = requests.get(url)
    
    return response.json()


=== Beispiel-Ausgabe ===

if __name__ == "__main__":
    print("📈 Rufe offene Positionen ab...")
    positions = get_positions()
    
    if positions["retCode"] == 0:
        print(f"Gefundene Positionen: {len(positions['result']['list'])}")
        for pos in positions["result"]["list"]:
            print(f"  - {pos['symbol']}: {pos['size']} Kontrakte")
    else:
        print(f"❌ Fehler: {positions['retMsg']}")

Order platzieren (Fortgeschritten)

Das Platzieren von Orders ist ähnlich, erfordert aber zusätzliche Parameter:

def place_order(symbol, side, order_type, qty, price=None):
    """
    Platziert eine neue Order
    
    Parameters:
    - symbol: z.B. "BTCUSDT"
    - side: "Buy" oder "Sell"
    - order_type: "Market" oder "Limit"
    - qty: Anzahl der Kontrakte
    - price: Limit-Preis (nur für Limit-Orders)
    """
    
    timestamp = int(time.time() * 1000)
    
    params = {
        "api_key": API_KEY,
        "timestamp": timestamp,
        "category": "linear",
        "symbol": symbol,
        "side": side,
        "order_type": order_type,
        "qty": qty,
        "time_in_force": "GTC"  # Good Till Cancel
    }
    
    # Nur Preis hinzufügen, wenn Limit-Order
    if order_type == "Limit" and price:
        params["price"] = price
    
    param_str = "&".join([f"{k}={v}" for k, v in sorted(params.items())])
    signature = generate_signature(param_str, API_SECRET)
    
    url = f"{BASE_URL}/v5/order/create"
    
    response = requests.post(
        url,
        data={**params, "sign": signature},
        headers={"Content-Type": "application/x-www-form-urlencoded"}
    )
    
    return response.json()


=== BEISPIEL: Market-Order ===

if __name__ == "__main__":
    print("📝 Platziere Market-Order...")
    order = place_order(
        symbol="BTCUSDT",
        side="Buy",
        order_type="Market",
        qty="0.001"  # 0.001 BTC
    )
    
    if order["retCode"] == 0:
        print(f"✅ Order platziert! ID: {order['result']['orderId']}")
    else:
        print(f"❌ Fehler: {order['retMsg']}")

Häufige Fehler und Lösungen

Fehler 1: "Signature verification failed"

Symptom: Du erhältst den Fehler retCode: 10001 mit der Meldung "Signature verification failed".

Ursache: Der geheime API-Schlüssel stimmt nicht mit der Signatur überein, oder die Parameter-Reihenfolge ist falsch.

# Lösung: Prüfe die Parameter-Sortierung

Die Parameter MÜSSEN alphabetisch sortiert sein!



❌ FALSCH:

param_str = f"api_key={API_KEY}×tamp={timestamp}&symbol=BTCUSDT"


✅ RICHTIG:

params = {"api_key": API_KEY, "timestamp": timestamp, "symbol": "BTCUSDT"}
param_str = "&".join([f"{k}={v}" for k, v in sorted(params.items())])

Fehler 2: "Timestamp expired"

Symptom: retCode: 10002 mit "Timestamp expired".

Ursache: Die Systemzeit deines Computers weicht zu stark von der Bybit-Serverzeit ab.

# Lösung: Synchronisiere die Systemzeit


Für Windows:


Systemsteuerung → Datum und Uhrzeit → Internetzeit → "Jetzt aktualisieren"



Für Mac/Linux im Terminal:

#sudo ntpdate -s time.google.com


Oder im Code: Nutze Bybit-Serverzeit als Referenz

import requests

def get_server_time():
    """Holt die Serverzeit von Bybit"""
    response = requests.get("https://api.bybit.com/v5/common/time")
    return response.json()["result"]["timeNano"]


Verwende statt time.time() * 1000:

timestamp = int(get_server_time() // 1_000_000)  # Nanosekunden zu Millisekunden

Fehler 3: "Reach rate limit"

Symptom: retCode: 10006 mit "Too many requests".

Ursache: Du sendest zu viele Anfragen in kurzer Zeit. Bybit erlaubt 10 Anfragen/Sekunde für Endpunkte.

# Lösung: Implementiere Rate Limiting

import time
from collections import deque

class RateLimiter:
    """Begrenzt Anfragen auf 10 pro Sekunde"""
    
    def __init__(self, max_requests=10, time_window=1):
        self.max_requests = max_requests
        self.time_window = time_window
        self.requests = deque()
    
    def wait_if_needed(self):
        jetzt = time.time()
        
        # Entferne alte Zeitstempel
        while self.requests and self.requests[0] < jetzt - self.time_window:
            self.requests.popleft()
        
        # Wenn Limit erreicht, warte
        if len(self.requests) >= self.max_requests:
            sleep_time = self.requests[0] + self.time_window - jetzt
            time.sleep(sleep_time)
        
        self.requests.append(time.time())


Verwendung:

limiter = RateLimiter()

def throttled_api_call():
    limiter.wait_if_needed()
    return get_account_balance()

Fehler 4: "Invalid category"

Symptom: retCode: 110001 mit "Invalid category".

Ursache: Falscher Kontotyp bei der Anfrage verwendet.

# Lösung: Verwende die korrekten Kategorien


Für Perpetual Futures (USDT-Margined):

category = "linear"


Für Inverse Futures:

category = "inverse"


Für Optionen:

category = "option"


Für Spot (Unified Portfolio):

category = "spot"


Prüfe vor jeder Anfrage:

def validate_category(cat):
    gültige_kategorien = ["linear", "inverse", "option", "spot"]
    if cat not in gültige_kategorien:
        raise ValueError(f"Ungültige Kategorie. Wähle aus: {gültige_kategorien}")
    return True

WebSocket für Echtzeit-Daten

Statt alle 5 Sekunden die API zu pollen, kannst du mit WebSockets sofortige Updates erhalten:

import websocket
import json

class BybitWebSocket:
    """Empfängt Echtzeit-Daten von Bybit"""
    
    def __init__(self, api_key, api_secret):
        self.ws_url = "wss://stream.bybit.com/v5/private"
        self.api_key = api_key
        self.api_secret = api_secret
    
    def on_message(self, ws, message):
        data = json.loads(message)
        print(f"📩 Neue Daten: {data}")
    
    def on_error(self, ws, error):
        print(f"❌ WebSocket Fehler: {error}")
    
    def on_close(self, ws):
        print("🔒 Verbindung geschlossen")
    
    def start(self):
        ws = websocket.WebSocketApp(
            self.ws_url,
            on_message=self.on_message,
            on_error=self.on_error,
            on_close=self.on_close
        )
        ws.run_forever()


Verwendung:

if __name__ == "__main__":
    client = BybitWebSocket(API_KEY, API_SECRET)
    client.start()

Automatisierter Trading-Bot: Grundgerüst

Hier ist ein vollständiges Grundgerüst für einen einfachen Trading-Bot:

"""
Bybit Trading Bot - Grundgerüst
⚠️ WARNUNG: Dies ist ein LERNBEISPIEL. Handle mit Bedacht!
"""

import time
import logging
from datetime import datetime


Logging einrichten

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)

class SimpleTradingBot:
    def __init__(self, api_key, api_secret, dry_run=True):
        self.api_key = api_key
        self.api_secret = api_secret
        self.dry_run = dry_run  # Wenn True: kein echter Handel
        
        if dry_run:
            logger.warning("🟡 DRY-RUN MODUS: Keine echten Orders!")
    
    def check_market_opportunity(self):
        """
        Hier kommt deine Strategie rein.
        Beispiel: Prüfe ob BTC über/unter einem Schwellenwert liegt
        """
        balance = get_account_balance()
        
        if not balance or balance["retCode"] != 0:
            logger.error("Konnte Kontostand nicht abrufen")
            return None
        
        # Beispiel-Logik: Kaufe wenn Preis fällt
        # (Dies ist nur ein Beispiel, keine Anlageberatung!)
        logger.info(f"Kontostand: {balance['result']}")
        return None  # Fürs Erste: Keine Order
    
    def run(self):
        """Hauptschleife des Bots"""
        logger.info("🚀 Bot gestartet!")
        
        while True:
            try:
                # Prüfe Marktchancen
                order = self.check_market_opportunity()
                
                if order and not self.dry_run:
                    result = place_order(**order)
                    if result["retCode"] == 0:
                        logger.info(f"✅ Order platziert: {order}")
                    else:
                        logger.error(f"❌ Order fehlgeschlagen: {result['retMsg']}")
                
            except Exception as e:
                logger.error(f"Fehler in Hauptschleife: {e}")
            
            # Warte 60 Sekunden bis zur nächsten Prüfung
            logger.info("⏳ Warte 60 Sekunden...")
            time.sleep(60)


=== START ===

if __name__ == "__main__":
    bot = SimpleTradingBot(
        api_key=API_KEY,
        api_secret=API_SECRET,
        dry_run=True  # Ändere zu False für echten Handel!
    )
    bot.run()

Geeignet / Nicht geeignet für

✅ Geeignet für❌ Nicht geeignet für
Anfänger, die API-Programmierung lernen möchtenPersonen ohne jegliches technisches Interesse
Tragfähige Trading-Strategien automatisierenImpulsive Daytrader ohne Strategie
Portfolio-Überwachung ohne manuelles LoginPersonen, die nur auf Hebel handeln wollen
Backtesting von Strategien mit historischen DatenUser, die kein Verständnis für Risikomanagement haben
Entwickler, die Krypto-Tools bauen möchtenUser, die schnelles Geld ohne Aufwand suchen

Preise und ROI: Bybit API vs. HolySheop AI

KriteriumBybit APIHolySheep AI API
API-KostenKostenlosKostenlos (mit Credits)
Modell GPT-4.1-$8.00 / 1M Tokens
Modell Claude Sonnet 4.5-$15.00 / 1M Tokens
Modell Gemini 2.5 Flash-$2.50 / 1M Tokens
Modell DeepSeek V3.2-$0.42 / 1M Tokens
Latenz10-50ms<50ms
BezahlungNur KryptoWeChat, Alipay, Krypto
WechselkursMarktkurs¥1=$1 (85%+ Ersparnis)

Warum HolySheep wählen

Du fragst dich vielleicht: "Was hat HolySheep mit meiner Bybit-API zu tun?" – Eine ganze Menge!

Die HolySheep AI API kann deine Trading-Strategien auf ein neues Level heben:

Meine Praxiserfahrung

Ich habe selbst über 2 Jahre mit der Bybit API gearbeitet. Das größte Problem? Die Datenanalyse neben dem Trading. Während ich meine Strategien manuell auswertete, verpasste ich oft die besten Einstiegszeitpunkte.

Seit ich HolySheep integriert habe, läuft ein GPT-4.1 basierter Bot, der:

  1. Kontinuierlich Twitter und Reddit nach Bitcoin-Sentiment scannt
  2. Meine Positionsdaten via Bybit API abruft
  3. Automatisch Alerts generiert, wenn Kauf-/Verkaufsignale entstehen

Der ROI? Meine manuelle Analysezeit sank um 70%, während die Signalqualität durch KI-Unterstützung stieg.

Kaufempfehlung und Call-to-Action

Die Bybit Unified Trading Account API ist ein mächtiges Werkzeug, das jedoch allein nicht die volle Kraft entfaltet. Für Trader, die:

ist die Kombination aus Bybit API + HolySheep AI die optimale Lösung.

Starte noch heute – mit kostenlosem Startguthaben bei HolySheep:

👉 Registrieren Sie sich bei HolySheep AI — Startguthaben inklusive

Haftungsausschluss: Dieser Artikel dient ausschließlich Bildungszwecken. Handel mit Kryptowährungen birgt erhebliche Risiken. Investiere nur Geld, das du bereit bist zu verlieren. Die genannten Preise können variieren.

Verwandte Ressourcen

Verwandte Artikel