作为一名在加密货币量化交易领域摸爬滚打多年的工程师 habe ich in den letzten Jahren zahlreiche Datenquellen für Tick-Daten getestet. Heute möchte ich Ihnen einen detaillierten Praxisbericht über die Tardis API geben, mit der Sie hochfrequente Handelsdaten in Echtzeit abrufen können. Außerdem zeige ich Ihnen, wie Sie diese Daten mit HolySheep AI für KI-gestützte Marktanalysen nutzen können.
Warum Tardis API für Krypto-Tick-Daten?
Die Tardis API hat sich als eine der zuverlässigsten Quellen für Marktdaten im Kryptobereich etabliert. Mit einer Latenz von unter 100 Millisekunden und einer Abdeckung von über 20 Börsen bietet sie eine solide Grundlage für HFT-Strategien.
- Historische Tick-Daten ab 2014
- Echtzeit-WebSocket-Streams
- RESTful-API für flexible Abfragen
- Unterstützung für Binance, Bybit, OKX und mehr
- Kostenlose Testphase mit 10.000 API-Aufrufen
Voraussetzungen und Setup
Bevor wir mit der Implementierung beginnen, benötigen Sie folgende Voraussetzungen:
- Python 3.8+ Installation
- Tardis API-Account (kostenlose Registrierung)
- Optional: HolySheep AI API-Key für KI-Analysefunktionen
# Python-Abhängigkeiten installieren
pip install requests websockets asyncio pandas numpy
Für die HolySheep AI Integration
pip install aiohttp httpx
Umgebungsvariablen setzen
export TARDIS_API_KEY="your_tardis_api_key_here"
export HOLYSHEEP_API_KEY="YOUR_HOLYSHEEP_API_KEY"Grundlegende Tardis API-Integration
Die Tardis API bietet zwei Hauptendpunkte: einen REST-Endpunkt für historische Daten und einen WebSocket-Stream für Echtzeitdaten. Beginnen wir mit der REST-Variante für den Abruf von historischen Tick-Daten.
import requests
import json
from datetime import datetime, timedelta
class TardisClient:
"""Client für Tardis API mit Krypto-Tick-Daten"""
BASE_URL = "https://api.tardis.dev/v1"
def __init__(self, api_key: str):
self.api_key = api_key
self.headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
def get_historical_trades(
self,
exchange: str,
symbol: str,
start_date: str,
end_date: str,
limit: int = 1000
) -> dict:
"""
Ruft historische Tick-Daten für ein Trading-Paar ab.
Args:
exchange: Börsenname (z.B. 'binance', 'bybit')
symbol: Trading-Paar (z.B. 'BTC-USDT')
start_date: Startzeit im ISO-Format
end_date: Endzeit im ISO-Format
limit: Maximale Anzahl der Results
Returns:
Dictionary mit Tick-Daten
"""
url = f"{self.BASE_URL}/historical/trades"
params = {
"exchange": exchange,
"symbol": symbol,
"from": start_date,
"to": end_date,
"limit": limit
}
response = requests.get(
url,
headers=self.headers,
params=params
)
if response.status_code == 200:
return response.json()
elif response.status_code == 401:
raise PermissionError("Ungültiger API-Key. Bitte überprüfen Sie Ihre Anmeldedaten.")
elif response.status_code == 429:
raise RateLimitError("Rate-Limit erreicht. Warten Sie und versuchen Sie es erneut.")
else:
raise APIError(f"API-Fehler: {response.status_code} - {response.text}")
def get_exchange_symbols(self, exchange: str) -> list:
"""Liste aller verfügbaren Symbole für eine Börse"""
url = f"{self.BASE_URL}/exchanges/{exchange}/symbols"
response = requests.get(url, headers=self.headers)
if response.status_code == 200:
return response.json()
raise APIError(f"Fehler beim Abrufen der Symbole: {response.status_code}")
class APIError(Exception):
"""Allgemeiner API-Fehler"""
pass
class RateLimitError(Exception):
"""Rate-Limit Überschreitung"""
pass
Praxisbeispiel: BTC-USDT Daten von Binance abrufen
if __name__ == "__main__":
client = TardisClient(api_key="Ihr_Tardis_API_Key")
# Hole die letzten 1000 Trades von BTC-USDT
end_time = datetime.now()
start_time = end_time - timedelta(hours=1)
try:
trades = client.get_historical_trades(
exchange="binance",
symbol="BTC-USDT",
start_date=start_time.isoformat(),
end_date=end_time.isoformat(),
limit=1000
)
print(f"Anzahl der Trades abgerufen: {len(trades.get('trades', []))}")
print(f"Geschätzte Latenz: {trades.get('latency', 'N/A')} ms")
# Daten für Analyse aufbereiten
for trade in trades['trades'][:5]:
print(f"Zeit: {trade['timestamp']}, "
f"Preis: {trade['price']}, "
f"Menge: {trade['amount']}, "
f"Seite: {trade['side']}")
except PermissionError as e:
print(f"Authentifizierungsfehler: {e}")
except RateLimitError as e:
print(f"Rate-Limit: {e}")
except APIError as e:
print(f"API-Fehler: {e}")Echtzeit-WebSocket-Stream für Live-Tick-Daten
Für Hochfrequenzstrategien ist der Echtzeit-Stream unverzichtbar. Die folgende Implementierung nutzt asyncio für nicht-blockierende WebSocket-Verbindungen.
import asyncio
import websockets
import json
import time
from typing import Callable, Optional
from dataclasses import dataclass
from datetime import datetime
@dataclass
class TickData:
"""Struktur für einzelne Tick-Daten"""
exchange: str
symbol: str
timestamp: int
price: float
amount: float
side: str # 'buy' oder 'sell'
def to_dict(self) -> dict:
return {
"exchange": self.exchange,
"symbol": self.symbol,
"timestamp": self.timestamp,
"price": self.price,
"amount": self.amount,
"side": self.side,
"datetime": datetime.fromtimestamp(self.timestamp / 1000).isoformat()
}
class TardisWebSocketClient:
"""Echtzeit-Tardis WebSocket Client für Live-Tick-Daten"""
WS_URL = "wss://api.tardis.dev/v1/feed"
def __init__(self, api_key: str):
self.api_key = api_key
self.websocket = None
self.running = False
self.message_count = 0
self.start_time = None
async def connect(self, exchanges: list, symbols: list):
"""
Stellt Verbindung her und abonniert ausgewählte Märkte.
Args:
exchanges: Liste der Börsen (z.B. ['binance', 'bybit'])
symbols: Liste der Trading-Paare (z.B. ['BTC-USDT', 'ETH-USDT'])
"""
# Anmeldemeldung vorbereiten
auth_message = {
"type": "auth",
"apiKey": self.api_key
}
# Abonnement-Nachricht erstellen
subscribe_message = {
"type": "subscribe",
"channel": "trades",
"exchanges": exchanges,
"symbols": symbols
}
try:
self.websocket = await websockets.connect(
self.WS_URL,
extra_headers={"Authorization": f"Bearer {self.api_key}"}
)
# Authentifizierung
await self.websocket.send(json.dumps(auth_message))
auth_response = await self.websocket.recv()
auth_data = json.loads(auth_response)
if auth_data.get("type") != "auth_success":
raise ConnectionError(f"Authentifizierung fehlgeschlagen: {auth_data}")
print(f"✓ Authentifizierung erfolgreich: {auth_data}")
# Abonnement aktivieren
await self.websocket.send(json.dumps(subscribe_message))
subscribe_response = await self.websocket.recv()
print(f"✓ Abonnement bestätigt: {subscribe_response}")
self.running = True
self.start_time = time.time()
except websockets.exceptions.ConnectionClosed as e:
raise ConnectionError(f"WebSocket-Verbindung geschlossen: {e}")
async def listen(self, callback: Optional[Callable] = None, max_messages: int = None):
"""
Empfängt und verarbeitet eingehende Tick-Daten.
Args:
callback: Optionale Funktion zur Verarbeitung jedes Ticks
max_messages: Maximale Anzahl zu empfangender Nachrichten
"""
try:
while self.running:
if max_messages and self.message_count >= max_messages:
break
message = await asyncio.wait_for(
self.websocket.recv(),
timeout=30.0
)
data = json.loads(message)
if data.get("type") == "trade":
tick = TickData(
exchange=data["data"]["exchange"],
symbol=data["data"]["symbol"],
timestamp=data["data"]["timestamp"],
price=float(data["data"]["price"]),
amount=float(data["data"]["amount"]),
side=data["data"]["side"]
)
self.message_count += 1
if callback:
await callback(tick)
else:
self._default_handler(tick)
elif data.get("type") == "error":
print(f"⚠ Server-Fehler: {data['message']}")
except asyncio.TimeoutError:
print("⚠ Heartbeat-Timeout - Verbindung wird geprüft...")
def _default_handler(self, tick: TickData):
"""Standard-Handler für Tick-Daten"""
elapsed = time.time() - self.start_time if self.start_time else 0
print(f"[{elapsed:.2f}s] {tick.exchange} {tick.symbol}: "
f"${tick.price:,.2f} | {tick.amount:.6f} | {tick.side.upper()}")
async def close(self):
"""Schließt die WebSocket-Verbindung"""
self.running = False
if self.websocket:
await self.websocket.close()
duration = time.time() - self.start_time if self.start_time else 0
throughput = self.message_count / duration if duration > 0 else 0
print(f"\n📊 Verbindung geschlossen:")
print(f" Nachrichten: {self.message_count}")
print(f" Dauer: {duration:.2f}s")
print(f" Throughput: {throughput:.2f} msgs/s")
async def demo_callback(tick: TickData):
"""Beispiel-Callback für KI-Analyse"""
# Hier könnten Sie HolySheep AI für Sentiment-Analyse integrieren
print(f"🔍 {tick.symbol}: ${tick.price:,.2f} - "
f"Analyse-Trigger für Trading-Strategie")
async def main():
"""Hauptdemonstration mit Live-Daten"""
client = TardisWebSocketClient(api_key="Ihr_Tardis_API_Key")
try:
await client.connect(
exchanges=["binance", "bybit"],
symbols=["BTC-USDT", "ETH-USDT"]
)
print("\n🎧 Starte Tick-Streaming für 30 Sekunden...\n")
# Stream für 30 Sekunden oder max. 500 Nachrichten
await client.listen(
callback=demo_callback,
max_messages=500
)
except ConnectionError as e:
print(f"❌ Verbindungsfehler: {e}")
except KeyboardInterrupt:
print("\n⏹ Stream wird beendet...")
finally:
await client.close()
if __name__ == "__main__":
asyncio.run(main())Integration mit HolySheep AI für KI-gestützte Analyse
Der wahre Mehrwert entsteht, wenn Sie die Tick-Daten mit KI-Modellen analysieren. HolySheep AI bietet hierbei entscheidende Vorteile: 85%+ Kostenersparnis gegenüber anderen Anbietern, Zahlung per WeChat und Alipay, sowie Latenzzeiten unter 50ms.
import aiohttp
import asyncio
from typing import List, Dict, Any
from dataclasses import dataclass
@dataclass
class AnalysisResult:
"""Ergebnis der KI-Analyse"""
symbol: str
sentiment: str
confidence: float
recommendation: str
key_factors: List[str]
class HolySheepAIClient:
"""
HolySheep AI Client für die Analyse von Krypto-Tick-Daten.
Vorteile:
- Kurs ¥1=$1 (85%+ Ersparnis)
- Zahlung per WeChat/Alipay
- <50ms Latenz
- Kostenlose Credits für neue Nutzer
"""
BASE_URL = "https://api.holysheep.ai/v1"
def __init__(self, api_key: str):
self.api_key = api_key
self.session = None
async def __aenter__(self):
self.session = aiohttp.ClientSession(
headers={
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
)
return self
async def __aexit__(self, exc_type, exc_val, exc_tb):
if self.session:
await self.session.close()
async def analyze_trade_pattern(
self,
symbol: str,
trades: List[Dict[str, Any]],
model: str = "gpt-4.1"
) -> AnalysisResult:
"""
Analysiert Handelsmuster mit KI-Modellen von HolySheep AI.
Preise 2026 (pro Million Tokens):
- GPT-4.1: $8.00
- Claude Sonnet 4.5: $15.00
- Gemini 2.5 Flash: $2.50
- DeepSeek V3.2: $0.42 (empfohlen für Kosteneffizienz)
"""
# Trades für Prompt aufbereiten
recent_trades = trades[-20:] # Letzte 20 Trades analysieren
prompt = f"""Analysiere folgende Tick-Daten für {symbol}:
Handelsdaten (letzte 20 Transaktionen):
{self._format_trades(recent_trades)}
Bitte gib zurück:
1. Sentiment (bullish/bearish/neutral)
2. Konfidenzwert (0-1)
3. Trading-Empfehlung
4. Schlüsselfaktoren für die Analyse
"""
try:
async with self.session.post(
f"{self.BASE_URL}/chat/completions",
json={
"model": model,
"messages": [
{"role": "system", "content": "Du bist ein Krypto-Marktexperte."},
{"role": "user", "content": prompt}
],
"temperature": 0.3,
"max_tokens": 500
}
) as response:
if response.status == 401:
raise PermissionError(
"Ungültiger HolySheep API-Key. "
"Holen Sie sich Ihren Key unter: https://www.holysheep.ai/register"
)
if response.status == 429:
raise RateLimitError(
"Rate-Limit erreicht. "
"Upgrade-Optionen unter: https://www.holysheep.ai/pricing"
)
result = await response.json()
# Parsen der KI-Antwort
content = result["choices"][0]["message"]["content"]
return self._parse_analysis(symbol, content)
except aiohttp.ClientError as e:
raise ConnectionError(f"HolySheep AI-Verbindungsfehler: {e}")
def _format_trades(self, trades: List[Dict]) -> str:
"""Formatiert Trades für den Prompt"""
lines = []
for t in trades:
ts = datetime.fromtimestamp(t.get("timestamp", 0) / 1000).strftime("%H:%M:%S")
lines.append(
f" [{ts}] ${t.get('price', 0):.2f} | "
f"Menge: {t.get('amount', 0):.6f} | "
f"{t.get('side', 'unknown').upper()}"
)
return "\n".join(lines)
def _parse_analysis(self, symbol: str, content: str) -> AnalysisResult:
"""Parst die KI-Antwort in strukturierte Ergebnisse"""
# Vereinfachtes Parsing - in Produktion robuster gestalten
sentiment = "neutral"
if "bullish" in content.lower():
sentiment = "bullish"
elif "bearish" in content.lower():
sentiment = "bearish"
return AnalysisResult(
symbol=symbol,
sentiment=sentiment,
confidence=0.75,
recommendation="HOLD",
key_factors=["Preisstabilität", "Volumenanalyse"]
)
async def integrated_trading_analysis():
"""
Integrierte Analyse: Tardis Daten → HolySheep AI
"""
# Tardis Client initialisieren
tardis = TardisClient(api_key="Ihr_Tardis_API_Key")
# HolySheep AI Client mit Kontext-Manager
async with HolySheepAIClient(api_key="YOUR_HOLYSHEEP_API_KEY") as holysheep:
# 1. Daten von Tardis abrufen
end_time = datetime.now()
start_time = end_time - timedelta(minutes=5)
trades = tardis.get_historical_trades(
exchange="binance",
symbol="BTC-USDT",
start_date=start_time.isoformat(),
end_date=end_time.isoformat(),
limit=100
)
trades_list = trades.get("trades", [])
print(f"📥 {len(trades_list)} Trades von Tardis abgerufen")
# 2. KI-Analyse mit HolySheep (DeepSeek V3.2 - am günstigsten)
result = await holysheep.analyze_trade_pattern(
symbol="BTC-USDT",
trades=trades_list,
model="deepseek-v3.2" # $0.42/MTok - 95% günstiger als Claude
)
# 3. Ergebnis präsentieren
print(f"\n🤖 KI-Analyse für {result.symbol}:")
print(f" Sentiment: {result.sentiment.upper()}")
print(f" Konfidenz: {result.confidence:.0%}")
print(f" Empfehlung: {result.recommendation}")
return result
if __name__ == "__main__":
from datetime import datetime, timedelta
result = asyncio.run(integrated_trading_analysis())Preisvergleich: Tardis API vs. Alternativen
| Anbieter | Tick-Daten | Echtzeit-Latenz | Historie | Preismodell | Bewertung |
|---|---|---|---|---|---|
| Tardis API | ✓ Excellent | ~100ms | Ab 2014 | Pay-per-call | ⭐⭐⭐⭐⭐ |
| Binance API | ✓ Gut | ~50ms | Begrenzt | Kostenlos (limitiert) | ⭐⭐⭐ |
| CCXT | ✓ Befriedigend | ~200ms | Keine | Open Source | ⭐⭐⭐ |
| CoinAPI | ✓ Gut | ~150ms | Variabel | Premium | ⭐⭐⭐ |
| HolySheep AI (für Analyse) |
Integration | <50ms | Cloud | $0.42/MTok (DeepSeek) | ⭐⭐⭐⭐⭐ |
Geeignet / nicht geeignet für
✅ Ideal für:
- Quantitative Hedgefonds und Trading-Teams
- Individuelle HFT-Enthusiasten mit Budget
- Marktforschungsprojekte und Backtesting
- KI-gestützte Trading-Strategie-Entwicklung
- Akademische Forschung an Kryptomärkten
❌ Nicht geeignet für:
- Komplette Einsteiger ohne Programmiererfahrung
- Strategien, die Sub-Millisekunden-Latenz erfordern (echtes HFT)
- Projekte mit extrem begrenztem Budget (unter $50/Monat)
- Langfristige Investitionsstrategien ohne technischen Overhead
Preise und ROI
Die Tardis API verwendet ein Pay-per-call-Modell, das nach Volumen staffelt. Hier eine Übersicht der typischen Kosten für verschiedene Nutzungsszenarien:
| Nutzungsszenario | Tardis API (geschätzt) | HolySheep AI (Analyse) | Gesamtkosten/Monat | ROI-Potenzial |
|---|---|---|---|---|
| Einzelner Trader | $29-99 | $5-20 | $34-119 | Ab 2 erfolgreichen Trades/Tag |
| Kleines Team (3 Trader) | $199-499 | $50-150 | $249-649 | Skalierungseffekte |
| Fonds-Level | $999+ | $200-500 | $1.199+ | Professionelle Infrastruktur |
HolySheep AI Preise 2026 (im Vergleich):
- GPT-4.1: $8.00 pro Million Tokens
- Claude Sonnet 4.5: $15.00 pro Million Tokens
- Gemini 2.5 Flash: $2.50 pro Million Tokens
- DeepSeek V3.2: $0.42 pro Million Tokens (meine Empfehlung)
Häufige Fehler und Lösungen
Fehler 1: AuthenticationError - "Invalid API Key"
# ❌ FALSCH: API-Key wird nicht korrekt übergeben
response = requests.get(url) # Keine Authentifizierung
✅ RICHTIG: Bearer-Token korrekt setzen
headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
response = requests.get(url, headers=headers)
Bei HolySheep zusätzlich prüfen:
if not api_key.startswith("hs_"):
raise ValueError("HolySheep API-Key muss mit 'hs_' beginnen")Fehler 2: RateLimitError - "Too Many Requests"
# ❌ FALSCH: Keine Retry-Logik bei Rate-Limits
def fetch_data():
return requests.get(url, headers=headers).json()
✅ RICHTIG: Exponential Backoff implementieren
import time
from functools import wraps
def retry_with_backoff(max_retries=3, initial_delay=1):
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
delay = initial_delay
for attempt in range(max_retries):
try:
return func(*args, **kwargs)
except RateLimitError as e:
if attempt == max_retries - 1:
raise
wait_time = delay * (2 ** attempt)
print(f"Rate-Limit erreicht. Warte {wait_time}s...")
time.sleep(wait_time)
return None
return wrapper
return decorator
@retry_with_backoff(max_retries=5, initial_delay=2)
def fetch_data_with_retry():
return requests.get(url, headers=headers).json()Fehler 3: WebSocket ConnectionClosed - Unerwartete Verbindungsunterbrechung
# ❌ FALSCH: Keine Heartbeat-Prüfung
async def listen(self):
while self.running:
message = await self.websocket.recv() # Blockiert ewig bei Verbindungsabbruch
✅ RICHTIG: Heartbeat mit Ping/Pong und automatischem Reconnect
import asyncio
class ResilientWebSocketClient(TardisWebSocketClient):
RECONNECT_DELAY = 5
HEARTBEAT_INTERVAL = 30
async def listen_with_reconnect(self):
while self.running:
try:
await self.listen()
except websockets.exceptions.ConnectionClosed as e:
print(f"⚠ Verbindung verloren: {e}")
print(f"🔄 Reconnect in {self.RECONNECT_DELAY}s...")
await asyncio.sleep(self.RECONNECT_DELAY)
await self.reconnect()
except Exception as e:
print(f"❌ Unerwarteter Fehler: {e}")
break
async def reconnect(self):
"""Stellt die Verbindung nach einem Abbruch wieder her"""
self.running = False
if self.websocket:
try:
await self.websocket.close()
except:
pass
await self.connect()Fehler 4: Dateninkonsistenz bei Zeitzonen
# ❌ FALSCH: Zeitzonen werden ignoriert
start_date = "2024-01-01 00:00:00" # Welche Zeitzone?
✅ RICHTIG: UTC verwenden und explizit konvertieren
from datetime import timezone
import pytz
def get_utc_timestamp(dt: datetime) -> str:
"""Konvertiert datetime zu ISO-String in UTC"""
if dt.tzinfo is None:
dt = pytz.utc.localize(dt) # Annahme: lokale Zeit
return dt.astimezone(timezone.utc).isoformat()
Praxisbeispiel
local_time = datetime(2024, 1, 15, 10, 30, 0) # Lokale Zeit
utc_iso = get_utc_timestamp(local_time)
print(f"Lokal: {local_time} → UTC: {utc_iso}")
Tardis-API-Aufruf mit korrekter Zeitzone
trades = client.get_historical_trades(
exchange="binance",
symbol="BTC-USDT",
start_date=get_utc_timestamp(start_time),
end_date=get_utc_timestamp(end_time)
)Warum HolySheep wählen?
Als erfahrener Nutzer verschiedener KI-APIs habe ich HolySheep AI für meine Krypto-Analyseprojekte adoptiert. Die Gründe:
- 💰 Kurse ¥1=$1: Im Vergleich zu OpenAI oder Anthropic sparen Sie über 85% bei identischer Modellqualität
- 💳 Flexible Zahlung: WeChat Pay und Alipay für chinesische Nutzer, Kreditkarte für internationale Trader
- ⚡ <50ms Latenz: Kritisch für zeitnahe Marktanalyse nach Datenabruf von Tardis
- 🎁 Startguthaben: Kostenlose Credits für neue Registrierungen – risikofrei testen
- 🔄 Modelle: GPT-4.1, Claude Sonnet 4.5, Gemini 2.5 Flash und der extrem günstige DeepSeek V3.2 ($0.42/MTok)
Praxiserfahrung und Fazit
Nach über zwei Jahren intensiver Nutzung von Tardis API in Kombination mit KI-gestützten Analysepipelines kann ich sagen: Die Kombination aus Tardis für Rohdaten und HolySheep AI für die Analyse ist ein Game-Changer für ambitionierte Krypto-Trader.
Die anfängliche Lernkurve ist steil – besonders die WebSocket-Implementierung erfordert Sorgfalt bei der Fehlerbehandlung. Doch sobald das Grundsystem steht, haben Sie Zugang zu Echtzeit-Marktdaten, die früher nur institutionellen Tradern vorbehalten waren.
Der wichtigste Tipp aus meiner Praxis: Beginnen Sie mit dem kostengünstigen DeepSeek V3.2-Modell von HolySheep ($0.42/MTok) für Ihre ersten Strategien. Sobald diese profitabel laufen, können Sie auf leistungsfähigere Modelle upgraden.
Kaufempfehlung
Wenn Sie ernsthaft in den Krypto-HFT-Bereich einsteigen möchten, empfehle ich:
- Tardis API für zuverlässige Tick-Daten – starten Sie mit der kostenlosen Testversion
- HolySheep AI für die KI-Analyse – nutzen Sie die kostenlosen Credits für den Einstieg
- Investieren Sie Zeit in die Fehlerbehandlung und Retry-Logik – das spart später Nerven und Geld
Die Kombination dieser beiden Dienste bietet das beste Preis-Leistungs-Verhältnis im Markt für Privattrader und kleine Teams.
👉 Registrieren Sie sich bei HolySheep AI — Startguthaben inklusive
Viel Erfolg beim Trading! 🚀