Binance Order Book WebSocket: Komplette Anleitung zur Hochfrequenz-Datenerfassung

Willkommen zu dieser Schritt-für-Schritt-Anleitung für absolute Anfänger! In diesem Artikel lernst du, wie du mit Binance WebSocket Order Book Daten in Echtzeit abrufst und diese für Trading-Strategien oder Analysen nutzen kannst. Keine Vorkenntnisse erforderlich – wir beginnen bei null.

Was ist ein Order Book und warum ist es wichtig?

Stell dir das Order Book wie eine elektronische Warteschlange vor einem beliebten Laden vor. Auf der einen Seite stehen Leute, die kaufen möchten (Bieter), auf der anderen Seite stehen Leute, die verkaufen möchten (Anbieter). Das Order Book zeigt dir:

• Alle offenen Kaufaufträge mit ihren Mengen und Preisen
• Alle offenen Verkaufsaufträge mit ihren Mengen und Preisen
• Die Tiefe des Marktes – wie viel Volumen bei welchen Preisen verfügbar ist

Warum WebSocket statt normaler API? Eine normale API-Abfrage funktioniert wie eine E-Mail: Du schickst eine Anfrage und bekommst eine Antwort. WebSocket funktioniert wie ein Telefonat: Die Verbindung bleibt offen und du erhältst kontinuierlich Updates in Echtzeit. Für Order Book Daten, die sich tausende Male pro Sekunde ändern können, ist WebSocket daher unverzichtbar.

Deine Entwicklungsumgebung einrichten

Bevor wir beginnen, brauchst du eine einfache Entwicklungsumgebung. Ich empfehle dir Python 3.8 oder höher mit dem Paket websockets. So richtest du alles ein:

# 1. Python installieren (falls noch nicht geschehen)
Lade Python von https://www.python.org/downloads/

2. Virtuelle Umgebung erstellen (empfohlen)
python -m venv trading_env

3. Virtuelle Umgebung aktivieren
Windows:
trading_env\Scripts\activate
macOS/Linux:
source trading_env/bin/activate

4. Benötigte Pakete installieren
pip install websockets pandas numpy requests

Screenshot-Hinweis: Öffne nach der Installation ein Terminal und gib python --version ein. Du solltest eine Versionsnummer wie "Python 3.11.5" sehen.

Verbindung zu Binance WebSocket herstellen

Jetzt verbinden wir uns mit dem Binance WebSocket. Binance bietet zwei Typen von Streams an:

1. Individuelle Streams – Für ein einzelnes Trading-Paar (z.B. BTCUSDT)
2. Kombinierte Streams – Für mehrere Trading-Paare gleichzeitig

Hier ist dein erstes vollständiges Skript, das eine Verbindung herstellt und Order Book Daten empfängt:

import asyncio
import json
import websockets
from collections import deque

Konfiguration
SYMBOL = "btcusdt"  # Trading-Paar in Kleinbuchstaben
DEPTH = 100         # Anzahl der Order-Book-Ebenen (max. 1000)
STREAM_URL = "wss://stream.binance.com:9443/ws"

async def connect_orderbook():
    """Verbindet sich zum Binance WebSocket und empfängt Order-Book-Daten."""
    
    # Der Stream-Name für Order Book Depth
    stream_name = f"{SYMBOL}@depth{DEPTH}@100ms"
    ws_url = f"{STREAM_URL}/{stream_name}"
    
    print(f"Verbinde mit: {ws_url}")
    print(f"Empfange Order Book für: {SYMBOL.upper()}")
    print("=" * 50)
    
    async with websockets.connect(ws_url) as websocket:
        message_count = 0
        
        while True:
            try:
                # Empfange Daten
                data = await websocket.recv()
                orderbook = json.loads(data)
                
                message_count += 1
                
                # Extrahiere relevante Informationen
                bids = orderbook.get("b", [])  # Kaufaufträge (bids)
                asks = orderbook.get("a", [])  # Verkaufsaufträge (asks)
                update_id = orderbook.get("u")  # Update-ID
                
                # Zeige die besten 5 Preise
                print(f"\n📊 Update #{message_count} (ID: {update_id})")
                print(f"   Beste 5 Käufe (Bids):")
                
                for i, (price, quantity) in enumerate(bids[:5]):
                    print(f"      {i+1}. Preis: ${float(price):,.2f} | Menge: {float(quantity):.4f}")
                
                print(f"   Beste 5 Verkäufe (Asks):")
                for i, (price, quantity) in enumerate(asks[:5]):
                    print(f"      {i+1}. Preis: ${float(price):,.2f} | Menge: {float(quantity):.4f}")
                
                # Berechne Spread (Differenz zwischen bestem Kauf und Verkauf)
                if bids and asks:
                    best_bid = float(bids[0][0])
                    best_ask = float(asks[0][0])
                    spread = best_ask - best_bid
                    spread_percent = (spread / best_bid) * 100
                    print(f"   📈 Spread: ${spread:.2f} ({spread_percent:.4f}%)")
                
            except websockets.exceptions.ConnectionClosed:
                print("Verbindung geschlossen. Versuche neu zu verbinden...")
                break
            except KeyboardInterrupt:
                print("\nSkript beendet durch Benutzer.")
                break
            except Exception as e:
                print(f"Fehler: {e}")

async def main():
    """Hauptfunktion zum Starten der Verbindung."""
    await connect_orderbook()

if __name__ == "__main__":
    # Führe das Skript aus
    asyncio.run(main())

Speichere dieses Skript als orderbook_basic.py und führe es aus:

python orderbook_basic.py

Screenshot-Hinweis: Du solltest jetzt eine kontinuierliche Ausgabe sehen, die sich jede Sekunde aktualisiert. Die Preise und Mengen ändern sich in Echtzeit!

Fortgeschrittenes Skript: Daten lokal speichern und analysieren

In der Praxis möchtest du die Daten nicht nur ansehen, sondern auch speichern und analysieren. Das folgende Skript sammelt Order Book Daten über einen bestimmten Zeitraum und bereitet sie für die Analyse vor:

Verwandte Ressourcen
📚 KI API Tutorials
💰 Preise ansehen
📖 Entwickler-Dokumentation
🚀 Kostenlos registrieren
Verwandte Artikel
Claude 4 vs. Gemini 1.5 Pro: Der ultimative Multimodal-Model
Deribit V2 API: Optionskette in Echtzeit abonnieren – Komple
Kryptowährungs-Volatilitätsindex: VIX-Berechnungsmethoden fü