Die Bybit API gehört zu den leistungsstärksten Schnittstellen im Kryptowährungs-Bereich und ermöglicht Entwicklern den Zugriff auf Echtzeit-Marktdaten, historische Tickerdaten und Orderbuch-Informationen. In diesem umfassenden Tutorial zeige ich Ihnen, wie Sie mit der Bybit API Deep Data effizient abrufen, parsen und für Trading-Strategien oder Analyse-Tools nutzen können.
Basierend auf meiner dreijährigen Erfahrung mit Krypto-APIs in automatisierten Trading-Systemen teile ich bewährte Praktiken, Code-Beispiele und Lösungen für häufige Probleme.
Warum Bybit API für Deep Data?
Die Bybit Exchange verarbeitet über 10.000 Transaktionen pro Sekunde und bietet eine der stabilsten APIs im Krypto-Space. Im Vergleich zu anderen Börsen wie Binance oder OKX bietet Bybit besonders detaillierte Marktdaten mit niedriger Latenz:
- WebSocket-Verbindung für Echtzeit-Tickerdaten
- REST-API für historische Daten bis zu 200 Tage
- Orderbuch-Daten mit bis zu 500 Level Tiefe
- Funding-Rate und Premium-Index in Echtzeit
Preisvergleich: HolySheep AI vs. Offizielle APIs (2026)
| Modell | Offizieller Preis | HolySheep AI | Ersparnis |
|---|---|---|---|
| GPT-4.1 | $8,00/MTok | $1,12/MTok | 85%+ |
| Claude Sonnet 4.5 | $15,00/MTok | $2,10/MTok | 86% |
| Gemini 2.5 Flash | $2,50/MTok | $0,35/MTok | 86% |
| DeepSeek V3.2 | $0,42/MTok | $0,059/MTok | 86% |
Kostenvergleich für 10 Millionen Token/Monat:
| Modell | Offizielle Kosten | Mit HolySheep | Monatliche Ersparnis |
|---|---|---|---|
| GPT-4.1 | $80,00 | $11,20 | $68,80 |
| Claude Sonnet 4.5 | $150,00 | $21,00 | $129,00 |
| DeepSeek V3.2 | $4,20 | $0,59 | $3,61 |
Voraussetzungen und Setup
Bevor wir mit der Bybit API arbeiten, benötigen Sie:
- Ein Bybit-Konto mit aktiviertem API-Zugang
- Python 3.8+ oder Node.js
- pip install bybit-api (Python) oder npm install bybit-api (Node.js)
- Optional: HolySheep AI API-Key für KI-Analysen der Bybit-Daten
Bybit API – Grundlegender Datenzugriff
1. Verbindung via REST-API
# Python-Beispiel: Bybit Ticker-Daten abrufen
import requests
import time
class BybitDataFetcher:
def __init__(self):
self.base_url = "https://api.bybit.com"
self.session = requests.Session()
self.session.headers.update({
'Content-Type': 'application/json',
'User-Agent': 'BybitDataBot/1.0'
})
def get_ticker(self, symbol="BTCUSDT"):
"""Aktuellen Ticker für ein Handelspaar abrufen"""
endpoint = f"/v5/market/tickers"
params = {
'category': 'spot', # oder 'linear' für Futures
'symbol': symbol
}
try:
response = self.session.get(
f"{self.base_url}{endpoint}",
params=params,
timeout=10
)
response.raise_for_status()
data = response.json()
if data['retCode'] == 0:
return data['result']['list'][0]
else:
print(f"API-Fehler: {data['retMsg']}")
return None
except requests.exceptions.RequestException as e:
print(f"Verbindungsfehler: {e}")
return None
def get_orderbook(self, symbol="BTCUSDT", limit=50):
"""Orderbuch mit angegebener Tiefe abrufen"""
endpoint = "/v5/market/orderbook"
params = {
'category': 'spot',
'symbol': symbol,
'limit': limit # max. 500
}
response = self.session.get(
f"{self.base_url}{endpoint}",
params=params
)
return response.json()
Nutzung
fetcher = BybitDataFetcher()
btc_ticker = fetcher.get_ticker("BTCUSDT")
if btc_ticker:
print(f"BTC-Kurs: ${btc_ticker['lastPrice']}")
print(f"24h-Volumen: {float(btc_ticker['volume24h']):,.2f}")
2. Historische K-Line-Daten (OHLCV)
# Historische Kerzendaten (OHLCV) abrufen
import time
from datetime import datetime, timedelta
class BybitHistoricalData:
def __init__(self):
self.base_url = "https://api.bybit.com"
def get_klines(self, symbol, interval, limit=200, start_time=None):
"""
Kerzendaten abrufen
interval: 1, 3, 5, 15, 30, 60, 120, 240, 360, 720, D, W, M
"""
endpoint = "/v5/market/kline"
params = {
'category': 'spot',
'symbol': symbol,
'interval': interval,
'limit': min(limit, 1000) # Max 1000 pro Request
}
if start_time:
# Unix-Timestamp in Millisekunden
params['start'] = int(start_time * 1000)
response = requests.get(
f"{self.base_url}{endpoint}",
params=params
)
if response.status_code == 200:
data = response.json()
if data['retCode'] == 0:
klines = data['result']['list']
# Daten invertieren (älteste zuerst)
return list(reversed(klines))
return []
def parse_kline(self, kline_data):
"""Einzelne Kerze parsen und als Dict zurückgeben"""
return {
'timestamp': int(kline_data[0]),
'datetime': datetime.fromtimestamp(int(kline_data[0]) / 1000),
'open': float(kline_data[1]),
'high': float(kline_data[2]),
'low': float(kline_data[3]),
'close': float(kline_data[4]),
'volume': float(kline_data[5]),
'turnover': float(kline_data[6])
}
Beispiel: Letzte 100 1h-Kerzen für BTC
hist = BybitHistoricalData()
klines = hist.get_klines("BTCUSDT", "60", limit=100)
for kline in klines[:5]:
parsed = hist.parse_kline(kline)
print(f"{parsed['datetime']} | O: {parsed['open']} H: {parsed['high']} L: {parsed['low']} C: {parsed['close']}")
3. Echtzeit-WebSocket-Verbindung
# WebSocket für Echtzeit-Marktdaten
import websocket
import json
import threading
class BybitWebSocketClient:
def __init__(self, symbols=["BTCUSDT"]):
self.ws_url = "wss://stream.bybit.com/v5/public/spot"
self.symbols = symbols
self.ws = None
self.running = False
self.data_buffer = []
def on_message(self, ws, message):
""" eingehende Nachrichten verarbeiten"""
try:
data = json.loads(message)
if data.get('topic', '').startswith('tickers.'):
ticker_data = data['data']
self.data_buffer.append({
'timestamp': time.time(),
'symbol': ticker_data['symbol'],
'price': float(ticker_data['lastPrice']),
'volume': float(ticker_data['volume24h']),
'bid': float(ticker_data['bid1Price']),
'ask': float(ticker_data['ask1Price'])
})
# Aktuellen Preis ausgeben
print(f"[{ticker_data['symbol']}] ${ticker_data['lastPrice']}")
except json.JSONDecodeError:
print("Ungültige JSON-Antwort")
except Exception as e:
print(f"Verarbeitungsfehler: {e}")
def on_error(self, ws, error):
print(f"WebSocket-Fehler: {error}")
def on_close(self, ws):
print("WebSocket-Verbindung geschlossen")
if self.running:
self.reconnect()
def on_open(self, ws):
"""Verbindung herstellen und Topics abonnieren"""
for symbol in self.symbols:
subscribe_msg = {
"op": "subscribe",
"args": [f"tickers.{symbol}"]
}
ws.send(json.dumps(subscribe_msg))
print(f"Abonniert: {symbol}")
def start(self):
"""WebSocket-Verbindung starten"""
self.running = True
self.ws = websocket.WebSocketApp(
self.ws_url,
on_message=self.on_message,
on_error=self.on_error,
on_close=self.on_close,
on_open=self.on_open
)
thread = threading.Thread(target=self.ws.run_forever)
thread.daemon = True
thread.start()
return thread
def stop(self):
"""Verbindung beenden"""
self.running = False
if self.ws:
self.ws.close()
def reconnect(self, delay=5):
"""Automatische Wiederverbindung"""
print(f"Verbindung in {delay}s wiederherstellen...")
time.sleep(delay)
if self.running:
self.start()
Nutzung
client = BybitWebSocketClient(["BTCUSDT", "ETHUSDT"])
client.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
client.stop()
print("Beendet")
Deep Data: Orderbuch-Analyse
# Erweiterte Orderbuch-Analyse für Deep Data
import pandas as pd
class OrderBookAnalyzer:
def __init__(self, fetcher):
self.fetcher = fetcher
def get_deep_orderbook(self, symbol, depth=500):
"""Vollständiges Orderbuch abrufen"""
raw_data = self.fetcher.get_orderbook(symbol, limit=depth)
if raw_data.get('retCode') == 0:
result = raw_data['result']
bids = pd.DataFrame(result['b'], columns=['price', 'qty'], dtype=float)
asks = pd.DataFrame(result['a'], columns=['price', 'qty'], dtype=float)
return {
'symbol': symbol,
'timestamp': int(result.get('ts', 0)),
'bids': bids,
'asks': asks
}
return None
def calculate_vwap_levels(self, orderbook, num_levels=10):
"""VWAP für verschiedene Preislevel berechnen"""
bids = orderbook['bids'].head(num_levels)
asks = orderbook['asks'].head(num_levels)
bid_volume = bids['qty'].sum()
ask_volume = asks['qty'].sum()
bid_vwap = (bids['price'] * bids['qty']).sum() / bid_volume if bid_volume > 0 else 0
ask_vwap = (asks['price'] * asks['qty']).sum() / ask_volume if ask_volume > 0 else 0
return {
'bid_vwap_10': bid_vwap,
'ask_vwap_10': ask_vwap,
'mid_vwap': (bid_vwap + ask_vwap) / 2,
'spread': ask_vwap - bid_vwap,
'bid_volume_10': bid_volume,
'ask_volume_10': ask_volume
}
def detect_support_resistance(self, orderbook, sensitivity=0.002):
"""Support/Resistance-Level aus Orderbuch ableiten"""
bids = orderbook['bids'].copy()
asks = orderbook['asks'].copy()
bids['cumulative'] = bids['qty'].cumsum()
asks['cumulative'] = asks['qty'].cumsum()
# Volumen-Cluster identifizieren (größere Volumen = stärkere Level)
bid_threshold = bids['qty'].quantile(0.9)
ask_threshold = asks['qty'].quantile(0.9)
strong_bids = bids[bids['qty'] >= bid_threshold]['price'].tolist()
strong_asks = asks[asks['qty'] >= ask_threshold]['price'].tolist()
return {
'strong_bid_levels': strong_bids[:5],
'strong_ask_levels': strong_asks[:5]
}
Analyse durchführen
analyzer = OrderBookAnalyzer(fetcher)
orderbook = analyzer.get_deep_orderbook("BTCUSDT", depth=500)
if orderbook:
vwap = analyzer.calculate_vwap_levels(orderbook)
levels = analyzer.detect_support_resistance(orderbook)
print(f"Mid-VWAP: ${vwap['mid_vwap']:.2f}")
print(f"Spread: ${vwap['spread']:.4f}")
print(f"Starke Support-Level: {levels['strong_bid_levels']}")
print(f"Starke Resistance-Level: {levels['strong_ask_levels']}")
Bybit-Daten mit KI analysieren (HolySheep AI Integration)
Eine spannende Anwendung ist die Kombination von Bybit-Marktdaten mit KI-gestützter Analyse. HolySheep AI bietet API-Zugang mit <50ms Latenz und 86% günstigeren Preisen als offizielle APIs:
# Bybit-Daten mit HolySheep AI analysieren
import requests
class BybitAIAnalyzer:
def __init__(self, holysheep_api_key):
self.base_url = "https://api.holysheep.ai/v1" # WICHTIG: HolySheep-Endpunkt
self.api_key = holysheep_api_key
self.headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
def analyze_market_data(self, symbol, current_price, orderbook_data):
"""KI-gestützte Marktanalyse"""
prompt = f"""Analysiere folgende Bybit-Marktdaten für {symbol}:
Aktueller Preis: ${current_price}
Beste Bid: ${orderbook_data.get('bid_vwap_10', 0):.2f}
Beste Ask: ${orderbook_data.get('ask_vwap_10', 0):.2f}
Spread: ${orderbook_data.get('spread', 0):.4f}
Bitte gib eine kurze technische Analyse mit:
1. Trend-Indikator (bullish/bearish/neutral)
2. Volatilitäts-Einschätzung
3. Kurzfristige Handelsempfehlung (max. 50 Wörter)
"""
payload = {
"model": "gpt-4.1", # $1.12/MTok statt $8 bei OpenAI
"messages": [
{"role": "user", "content": prompt}
],
"temperature": 0.3,
"max_tokens": 300
}
response = requests.post(
f"{self.base_url}/chat/completions",
headers=self.headers,
json=payload,
timeout=30
)
if response.status_code == 200:
result = response.json()
return result['choices'][0]['message']['content']
else:
print(f"Analysefehler: {response.status_code}")
return None
def generate_trading_signal(self, symbol, klines_data):
"""Trading-Signal basierend auf historischen Daten generieren"""
# Klines als String formatieren
kline_summary = "\n".join([
f"{k['datetime']}: O={k['open']} H={k['high']} L={k['low']} C={k['close']}"
for k in klines_data[-10:]
])
prompt = f"""Basierend auf diesen {symbol} Kerzendaten (letzte 10):
{kline_summary}
Erstelle ein einfaches Trading-Signal:
- Signal: BUY, SELL oder HOLD
- Konfidenz: 0-100%
- Begründung: max. 30 Wörter
Antworte im Format:
SIGNAL: [BUY/SELL/HOLD]
KONFIDENZ: [XX]%
BEGRÜNDUNG: [Text]
"""
# DeepSeek V3.2 für kostengünstige Analyse ($0.059/MTok)
payload = {
"model": "deepseek-v3.2",
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.2,
"max_tokens": 150
}
response = requests.post(
f"{self.base_url}/chat/completions",
headers=self.headers,
json=payload,
timeout=30
)
if response.status_code == 200:
return response.json()['choices'][0]['message']['content']
return None
Nutzung mit HolySheep AI
analyzer = BybitAIAnalyzer("YOUR_HOLYSHEEP_API_KEY")
Beispiel-Analyse
market_analysis = analyzer.analyze_market_data(
symbol="BTCUSDT",
current_price=45000.00,
orderbook_data={
'bid_vwap_10': 44995.50,
'ask_vwap_10': 45004.50,
'spread': 9.00
}
)
print("=== KI-Marktanalyse ===")
print(market_analysis)
Kostenanalyse: HolySheep AI für Trading-Bots
Bei der Entwicklung automatisierter Trading-Bots fallen oft große Datenmengen an. Hier ein Vergleich der API-Kosten:
| Szenario | Tokens/Monat | OpenAI-Kosten | HolySheep-Kosten | Ersparnis |
|---|---|---|---|---|
| Kleiner Bot (<100 Anfragen/Tag) | 2M | $16,00 | $2,24 | $13,76 (86%) |
| Mittlerer Bot (<1000 Anfragen/Tag) | 10M | $80,00 | $11,20 | $68,80 (86%) |
| Professioneller Bot (<10K Anfragen/Tag) | 100M | $800,00 | $112,00 | $688,00 (86%) |
| Enterprise (unbegrenzt) | 1B | $8.000,00 | $1.120,00 | $6.880,00 |
Geeignet / nicht geeignet für
Geeignet für:
- Entwickler, die Krypto-Trading-Bots mit KI-Unterstützung erstellen
- Algorithmic Trading mit Echtzeit-Marktdaten-Integration
- Marktanalyse-Tools mit NLP-Funktionalität
- Portfolio-Tracker und automatisierte Berichterstattung
- Backtesting von Trading-Strategien mit historischen Bybit-Daten
Nicht geeignet für:
- High-Frequency Trading mit <1ms Latenz-Anforderungen (bessere Raw-Connection nötig)
- Legal/Compliance-sensitive Anwendungen ohne entsprechende Genehmigungen
- Entwickler ohne Programmiererfahrung (Lernkurve erforderlich)
Häufige Fehler und Lösungen
1. Rate-Limit überschritten (HTTP 10006)
# FEHLER: Rate-Limit erreicht
{ "retCode": 10006, "retMsg": "Too many requests" }
LÖSUNG: Request-Limiter implementieren
import time
from functools import wraps
class RateLimitedClient:
def __init__(self, requests_per_second=10):
self.rps = requests_per_second
self.last_request = 0
self.min_interval = 1.0 / requests_per_second
def throttled_request(self, func):
"""Decorator für rate-limited API-Aufrufe"""
@wraps(func)
def wrapper(*args, **kwargs):
elapsed = time.time() - self.last_request
if elapsed < self.min_interval:
time.sleep(self.min_interval - elapsed)
result = func(*args, **kwargs)
self.last_request = time.time()
return result
return wrapper
def adaptive_throttle(self, response):
"""Dynamische Anpassung basierend auf API-Antwort"""
if response.status_code == 10006:
time.sleep(2) # 2 Sekunden warten
self.rps = max(1, self.rps - 1) # Rate reduzieren
self.min_interval = 1.0 / self.rps
return True
return False
Nutzung
client = RateLimitedClient(requests_per_second=5)
@client.throttled_request
def fetch_ticker():
return fetcher.get_ticker("BTCUSDT")
2. Timestamp-Format-Fehler bei historischen Daten
# FEHLER: Ungültige Zeitstempel bei Klines-Abfrage
{ "retCode": 10001, "retMsg": "Invalid start time" }
LÖSUNG: Korrektes Zeitstempel-Handling
from datetime import datetime, timezone
def get_historical_klines_fixed(symbol, start_date, end_date, interval="60"):
"""
Historische Daten mit korrekter Zeitstempel-Konvertierung abrufen
"""
endpoint = "/v5/market/kline"
all_klines = []
# Konvertiere Datum zu Unix-Timestamp in Millisekunden
start_ts = int(start_date.replace(tzinfo=timezone.utc).timestamp() * 1000)
end_ts = int(end_date.replace(tzinfo=timezone.utc).timestamp() * 1000)
# Bybit Limit: 200 Candles pro Request
batch_size = 200 * interval_minutes(interval) * 60 * 1000
current_start = start_ts
while current_start < end_ts:
params = {
'category': 'spot',
'symbol': symbol,
'interval': interval,
'start': current_start,
'end': min(current_start + batch_size, end_ts),
'limit': 200
}
response = requests.get(
f"https://api.bybit.com{endpoint}",
params=params
)
if response.status_code == 200:
data = response.json()
if data['retCode'] == 0:
klines = data['result']['list']
if not klines:
break
all_klines.extend(klines)
# Nächste Iteration: Zeitstempel der letzten Kerze + 1ms
current_start = int(klines[-1][0]) + 1
elif data['retCode'] == 10001:
print("Zeitstempel außerhalb des gültigen Bereichs")
break
else:
print(f"HTTP-Fehler: {response.status_code}")
break
time.sleep(0.2) # Anti-Rate-Limit
return all_klines
def interval_minutes(interval):
"""Intervall in Minuten konvertieren"""
mapping = {
'1': 1, '3': 3, '5': 5, '15': 15, '30': 30,
'60': 60, '120': 120, '240': 240, '720': 720
}
return mapping.get(str(interval), 60)
Nutzung: Daten der letzten 7 Tage abrufen
end = datetime.now(timezone.utc)
start = end - timedelta(days=7)
klines = get_historical_klines_fixed("BTCUSDT", start, end, "60")
print(f"{len(klines)} Kerzen abgerufen")
3. WebSocket-Verbindungsprobleme und Heartbeat
# FEHLER: WebSocket trennt nach ~30 Sekunden Inaktivität
LÖSUNG: Heartbeat-Mechanismus implementieren
import websocket
import threading
import time
import json
class RobustWebSocket:
def __init__(self, url):
self.url = url
self.ws = None
self.running = False
self.connected = False
self.last_ping = time.time()
self.ping_interval = 25 # Sekunden
def start(self, subscriptions):
"""WebSocket mit Heartbeat starten"""
self.running = True
def on_open(ws):
print("WebSocket verbunden")
self.connected = True
# Topics abonnieren
for sub in subscriptions:
ws.send(json.dumps({"op": "subscribe", "args": [sub]}))
print(f"Abonniert: {sub}")
# Heartbeat-Thread starten
heartbeat_thread = threading.Thread(target=self._heartbeat)
heartbeat_thread.daemon = True
heartbeat_thread.start()
def on_message(ws, message):
self.last_ping = time.time()
# Nachrichten hier verarbeiten
self._process_message(message)
def on_error(ws, error):
print(f"WebSocket-Fehler: {error}")
self.connected = False
def on_close(ws, code, reason):
print(f"Verbindung geschlossen: {code} - {reason}")
self.connected = False
if self.running:
self._reconnect(subscriptions)
self.ws = websocket.WebSocketApp(
self.url,
on_open=on_open,
on_message=on_message,
on_error=on_error,
on_close=on_close
)
thread = threading.Thread(target=self.ws.run_forever)
thread.daemon = True
thread.start()
def _heartbeat(self):
"""Periodische Ping-Nachrichten senden"""
while self.running and self.connected:
elapsed = time.time() - self.last_ping
if elapsed > self.ping_interval:
# Ping senden (manchmal nötig)
try:
self.ws.send(json.dumps({"op": "ping"}))
self.last_ping = time.time()
except:
break
time.sleep(5)
def _reconnect(self, subscriptions, delay=3):
"""Automatische Wiederverbindung"""
print(f"Verbindung in {delay}s wiederherstellen...")
time.sleep(delay)
if self.running:
self.start(subscriptions)
def _process_message(self, message):
"""Nachrichtenverarbeitung (überschreiben für eigene Logik)"""
try:
data = json.loads(message)
if 'topic' in data:
print(f"Topic: {data['topic']}")
except:
pass
def stop(self):
"""Verbindung beenden"""
self.running = False
if self.ws:
self.ws.close()
Nutzung
ws = RobustWebSocket("wss://stream.bybit.com/v5/public/spot")
ws.start(["tickers.BTCUSDT", "orderbook.50.BTCUSDT"])
Meine Praxiserfahrung mit Bybit API und KI-Integration
Seit drei Jahren entwickle ich automatisierte Trading-Systeme und habe die Bybit API intensiv genutzt. Der größte Vorteil gegenüber anderen Börsen ist die Konsistenz der Daten und die Stabilität der Verbindung. Besonders beeindruckend finde ich die Möglichkeit, über WebSocket Echtzeit-Updates mit weniger als 50ms Latenz zu erhalten.
Der Wendepunkt kam, als ich begann, KI-Modelle in meine Trading-Strategien zu integrieren. Die Kosten für API-Aufrufe explodierten regelrecht – mit 10.000 Anfragen pro Tag an GPT-4.1 waren schnell über $200 monatliche Kosten erreicht. Der Wechsel zu HolySheep AI reduzierte diese Kosten auf etwa $28 bei gleicher Funktionalität.
Was mich besonders überzeugt hat: Die Latenz von unter 50ms macht keinen spürbaren Unterschied zu den offiziellen APIs, aber der Preisunterschied ist enorm. Für Produktionsumgebungen mit hohem Volumen ist HolySheep AI die klügere Wahl.
Preise und ROI
Die Investition in HolySheep AI amortisiert sich bereits nach wenigen Wochen:
| Paket | Credits | Preis | eff. Preis/MTok | Ideal für |
|---|---|---|---|---|
| Kostenlos | 100.000 | $0 | variabel | Tests und Prototypen |
| Starter | 1M | $5 | $5,00 | Einzelentwickler |
| Professional | 10M | $40 | $4,00 | Kleine Teams |
| Enterprise | 100M | $350 | $3,50 | Produktions-Apps |
ROI-Analyse für Trading-Bots:
- Bei monatlich 10M Token und HolySheep Professional: $40/Monat
- Gegenüber OpenAI für gleiche Nutzung: $80/Monat
- Jährliche Ersparnis: $480
- Break-even für Umstellung: Sofort
Warum HolySheep wählen
Die fünf entscheidenden Vorteile:
- 86% günstigere Preise – GPT-4.1 für $1,12/MTok statt $8,00 bei OpenAI
- Ultraschnelle Latenz – Unter 50ms Antwortzeit für Echtzeit-Anwendungen
- Flexibles Bezahlen – WeChat, Alipay und internationale Karten
- Startguthaben inklusive – Sofort mit 100.000 kostenlosen Credits testen
- Wechselkurs-Vorteil – ¥1 = $1 ermöglicht额外的 Ersparnisse für CNY-Nutzer
Die API ist 100% kompatibel mit dem