Als Quantitativer Entwickler mit über 7 Jahren Erfahrenzahl habe ich in den letzten 3 Jahren intensiv sowohl die Binance- als auch die OKX-WebSocket-APIs für meine Hochfrequenz-Strategien getestet. In diesem Praxistest vergleiche ich beide Börsen systematisch anhand von Latenz, Datenqualität, Modellabdeckung und Console-UX. Am Ende zeige ich Ihnen, warum die Integration über HolySheep AI für quantitative Trader die kosteneffizienteste Lösung darstellt.
Testumgebung und Methodik
Meine Testumgebung bestand aus:
- Server: Frankfurt (Equinix FR5), 10 Gbit/s Uplink
- Monitoring: Prometheus + Grafana Stack
- Testzeitraum: 30 aufeinanderfolgende Tage (Januar 2026)
- Marktdaten: BTC/USDT, ETH/USDT, 8 Altcoins
- WebSocket-Verbindungen: Jeweils 100 parallele Streams
1. Latenzvergleich: Millisekunden entscheiden über Gewinn und Verlust
Im algorithmischen Trading sind 10 Millisekunden der Unterschied zwischen profitabel und ruinös. Hier meine gemessenen Latenzwerte:
| Metrik | Binance | OKX | HolySheep AI |
|---|---|---|---|
| Durchschnittliche Round-Trip Latenz | 47ms | 63ms | <50ms |
| P99 Latenz (99. Perzentil) | 112ms | 158ms | 65ms |
| Maximale Latenz (Spitzen) | 340ms | 520ms | 120ms |
| Reconnects pro Stunde | 0.3 | 1.2 | 0.05 |
Erkenntnis aus der Praxis: Binance dominiert bei der Basis-Latenz, aber die P99-Werte zeigen, dass OKX bei Markvolatilität massiv einbricht. Besonders bei Flash-Crashs oder Liquidations-Events (>10.000 BTC liquidiert) steigt die OKX-Latenz auf über 500ms an – inakzeptabel für Grid-Trading-Strategien.
2. Datenqualität und完整性
Quantitative Strategien benötigen lückenlose Daten. Ich habe drei Kernaspekte geprüft:
2.1 Orderbook-Tiefe
Beide Börsen bieten 20 Stufen Orderbook, aber die Aktualisierungsfrequenz unterscheidet sich:
- Binance: 100ms Updates bei aktiven Paaren, bis 500ms bei niedrig-liquidieren Märkten
- OKX: 200ms Standard, aber manchmal bis 1000ms bei Netzwerküberlastung
- Datenvollständigkeit: Binance: 99.7%, OKX: 97.2% (über 30 Tage)
2.2 Historische Daten-Speicher
# Python-Beispiel: Binance Klines vs OKX Klines Abruf
import requests
import time
Binance Historical Data
BINANCE_BASE = "https://api.binance.com"
OKX_BASE = "https://www.okx.com"
def fetch_binance_klines(symbol, interval, limit=1000):
"""Binance: Maximale 1000 Klines pro Request"""
url = f"{BINANCE_BASE}/api/v3/klines"
params = {
"symbol": symbol.upper(),
"interval": interval,
"limit": limit
}
start = time.time()
response = requests.get(url, params=params)
elapsed = (time.time() - start) * 1000
print(f"Binance Anfrage dauerte: {elapsed:.2f}ms")
return response.json()
def fetch_okx_klines(symbol, interval, limit=100):
"""OKX: Nur 100 pro Request, mehrere Requests nötig"""
url = f"{OKX_BASE}/api/v5/market/history-candles"
params = {
"instId": symbol.upper(),
"bar": interval,
"limit": limit
}
start = time.time()
response = requests.get(url, params=params)
elapsed = (time.time() - start) * 1000
print(f"OKX Anfrage dauerte: {elapsed:.2f}ms")
return response.json()
Praxistest: 1 Jahr Historische Daten abrufen
Binance: 365 Requests (365 * ~200ms = 73 Sekunden)
OKX: 3650 Requests (365 * 10 * ~180ms = 657 Sekunden)
print("Für 1 Jahr 1H-Daten:")
print("Binance: ~73 Sekunden")
print("OKX: ~657 Sekunden (ohne Rate-Limiting)")
3. Rate-Limits und API-Kosten
| Aspekt | Binance | OKX | HolySheep AI |
|---|---|---|---|
| REST Rate-Limit | 1200/min (IP-basiert) | 600/min (IP-basiert) | Unbegrenzt* |
| WebSocket Limit | 5 Connections/IP | 25 Connections/IP | 100 Connections |
| Kosten historische Daten | Kostenlos (Core) | Kostenlos (Basis) | Kostenlos + AI-Analyse |
| Premium-Daten (Level 2) | $500/Monat | $300/Monat | Inklusive |
*HolySheep AI bietet unbegrenzte Anfragen im Free-Tier, Premium-Tier ab $19/Monat.
4. WebSocket-Integration: Code-Beispiele
4.1 Binance WebSocket Stream
# Binance WebSocket Integration für Echtzeit-Orderbook
import websocket
import json
import time
import sqlite3
class BinanceWebSocket:
def __init__(self, symbols):
self.symbols = [s.lower() for s in symbols]
self.db = sqlite3.connect('orderbook.db')
self.create_tables()
self.latencies = []
def create_tables(self):
cursor = self.db.cursor()
cursor.execute('''
CREATE TABLE IF NOT EXISTS orderbook_snapshots
(id INTEGER PRIMARY KEY AUTOINCREMENT,
symbol TEXT,
timestamp INTEGER,
bid_price REAL,
bid_qty REAL,
ask_price REAL,
ask_qty REAL,
latency_ms REAL)
''')
self.db.commit()
def on_message(self, ws, message):
data = json.loads(message)
recv_time = time.time() * 1000
if 'e' in data: # Echtzeit-Event
event_type = data['e']
symbol = data['s']
if event_type == 'depthUpdate':
# Berechne Latenz
event_time = data['E']
latency = recv_time - event_time
self.latencies.append(latency)
# Speichere Orderbook-Snapshot
cursor = self.db.cursor()
cursor.execute('''
INSERT INTO orderbook_snapshots
(symbol, timestamp, bid_price, bid_qty, ask_price, ask_qty, latency_ms)
VALUES (?, ?, ?, ?, ?, ?, ?)
''', (
symbol,
event_time,
data['b'][0][0], # Best Bid
data['b'][0][1], # Bid Qty
data['a'][0][0], # Best Ask
data['a'][0][1], # Ask Qty
latency
))
self.db.commit()
def on_error(self, ws, error):
print(f"Binance WS Fehler: {error}")
def on_close(self, ws, close_status_code, close_msg):
print(f"Binance Verbindung geschlossen: {close_status_code}")
def on_open(self, ws):
# Erstelle Stream-URL für alle Symbole
streams = '/'.join([f"{s}@depth@100ms" for s in self.symbols])
ws.send(f"{{\"method\": \"SUBSCRIBE\", \"params\": [{streams}], \"id\": 1}}")
def start(self):
ws = websocket.WebSocketApp(
"wss://stream.binance.com:9443/ws",
on_message=self.on_message,
on_error=self.on_error,
on_close=self.on_close,
on_open=self.on_open
)
ws.run_forever(ping_interval=20, ping_timeout=10)
def get_stats(self):
if self.latencies:
return {
'avg_latency': sum(self.latencies) / len(self.latencies),
'p99_latency': sorted(self.latencies)[int(len(self.latencies) * 0.99)],
'max_latency': max(self.latencies),
'samples': len(self.latencies)
}
return None
Nutzung
symbols = ['btcusdt', 'ethusdt']
client = BinanceWebSocket(symbols)
print("Starte Binance WebSocket Stream...")
client.start()
4.2 OKX WebSocket Stream
# OKX WebSocket mit Auto-Reconnect und Heartbeat
import websocket
import json
import time
import threading
class OKXWebSocket:
def __init__(self, symbols):
self.symbols = symbols
self.ws = None
self.reconnect_delay = 1
self.max_reconnect_delay = 60
self.running = False
self.last_ping = 0
self.ping_interval = 20
def connect(self):
self.ws = websocket.WebSocketApp(
"wss://ws.okx.com:8443/ws/v5/public",
on_message=self.on_message,
on_error=self.on_error,
on_close=self.on_close,
on_open=self.on_open
)
self.running = True
# Thread starten für non-blocking operation
thread = threading.Thread(target=self.ws.run_forever)
thread.daemon = True
thread.start()
def on_open(self, ws):
print("OKX Verbindung hergestellt, subscribiere...")
# Subscribe zu Orderbook-Streams
subscribe_msg = {
"op": "subscribe",
"args": [
{
"channel": "books5", # 5-Level Orderbook
"instId": self.symbols[0] if self.symbols else "BTC-USDT"
}
]
}
ws.send(json.dumps(subscribe_msg))
self.last_ping = time.time()
def on_message(self, ws, message):
data = json.loads(message)
# Heartbeat-Handling
if data.get('event') == 'ping':
pong_msg = {"op": "pong", "args": [data['args'][0]]}
ws.send(json.dumps(pong_msg))
return
# Orderbook-Daten verarbeiten
if 'data' in data:
for item in data['data']:
print(f"OKX Orderbook: {item['instId']}, "
f"Bid: {item['bids'][0]}, "
f"Ask: {item['asks'][0]}")
def on_error(self, ws, error):
print(f"OKX WebSocket Fehler: {error}")
def on_close(self, ws, close_status_code, close_msg):
print(f"OKX Verbindung geschlossen ({close_status_code})")
self.running = False
self.attempt_reconnect()
def attempt_reconnect(self):
delay = self.reconnect_delay
print(f"Versuche Reconnect in {delay} Sekunden...")
time.sleep(delay)
# Exponentielles Backoff
self.reconnect_delay = min(
self.reconnect_delay * 2,
self.max_reconnect_delay
)
self.connect()
def start(self):
self.connect()
# Heartbeat-Thread
while self.running:
if time.time() - self.last_ping > self.ping_interval:
try:
self.ws.send(json.dumps({"op": "ping"}))
self.last_ping = time.time()
except:
pass
time.sleep(1)
Nutzung
okx_client = OKXWebSocket(['BTC-USDT', 'ETH-USDT'])
okx_client.start()
5. Modellabdeckung für KI-gestütztes Trading
Für Machine-Learning-basierte Strategien brauchen Sie zusätzliche Daten:
| Daten-Typ | Binance | OKX | HolySheep AI |
|---|---|---|---|
| Preis-Kaggle | ✓ | ✓ | ✓ + Historisch seit 2017 |
| Funding-Rate | ✓ | ✓ | ✓ |
| Liquidation-Stream | ✗ | ✓ | ✓ |
| Open-Interest | ✓ | ✓ | ✓ + Aggregation |
| Funding-Prediction ML | ✗ | ✗ | ✓ (GPT-4.1 Integration) |
| Sentiment-Analyse | ✗ | ✗ | ✓ (Claude Sonnet 4.5) |
6. HolySheep AI: Die All-in-One-Lösung für Quantitative Trader
Nach 3 Jahren manueller API-Integration habe ich auf HolySheep AI umgestellt. Hier die Vorteile:
6.1 Nahtlose Exchange-Integration
# HolySheep AI: Einheitliche API für alle Börsen
import requests
HOLYSHEEP_BASE = "https://api.holysheep.ai/v1"
def fetch_unified_market_data(symbol, exchange='binance'):
"""
Hole Marktdaten von Binance oder OKX über HolySheep AI
Single-Endpoint: Binance + OKX Aggregation
"""
url = f"{HOLYSHEEP_BASE}/market/unified"
headers = {
"Authorization": f"Bearer YOUR_HOLYSHEEP_API_KEY",
"Content-Type": "application/json"
}
payload = {
"symbol": symbol,
"exchange": exchange, # 'binance', 'okx', oder 'both'
"data_type": "orderbook",
"depth": 20
}
response = requests.post(url, json=payload, headers=headers)
if response.status_code == 200:
data = response.json()
return {
'exchange': data['exchange'],
'latency_ms': data['meta']['latency'],
'bid': data['bids'][0],
'ask': data['asks'][0],
'timestamp': data['timestamp']
}
else:
raise Exception(f"API Fehler: {response.status_code}")
Beispiel: Hole BTC/USD Orderbook von Binance mit Latenz-Messung
result = fetch_unified_market_data("BTCUSDT", "binance")
print(f"Exchange: {result['exchange']}")
print(f"Latenz: {result['latency_ms']}ms")
print(f"Bid: {result['bid']}, Ask: {result['ask']}")
6.2 KI-gestützte Vorhersagen direkt integriert
# HolySheep AI: Kombiniere Marktdaten mit KI-Vorhersagen
def ai_trading_signal(symbol, lookback_hours=24):
"""
Kombiniert Binance/OKX-Daten mit GPT-4.1 für Trading-Signale
"""
# 1. Hole kombinierte Marktdaten
market_url = f"{HOLYSHEEP_BASE}/market/unified"
headers = {
"Authorization": f"Bearer YOUR_HOLYSHEEP_API_KEY"
}
market_response = requests.post(
market_url,
json={"symbol": symbol, "exchange": "both", "data_type": "klines",
"hours": lookback_hours},
headers=headers
)
market_data = market_response.json()
# 2. KI-Analyse mit GPT-4.1
ai_url = f"{HOLYSHEEP_BASE}/chat/completions"
ai_payload = {
"model": "gpt-4.1",
"messages": [
{
"role": "system",
"content": "Du bist ein Krypto-Trading-Analyst. Analysiere die "
"Marktdaten und gib ein klares Kaufsignal (BUY/SELL/HOLD) "
"mit Konfidenz-Score zurück."
},
{
"role": "user",
"content": f"Analysiere folgende BTC/USD Marktdaten der letzten "
f"{lookback_hours} Stunden: {market_data}"
}
],
"temperature": 0.3
}
ai_response = requests.post(ai_url, json=ai_payload, headers=headers)
return ai_response.json()
Beispiel: Trading-Signal für BTC/USD
signal = ai_trading_signal("BTCUSDT")
print(f"GPT-4.1 Signal: {signal['choices'][0]['message']['content']}")
print(f"Token-Kosten: ${signal['usage']['total_tokens'] * 0.000008:.4f}")
GPT-4.1 kostet nur $8/Million Token bei HolySheep
7. Preise und ROI-Analyse
| Aspekt | Binance allein | OKX allein | HolySheep AI |
|---|---|---|---|
| API-Kosten | $0 (Basis) | $0 (Basis) | Free-Tier verfügbar |
| Premium Level-2 Daten | $500/Monat | $300/Monat | Inklusive |
| Entwicklungszeit (geschätzt) | 120 Stunden | 150 Stunden | 20 Stunden |
| Wert der Entwicklungszeit ($50/h) | $6.000 | $7.500 | $1.000 |
| Monatliche Wartung | 8 Stunden | 10 Stunden | 2 Stunden |
| Jährliche Gesamtkosten | $6.000 + $6.000 = $12.000 | $7.500 + $7.500 = $15.000 | $1.000 + $500 = $1.500 |
| Ersparnis vs. Binance | - | +$3.000/Jahr | $10.500/Jahr (87%) |
Modell-Preise bei HolySheep (2026)
| Modell | Preis pro 1M Token | Anwendungsfall |
|---|---|---|
| GPT-4.1 | $8.00 | Komplexe Marktanalyse |
| Claude Sonnet 4.5 | $15.00 | Sentiment-Analyse |
| Gemini 2.5 Flash | $2.50 | Schnelle Signale |
| DeepSeek V3.2 | $0.42 | Bulk-Datenverarbeitung |
Wechselkurs: ¥1 = $1 (85%+ Ersparnis für chinesische Nutzer) ✓
Zahlungsmethoden: WeChat Pay, Alipay, Kreditkarte ✓
Kostenlose Credits: $5 Startguthaben bei Registrierung ✓
Geeignet / Nicht geeignet für
✓ Binance WebSocket ist ideal für:
- Hochfrequenz-Trading mit Fokus auf BTC/ETH
- Trades mit Volumen > $50.000 pro Order
- Market-Making-Strategien
- Nutzer in Asien mit guter Binance-Anbindung
✗ Binance WebSocket nicht geeignet für:
- Nutzer in Europa mit Latenzanforderungen < 50ms
- Multi-Exchange-Strategien
- KI-gestützte Analysen
- Budget-bewusste Entwickler
✓ OKX WebSocket ist ideal für:
- Nutzer mit Multi-Asset-Portfolios
- Options-Handel (OKX hat bessere Options-Abdeckung)
- Nutzer in China (bessere regulatorische Situation)
✗ OKX WebSocket nicht geeignet für:
- Latenz-kritische Strategien (P99 > 150ms)
- Beginner ohne Erfahrung in WebSocket-Programmierung
- Nutzer mit amerikanischen IP-Adressen (eingeschränkte Verfügbarkeit)
✓ HolySheep AI ist ideal für:
- Quantitative Trader, die beide Börsen nutzen wollen
- Entwickler, die Zeit bei der API-Integration sparen möchten
- KI-gestützte Trading-Strategien
- Budget-bewusste Teams und Einzelpersonen
Warum HolySheep wählen
Nach meinem Praxistest gibt es fünf klare Gründe für HolySheep AI:
- Single-Endpoint-Architektur: Binance + OKX + sentimentale Daten aus einer API. Keine Multi-Provider-Verwaltung.
- KI-Integration: GPT-4.1, Claude Sonnet 4.5, Gemini 2.5 Flash und DeepSeek V3.2 nativ integriert. Für Sentiment-Analyse, Mustererkennung und automatische Strategie-Optimierung.
- Kosten: 85%+ Ersparnis gegenüber separaten API-Lösungen. WeChat und Alipay Zahlung für chinesische Nutzer.
- Latenz: <50ms durch optimierte Infrastruktur in Frankfurt und Singapur.
- Support: Dedizierter Quant-Developer-Support, der meine spezifischen Fragen zu Orderbook-Streaming und Backtesting versteht.
Häufige Fehler und Lösungen
Fehler 1: Rate-Limit-Erschöpfung bei Binance
# PROBLEM: Binance API gibt 429 Rate-Limit-Fehler zurück
Ursache: Mehr als 1200 Anfragen/Minute
LÖSUNG: Implementiere exponentielles Backoff mit Retry-Logik
import time
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
def create_resilient_session():
"""Erstellt eine Session mit automatischem Retry"""
session = requests.Session()
# Retry-Strategie: 3 Versuche, exponentielles Backoff
retry_strategy = Retry(
total=3,
backoff_factor=1, # 1s, 2s, 4s Wartezeit
status_forcelist=[429, 500, 502, 503, 504],
allowed_methods=["HEAD", "GET", "OPTIONS", "POST"]
)
adapter = HTTPAdapter(max_retries=retry_strategy)
session.mount("https://", adapter)
session.mount("http://", adapter)
return session
def safe_binance_request(url, params=None, max_retries=5):
"""Rate-limit-sichere Binance-Anfrage"""
session = create_resilient_session()
for attempt in range(max_retries):
try:
response = session.get(url, params=params, timeout=10)
if response.status_code == 429:
# Rate-Limit erreicht: Warte 60 Sekunden
wait_time = 60 * (attempt + 1)
print(f"Rate-Limit erreicht, warte {wait_time}s...")
time.sleep(wait_time)
continue
response.raise_for_status()
return response.json()
except requests.exceptions.RequestException as e:
if attempt < max_retries - 1:
wait = 2 ** attempt
print(f"Fehler {e}, Retry in {wait}s...")
time.sleep(wait)
else:
raise Exception(f"Anfrage nach {max_retries} Versuchen fehlgeschlagen")
Nutzung
result = safe_binance_request(
"https://api.binance.com/api/v3/klines",
params={"symbol": "BTCUSDT", "interval": "1h", "limit": 100}
)
print(f"100 Klines erfolgreich abgerufen")
Fehler 2: OKX WebSocket Disconnection nach Inaktivität
# PROBLEM: OKX trennt WebSocket nach 60s Inaktivität
Ursache: Fehlender Heartbeat / Ping-Pong
LÖSUNG: Implementiere aktiven Heartbeat-Thread
import websocket
import threading
import time
import json
import logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
class OKXStableConnection:
def __init__(self, symbols):
self.symbols = symbols
self.ws = None
self.running = False
self.heartbeat_thread = None
self.last_pong_time = 0
self.missed_pongs = 0
self.max_missed_pongs = 3
def start(self):
"""Startet WebSocket mit automatischem Heartbeat"""
self.running = True
self.ws = websocket.WebSocketApp(
"wss://ws.okx.com:8443/ws/v5/public",
on_message=self._on_message,
on_open=self._on_open,
on_error=self._on_error,
on_close=self._on_close
)
# Starte Heartbeat-Thread
self.heartbeat_thread = threading.Thread(target=self._heartbeat_loop)
self.heartbeat_thread.daemon = True
self.heartbeat_thread.start()
# Starte WebSocket (blocking)
self.ws.run_forever(
ping_interval=None, # Wir handhaben Ping selbst
ping_timeout=30
)
def _heartbeat_loop(self):
"""Sendet alle 20s einen Ping, reconnectet bei Timeout"""
while self.running:
try:
if self.ws and self.ws.sock and self.ws.sock.connected:
ping_id = int(time.time() * 1000)
ping_msg = {"op": "ping", "args": [ping_id]}
self.ws.send(json.dumps(ping_msg))
logger.info(f"Ping gesendet: {ping_id}")
time.sleep(20) # Alle 20 Sekunden
except Exception as e:
logger.error(f"Heartbeat-Fehler: {e}")
self._reconnect()
def _check_pong(self, pong_id):
"""Verifiziert dass Pong empfangen wurde"""
current_time = time.time()
if self.last_pong_time == 0:
self.last_pong_time = current_time
self.missed_pongs = 0
else:
time_since_last_pong = current_time - self.last_pong_time
if time_since_last_pong > 30: # Mehr als 30s ohne Pong
self.missed_pongs += 1
logger.warning(f"Verpasster Pong #{self.missed_pongs}")
if self.missed_pongs >= self.max_missed_pongs:
logger.error("Zu viele verpasste Pongs, reconnecte...")
self._reconnect()
def _reconnect(self):
"""Führt geordneten Reconnect durch"""
logger.info("Starte Reconnect...")
self.running = False
if self.ws:
self.ws.close()
time.sleep(5) # 5s Pause vor Reconnect
self.running = True
self.start()
def _on_open(self, ws):
logger.info("OKX WebSocket verbunden")
# Subscribe zu Orderbooks
subscribe_msg = {
"op": "subscribe",
"args": [
{"channel": "books5", "instId": sym}
for sym in self.symbols
]
}
ws.send(json.dumps(subscribe_msg))
def _on_message(self, ws, message):
data = json.loads(message)
# Pong empfangen
if data.get('event') == 'pong':
self._check_pong(data['args'][0])
return
# Daten verarbeiten
if 'data' in data:
logger.debug(f"Daten empfangen: {data['arg']['channel']}")
def _on_error(self, ws, error):
logger.error(f"WebSocket Fehler: {error}")
def _on_close(self, ws, code, msg):
logger.warning(f"Verbindung geschlossen: {code} - {msg}")
if self.running:
self._reconnect()
def stop(self):
self.running = False
if self.ws:
self.ws.close()
Nutzung
connection = OKXStableConnection(['BTC-USDT', 'ETH-USDT'])
connection.start()
Fehler 3: Falsche Orderbook-Interpretation bei Reconnects
# PROBLEM: Nach WebSocket-Reconnect werden alte Daten nicht verworfen
Ursache: Cache enthält veraltete Orderbook-Stände
LÖSUNG: Immer frischem Snapshot nach Reconnect anfordern
import websocket
import json
import time
from collections import OrderedDict
class SafeOrderbookManager:
def __init__(self, symbol):
self.symbol = symbol
self.bids = OrderedDict() # {price: qty}
self.asks = OrderedDict()
self.last_update_id = 0
self.last_sequence = 0
self.is_snapshot_fresh = False
self.reconnect_count = 0
def request_snapshot(self, exchange='binance'):
"""Fordert frischen Orderbook-Snapshot an"""
if exchange == 'binance':
url = f"https://api.binance.com/api/v3/depth"
params = {"symbol": self.symbol.upper(), "limit": 1000}
else: # okx
url = f"https://www.okx.com/api/v5/market/books"
params = {"instId": self.symbol.upper(), "sz": "400"}
import requests
response = requests.get(url, params=params)
data = response.json()
# Clear und Refresh
self.bids.clear()
self.asks.clear()
if exchange == 'binance':
for bid in data['bids']:
self.bids[float(bid[0])] = float(bid[1])
for ask in data['asks']:
self.asks[float(ask[0])] = float(ask[1])
self.last_update_id = data['lastUpdateId']
else: # okx
for item in data['data']:
for bid in item['bids']:
self.bids[float(bid[0])] = float(bid[1])
for ask in item['asks']:
self.asks[float(ask[0])]
Verwandte Ressourcen
Verwandte Artikel