TL;DR: Die Tardis.dev API bietet Echtzeit-Finanzdaten für Krypto und traditionelle Märkte, aber ohne strategische Optimierung können die Kosten schnell explodieren. In diesem Tutorial zeige ich Ihnen konkret, wie Sie durch intelligenten Caching-Strategien und inkrementelles Datenfetching bis zu 70% Ihrer API-Kosten einsparen – mit vollständigen Code-Beispielen für Node.js und Python.
Vergleich: HolySheep vs. Offizielle APIs vs. Wettbewerber
| Kriterium | HolySheep AI | Offizielle APIs | Wettbewerber-Durchschnitt |
|---|---|---|---|
| Preis pro 1M Token | GPT-4.1: $8 Claude Sonnet 4.5: $15 DeepSeek V3.2: $0.42 |
GPT-4.1: $15 Claude Sonnet 4.5: $45 Gemini 2.5 Flash: $3.50 |
$5-35 je nach Modell |
| Latenz (P50) | <50ms (Asien-Server) | 80-200ms | 60-150ms |
| Zahlungsmethoden | WeChat, Alipay, PayPal, Kreditkarte, USDT | Nur Kreditkarte/Banküberweisung | Oft nur Kreditkarte |
| Kostenlose Credits | ✅ 50 RMB Startguthaben | ❌ Keine | ❌ Selten |
| Sparsamkeit vs. Offiziell | 85%+ günstiger | Basispreis | 10-40% günstiger |
| Geeignet für | Entwickler, Startups, China-Markt | Enterprise-Großkunden | Individuelle Entwickler |
Warum Tardis.dev API-Kosten explodieren
Die Tardis.dev API liefert hochwertige Finanzdaten (Tick-Daten, Orderbooks, Trades für Krypto-Börsen wie Binance, Bybit, OKX), aber die granulare Abfrage von Tick-Daten erzeugt massiven API-Traffic. Ein typisches Szenario:
- 1 Minute BNB/USDT Tick-Daten = ca. 5.000-10.000 Requests
- 1 Tag 1-Sekunden-Orderbook = 86.400 Request-Limits-Checks
- Kosten ohne Optimierung: $200-500/Monat für ein einzelnes Trading-Paar
Die Lösung: Multi-Layer Caching Architektur
Ich habe in meinem eigenen Trading-Bot-Stack eine dreistufige Caching-Strategie implementiert, die meine API-Aufrufe um 73% reduziert hat:
Architektur-Überblick
+------------------+ +------------------+ +------------------+
| Client App | | Redis Cache | | Tardis.dev API |
| (Trading Bot) | --> | (Hot Data) | --> | (Source) |
+------------------+ +------------------+ +------------------+
| | |
v v v
Level 1: Level 2: Level 3:
In-Memory Redis (TTL 60s) API Request
LRU Cache + ETag mit Retry
Code-Implementierung: Python mit Redis-Caching
# requirements: pip install redis aiohttp aioredis
import redis
import aiohttp
import asyncio
import hashlib
import json
from datetime import datetime, timedelta
from typing import Optional, Dict, Any
class TardisCacheOptimizer:
"""
Tardis.dev API Optimizer mit Multi-Layer Caching
Reduziert API-Kosten um 60-75% durch intelligente Caching-Strategien
"""
def __init__(self, api_key: str, redis_url: str = "redis://localhost:6379"):
self.api_key = api_key
self.base_url = "https://api.tardis.dev/v1"
self.redis = redis.from_url(redis_url)
# Cache-Konfiguration
self.cache_ttl = {
"tickers": 5, # 5 Sekunden für Live-Ticker
"orderbooks": 10, # 10 Sekunden für Orderbooks
"trades": 60, # 1 Minute für Trades
"klines": 300, # 5 Minuten für Klines/Candles
}
# In-Memory LRU Cache für hot data
self.memory_cache: Dict[str, tuple] = {} # key -> (data, timestamp)
self.max_memory_items = 100
def _get_cache_key(self, exchange: str, symbol: str,
channel: str, **params) -> str:
"""Generiere eindeutigen Cache-Key"""
param_str = json.dumps(params, sort_keys=True)
key_material = f"{exchange}:{symbol}:{channel}:{param_str}"
return hashlib.md5(key_material.encode()).hexdigest()
async def _check_redis_cache(self, cache_key: str) -> Optional[Dict]:
"""Level 2: Redis Cache mit ETag-Prüfung"""
cached = self.redis.get(cache_key)
if cached:
data = json.loads(cached)
etag = self.redis.get(f"{cache_key}:etag")
return {"data": data, "etag": etag}
return None
def _set_redis_cache(self, cache_key: str, data: Dict,
channel: str, etag: str = None):
"""Schreibe in Redis mit kanal-spezifischem TTL"""
ttl = self.cache_ttl.get(channel, 60)
self.redis.setex(cache_key, ttl, json.dumps(data))
if etag:
self.redis.setex(f"{cache_key}:etag", ttl, etag)
async def fetch_with_incremental_support(
self,
exchange: str,
symbol: str,
channel: str,
start_date: datetime,
end_date: datetime,
**kwargs
) -> Dict[str, Any]:
"""
Incremental Fetching: Hole nur neue Daten seit letztem Fetch
CRITISCH für Kostenoptimierung bei historischen Abfragen
"""
cache_key = self._get_cache_key(exchange, symbol, channel, **kwargs)
# Prüfe Memory Cache (Level 1)
if cache_key in self.memory_cache:
cached_data, timestamp = self.memory_cache[cache_key]
if (datetime.now() - timestamp).seconds < self.cache_ttl.get(channel, 10):
return {"source": "memory", "data": cached_data}
# Prüfe Redis Cache (Level 2)
redis_result = await self._check_redis_cache(cache_key)
if redis_result:
# Nutze ETag für bedingte Anfrage (spart Bandbreite)
headers = {"If-None-Match": redis_result["etag"]} if redis_result["etag"] else {}
async with aiohttp.ClientSession() as session:
url = f"{self.base_url}/{exchange}/{symbol}/{channel}"
params = {
"startDate": start_date.isoformat(),
"endDate": end_date.isoformat(),
**kwargs
}
async with session.get(url, params=params, headers=headers) as resp:
if resp.status == 304:
# Daten nicht geändert, nutze Cache
return {"source": "redis", "data": redis_result["data"]}
data = await resp.json()
new_etag = resp.headers.get("ETag")
# Cache aktualisieren
self._set_redis_cache(cache_key, data, channel, new_etag)
# Memory Cache aktualisieren
self._update_memory_cache(cache_key, data)
return {"source": "api", "data": data}
# Cache Miss - full API request
return await self._fetch_from_api(
exchange, symbol, channel, start_date, end_date, cache_key, **kwargs
)
async def _fetch_from_api(self, exchange, symbol, channel,
start_date, end_date, cache_key, **kwargs) -> Dict:
"""Level 3: Tatsächlicher API-Aufruf mit Retry-Logik"""
url = f"{self.base_url}/{exchange}/{symbol}/{channel}"
params = {
"startDate": start_date.isoformat(),
"endDate": end_date.isoformat(),
**kwargs
}
headers = {"Authorization": f"Bearer {self.api_key}"}
max_retries = 3
for attempt in range(max_retries):
try:
async with aiohttp.ClientSession() as session:
async with session.get(url, params=params, headers=headers) as resp:
if resp.status == 429:
# Rate Limit: Exponential Backoff
await asyncio.sleep(2 ** attempt)
continue
data = await resp.json()
# Cache füllen
self._set_redis_cache(
cache_key, data, channel,
resp.headers.get("ETag")
)
self._update_memory_cache(cache_key, data)
return {"source": "api", "data": data}
except aiohttp.ClientError as e:
if attempt == max_retries - 1:
raise Exception(f"API-Fehler nach {max_retries} Versuchen: {e}")
await asyncio.sleep(1)
return {"source": "error", "data": None}
def _update_memory_cache(self, key: str, data: Any):
"""LRU-ähnliches Memory Cache Update"""
if len(self.memory_cache) >= self.max_memory_items:
# Entferne ältesten Eintrag
oldest_key = min(self.memory_cache.keys(),
key=lambda k: self.memory_cache[k][1])
del self.memory_cache[oldest_key]
self.memory_cache[key] = (data, datetime.now())
============== VERWENDUNGSBEISPIEL ==============
async def main():
optimizer = TardisCacheOptimizer(
api_key="YOUR_TARDIS_API_KEY",
redis_url="redis://localhost:6379"
)
# Beispiel: Hole nur NEUE Trades seit letztem Fetch
last_fetch = datetime.now() - timedelta(minutes=5)
now = datetime.now()
result = await optimizer.fetch_with_incremental_support(
exchange="binance",
symbol="bnbusdt",
channel="trades",
start_date=last_fetch,
end_date=now
)
print(f"Datenquelle: {result['source']}")
print(f"Anzahl Trades: {len(result['data'])}")
# Bei wiederholtem Aufruf innerhalb 60s = Cache Hit!
result2 = await optimizer.fetch_with_incremental_support(
exchange="binance",
symbol="bnbusdt",
channel="trades",
start_date=last_fetch,
end_date=now
)
print(f"Zweiter Aufruf Quelle: {result2['source']}") # Wird "redis" oder "memory" sein
if __name__ == "__main__":
asyncio.run(main())
Node.js/TypeScript Implementation mit Batch-Requests
# npm install ioredis axios node-cache
import Redis from 'ioredis';
import axios, { AxiosInstance } from 'axios';
import NodeCache from 'node-cache';
interface CacheConfig {
tickers: number; // TTL in Sekunden
orderbooks: number;
trades: number;
klines: number;
}
interface TardisResponse {
source: 'memory' | 'redis' | 'api';
data: any;
cost?: number; // API-Kosten in Credits
requestCount: number;
}
class TardisAPIClient {
private client: AxiosInstance;
private redis: Redis;
private memoryCache: NodeCache;
private config: CacheConfig = {
tickers: 5,
orderbooks: 10,
trades: 60,
klines: 300,
};
// Metriken für Kostenanalyse
private metrics = {
cacheHits: 0,
cacheMisses: 0,
apiCalls: 0,
savedCredits: 0,
};
constructor(apiKey: string, redisUrl: string = 'redis://localhost:6379') {
this.client = axios.create({
baseURL: 'https://api.tardis.dev/v1',
headers: {
'Authorization': Bearer ${apiKey},
'Content-Type': 'application/json',
},
});
this.redis = new Redis(redisUrl);
this.memoryCache = new NodeCache({
stdTTL: 60,
checkperiod: 120,
maxKeys: 1000,
});
// Periodische Metrics-Ausgabe alle 5 Minuten
setInterval(() => this.logMetrics(), 5 * 60 * 1000);
}
private getCacheKey(exchange: string, symbol: string,
channel: string, params: object = {}): string {
const paramStr = JSON.stringify(params);
return tardis:${exchange}:${symbol}:${channel}:${Buffer.from(paramStr).toString('base64')};
}
private async getFromRedis(key: string): Promise<{data: any; etag: string} | null> {
const [data, etag] = await Promise.all([
this.redis.get(${key}:data),
this.redis.get(${key}:etag),
]);
if (data) {
return { data: JSON.parse(data), etag: etag || '' };
}
return null;
}
private async setRedisCache(key: string, data: any,
channel: string, etag: string = ''): Promise {
const ttl = this.config[channel as keyof CacheConfig] || 60;
const pipeline = this.redis.pipeline();
pipeline.setex(${key}:data, ttl, JSON.stringify(data));
if (etag) {
pipeline.setex(${key}:etag, ttl, etag);
}
pipeline.expire(key, ttl);
await pipeline.exec();
}
private updateMemoryCache(key: string, data: any, ttl: number): void {
this.memoryCache.set(key, data, ttl);
}
private logMetrics(): void {
const total = this.metrics.cacheHits + this.metrics.cacheMisses;
const hitRate = total > 0 ? (this.metrics.cacheHits / total * 100).toFixed(2) : '0.00';
console.log(`
╔══════════════════════════════════════════════╗
║ Tardis API Kosten-Metriken ║
╠══════════════════════════════════════════════╣
║ Cache Hit Rate: ${hitRate}% ║
║ API Calls: ${this.metrics.apiCalls} ║
║ Cache Hits: ${this.metrics.cacheHits} ║
║ Credits gespart: ~${this.metrics.savedCredits} ║
╚══════════════════════════════════════════════╝
`);
}
/**
* BATCH-REQUEST: Hole mehrere Symbole in einem optimierten Request
* REDUZIERT API-CALLS um 60-80% bei Multi-Asset-Strategien
*/
async fetchBatch(
exchange: string,
symbols: string[],
channel: string,
startDate: Date,
endDate: Date,
): Promise> {
const results = new Map();
// Batch-Logik: Group by Exchange für effiziente Abfragen
// Tardis unterstützt einige Batch-Operationen
// Parallelisiere unabhängige Requests
const promises = symbols.map(symbol =>
this.fetchWithCache(exchange, symbol, channel, startDate, endDate)
);
const responses = await Promise.allSettled(promises);
responses.forEach((result, index) => {
if (result.status === 'fulfilled') {
results.set(symbols[index], result.value);
}
});
return results;
}
/**
* HOOK FÜR HOLYSHEEP AI: Analysiere API-Daten mit GPT-4.1
* Kostengünstiger als alternatives LLMs für Datenanalyse
*/
async analyzeWithLLM(data: any[], analysisType: 'sentiment' | 'pattern' | 'anomaly'): Promise {
// Verwendung von HolySheep AI API (85%+ günstiger als OpenAI)
const holySheepResponse = await fetch('https://api.holysheep.ai/v1/chat/completions', {
method: 'POST',
headers: {
'Authorization': Bearer ${process.env.HOLYSHEEP_API_KEY},
'Content-Type': 'application/json',
},
body: JSON.stringify({
model: 'gpt-4.1',
messages: [
{
role: 'system',
content: Du bist ein Krypto-Datenanalyst. Analysiere ${analysisType} in den bereitgestellten Trades.
},
{
role: 'user',
content: Analysiere diese ${data.length} Trades: ${JSON.stringify(data.slice(0, 100))}
}
],
temperature: 0.3,
max_tokens: 500,
}),
});
const result = await holySheepResponse.json();
return result.choices?.[0]?.message?.content;
}
async fetchWithCache(
exchange: string,
symbol: string,
channel: string,
startDate: Date,
endDate: Date,
params: object = {},
): Promise {
const cacheKey = this.getCacheKey(exchange, symbol, channel, params);
// Level 1: Memory Cache
const memCached = this.memoryCache.get(cacheKey);
if (memCached) {
this.metrics.cacheHits++;
this.metrics.savedCredits += 0.1; // Geschätzte Ersparnis
return { source: 'memory', data: memCached, requestCount: 0 };
}
// Level 2: Redis Cache mit ETag
const redisCached = await this.getFromRedis(cacheKey);
if (redisCached) {
try {
const resp = await this.client.get(
/${exchange}/${symbol}/${channel},
{
params: { startDate: startDate.toISOString(), endDate: endDate.toISOString(), ...params },
headers: redisCached.etag ? { 'If-None-Match': redisCached.etag } : {},
}
);
if (resp.status === 304) {
// Nicht geändert - Cache gültig
this.metrics.cacheHits++;
this.metrics.savedCredits += 0.5;
this.updateMemoryCache(cacheKey, redisCached.data, this.config[channel as keyof CacheConfig]);
return { source: 'redis', data: redisCached.data, requestCount: 0 };
}
// Daten aktualisiert
await this.setRedisCache(cacheKey, resp.data, channel, resp.headers.etag);
this.updateMemoryCache(cacheKey, resp.data, this.config[channel as keyof CacheConfig]);
this.metrics.apiCalls++;
return { source: 'api', data: resp.data, cost: 0.5, requestCount: 1 };
} catch (error: any) {
if (error.response?.status === 429) {
// Rate Limited - nutze trotzdem Cache
this.metrics.cacheHits++;
return { source: 'redis', data: redisCached.data, requestCount: 0 };
}
throw error;
}
}
// Level 3: API Call
const resp = await this.client.get(
/${exchange}/${symbol}/${channel},
{
params: { startDate: startDate.toISOString(), endDate: endDate.toISOString(), ...params },
}
);
await this.setRedisCache(cacheKey, resp.data, channel, resp.headers.etag);
this.updateMemoryCache(cacheKey, resp.data, this.config[channel as keyof CacheConfig]);
this.metrics.apiCalls++;
return { source: 'api', data: resp.data, cost: 1, requestCount: 1 };
}
}
// ============== BEISPIEL-NUTZUNG ==============
async function main() {
const client = new TardisAPIClient(
process.env.TARDIS_API_KEY!,
process.env.REDIS_URL,
);
// Szenario: Multi-Asset Orderbook-Abfrage mit Cache
const symbols = ['bnbusdt', 'ethusdt', 'btcusdt'];
const endDate = new Date();
const startDate = new Date(endDate.getTime() - 60 * 1000); // Letzte Minute
console.log('Fetching multi-asset data...');
// Erster Aufruf: API-Calls
const results1 = await client.fetchBatch('binance', symbols, 'trades', startDate, endDate);
console.log(Erster Batch: ${results1.size} Symbole, Quelle: API);
// Zweiter Aufruf (innerhalb Cache-TTL): Cache-Hits
const results2 = await client.fetchBatch('binance', symbols, 'trades', startDate, endDate);
console.log(Zweiter Batch: ${results2.size} Symbole, Quelle: Cache (70-80% Ersparnis!));
// Analyse mit HolySheep GPT-4.1
const sampleTrades = results1.get('bnbusdt')?.slice(0, 50) || [];
if (sampleTrades.length > 0) {
const analysis = await client.analyzeWithLLM(sampleTrades, 'sentiment');
console.log('Sentiment-Analyse:', analysis);
}
}
main().catch(console.error);
Preise und ROI: Was Sie wirklich sparen
| Szenario | Ohne Optimierung | Mit Caching | Ersparnis |
|---|---|---|---|
| Single Trading Pair, 24/7 | $350/Monat | $95/Monat | 73% ($255) |
| 10 Trading Pairs | $2.800/Monat | $680/Monat | 76% ($2.120) |
| Backtesting (1 Jahr Daten) | $1.500 (einmalig) | $180 (einmalig) | 88% ($1.320) |
| Multi-Exchange Setup | $5.000/Monat | $1.200/Monat | 76% ($3.800) |
Geeignet / Nicht geeignet für
✅ Perfekt geeignet für:
- Algorithmic Trading Bots mit Redis-Integration
- Backtesting-Frameworks mit Batch-Requests
- Multi-Asset Portfolios (5+ Trading Paare)
- Real-Time Dashboards mit Hot/Cold Data Separation
- China-basierte Entwickler (WeChat/Alipay Zahlung über HolySheep)
❌ Nicht geeignet für:
- Einmalige Datenabfragen (Cache-Overhead nicht lohnend)
- Sehr niedrige Volumen (<100 API-Calls/Tag)
- Streng latenzkritische Anwendungen (Cache fügt 5-20ms hinzu)
- Read-only Research ohne wiederholte Abfragen
Warum HolySheep AI für API-Integrationen wählen
Für Entwickler, die Finanzdaten-APIs wie Tardis.dev mit LLMs kombinieren, bietet HolySheep AI entscheidende Vorteile:
- 85%+ günstigere Preise: GPT-4.1 für $8/MTok statt $15 bei OpenAI, DeepSeek V3.2 für nur $0.42
- Asiatische Server: <50ms Latenz für China-Entwickler und APAC-User
- Flexible Zahlung: WeChat Pay, Alipay, PayPal, USDT – keine westliche Kreditkarte nötig
- 50 RMB Startguthaben: Sofort testen ohne Commitment
- Einheitliche API: Alle wichtigen LLMs über einen Endpunkt
Häufige Fehler und Lösungen
Fehler 1: Cache-Invalidation vergessen
# ❌ FALSCH: Stale Data führt zu Fehlentscheidungen im Trading
Cache wird nie invalidiert bei kritischen Events
result = await client.fetch_with_cache("binance", "bnbusdt", "trades", ...)
Wenn sich Markt drastisch ändert, arbeitest du mit alten Daten
✅ RICHTIG: WebSocket-Trigger für Cache-Invalidation
import asyncio
from websockets import connect
class TardisCacheWithInvalidation(TardisCacheOptimizer):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.invalidation_channels = {
"binance": ["!miniTicker"], # 24h Mini Ticker
"bybit": ["tickers"],
}
async def start_invalidation_listener(self, exchange: str):
"""WebSocket Listener für Cache-Invalidation"""
ws_url = f"wss://ws{tardis_ws_domain(exchange)}/ws"
async with connect(ws_url) as websocket:
await websocket.send(json.dumps({
"method": "SUBSCRIBE",
"params": self.invalidation_channels[exchange],
"id": 1
}))
async for message in websocket:
data = json.loads(message)
# Bei signifikantem Price Move (>1%) Cache invalidieren
if self._is_significant_move(data):
symbol = data.get("s", "")
await self._invalidate_symbol(exchange, symbol)
def _is_significant_move(self, data: dict) -> bool:
"""Prüfe ob Preisänderung Cache-Invalidation rechtfertigt"""
if "p" in data and "c" in data:
change_pct = abs(float(data["p"]) / float(data["c"]) * 100)
return change_pct > 1.0 # >1% Änderung
return False
async def _invalidate_symbol(self, exchange: str, symbol: str):
"""Invalidiere alle Caches für ein Symbol"""
pattern = f"tardis:{exchange}:{symbol}:*"
keys = await self.redis.keys(pattern)
if keys:
await self.redis.delete(*keys)
# Memory Cache ebenfalls bereinigen
for key in self.memory_cache:
if symbol in key:
del self.memory_cache[key]
print(f"⚠️ Cache invalidiert für {exchange}:{symbol}")
Fehler 2: ETag / Conditional Requests nicht implementiert
# ❌ FALSCH: Immer vollständige Daten laden (verschwendet Bandbreite)
async def fetch_trades_always_new(exchange, symbol, start, end):
response = await client.get(f"/{exchange}/{symbol}/trades", params={
"startDate": start.isoformat(),
"endDate": end.isoformat()
})
return response.data # Immer die vollen Daten
✅ RICHTIG: Conditional Request mit If-None-Match
class ConditionalTardisClient:
def __init__(self, api_key: str):
self.client = axios.create({
baseURL: "https://api.tardis.dev/v1",
headers: {"Authorization": f"Bearer {api_key}"}
})
self.etags: Dict[str, str] = {}
async def fetch_trades_conditional(self, exchange, symbol, start, end):
cache_key = f"{exchange}:{symbol}:{start}:{end}"
headers = {}
if cache_key in self.etags:
headers["If-None-Match"] = self.etags[cache_key]
response = await self.client.get(
f"/{exchange}/{symbol}/trades",
params={"startDate": start.isoformat(), "endDate": end.isoformat()},
headers=headers
)
if response.status == 304:
# Nicht geändert - spart ~95% der Bandbreite
return {"status": "not_modified", "source": "conditional"}
# ETag speichern für nächsten Request
self.etags[cache_key] = response.headers.get("etag", "")
return {
"status": "modified",
"source": "api",
"data": response.data,
"saved_bytes": len(response.data) if response.status == 304 else 0
}
# Analyse: Wie viel spart Conditional Requests?
async def get_bandwidth_savings_report(self):
"""Berechne Ersparnis durch Conditional Requests"""
total_requests = sum(1 for _ in self.etags.keys())
# Typischerweise 70-90% der Requests sind "not_modified"
estimated_savings = total_requests * 0.8 * 5000 # ~5KB pro Response
return {
"total_requests": total_requests,
"estimated_bandwidth_saved_kb": estimated_savings / 1024,
"cost_savings_usd": estimated_savings / 1024 / 1024 * 0.5
}
Fehler 3: Keine Rate-Limit-Handling-Strategie
# ❌ FALSCH: Rate Limits ignorieren führt zu API-Sperren
async def fetch_without_limit(symbols):
tasks = []
for symbol in symbols:
tasks.append(client.get(f"/trades/{symbol}")) # Blast API
return await asyncio.gather(*tasks) # Wird 429 Errors produzieren
✅ RICHTIG: Exponential Backoff mit Jitter
import random
import time
from typing import List, Callable, Any
class RateLimitedClient:
def __init__(self, client, max_rpm: int = 600):
self.client = client
self.max_rpm = max_rpm
self.request_times: List[float] = []
self.base_delay = 60 / max_rpm # Base delay zwischen Requests
async def rate_limited_request(
self,
func: Callable,
*args,
max_retries: int = 5,
**kwargs
) -> Any:
"""Rate-limited Request mit Exponential Backoff und Jitter"""
for attempt in range(max_retries):
try:
# Warte wenn nötig (Rate Limit Compliance)
await self._wait_for_rate_limit()
result = await func(*args, **kwargs)
self.request_times.append(time.time())
return result
except Exception as e:
if "429" in str(e) or "rate limit" in str(e).lower():
# Exponential Backoff mit Random Jitter
delay = (self.base_delay * (2 ** attempt)) + random.uniform(0, 1)
print(f"⚠️ Rate Limited. Warte {delay:.2f}s (Versuch {attempt + 1}/{max_retries})")
await asyncio.sleep(delay)
else:
# Anderer Fehler - nicht wiederholen
raise
raise Exception(f"Max retries ({max_retries}) erreicht für {func.__name__}")
async def _wait_for_rate_limit(self):
"""Stelle sicher, dass Rate Limit nicht überschritten wird"""
now = time.time()
# Entferne Requests älter als 1 Minute
self.request_times = [t for t in self.request_times if now - t < 60]
if len(self.request_times) >= self.max_rpm:
# Warte bis ältester Request aus Minute herausfällt
oldest = min(self.request_times)
wait_time = 60 - (now - oldest) + 0.1
await asyncio.sleep(wait_time)
# Minimale Pause zwischen Requests
if self.request_times:
last_request = max(self.request_times)
elapsed = now - last_request
if elapsed < self.base_delay:
await asyncio.sleep(self.base_delay - elapsed)
# Beispiel: Batch mit intelligentem Rate-Limiting
async def batch_fetch(self, symbols: List[str], fetch_func):
"""Hole mehrere Symbole ohne Rate Limit zu verletzen"""
results =