Inhaltsverzeichnis

Übersicht Caching-Strategien Connection Pooling Batch-Operationen Abfrageoptimierung Kompression Asynchrone Muster Leistungsmetriken Benchmarking Optimierungsempfehlungen

API-Dokumentation

API-Leistungsoptimierung und Latenzreduzierung

Erzielen Sie Antwortzeiten unter 100 ms mit der Smart Money API. Meistern Sie Caching, Connection Pooling, Batch-Operationen und Abfrageoptimierung für maximalen Durchsatz.

Veröffentlicht am 21. März 2026 • 17 Min. Lesezeit • Leistung

Leistungsübersicht

Die Smart Money API ist für niedrige Latenz und hohen Durchsatz optimiert. Erzielen Sie maximale Leistung, indem Sie die empfohlenen Muster auf Ihrer Integrationsseite implementieren.

Ebenen der Leistungsoptimierung:

Caching — Lokales und CDN-Caching reduziert Origin-Anfragen
Connection Pooling — Wiederverwendung von Verbindungen, Reduzierung des Overheads
Batch-Operationen — Kombinieren Sie mehrere Anfragen in einer
Abfrageoptimierung — Fordern Sie nur benötigte Daten an
Asynchron/Parallel — Verarbeiten Sie mehrere Anfragen gleichzeitig

Leistungsziel: P95-Latenz <100 ms, P99 <500 ms, 99,9 % Verfügbarkeit mit <0,1 % Fehlerrate.

Caching-Strategien

Antwort-Caching

Lokaler Cache
// Cache-Control-Header beachten
const cache = new Map();
async function cachedFetch(url) {
  const cached = cache.get(url);
  if (cached && !cached.isExpired) {
    return cached.data;
  }
  const response = await fetch(url);
  const ttl = parseCacheControl(response.headers);
  cache.set(url, { data: response, expiry: ttl });
  return response;
}

Cache-Invalidierung

Whale-Akkumulationsdaten: 5 Minuten TTL
Funding Rates: 1 Minute TTL
OHLCV-Daten: 1 Stunde TTL
Historische Daten: 24 Stunden TTL

Live-Funding und Open Interest — kostenlose API

Funding, Open Interest und Long/Short-Verhältnisse der von uns abgedeckten Börsen, live in unserem Screener.

Live-Funding ansehen →

Connection Pooling

HTTP-Verbindungswiederverwendung

Verbindungspool
// Node.js HTTP Agent mit Pooling
const http = require('http');
const https = require('https');
const httpAgent = new http.Agent({
  keepAlive: true,
  maxSockets: 50,
  maxFreeSockets: 10
});
const httpsAgent = new https.Agent({
  keepAlive: true,
  maxSockets: 50,
  maxFreeSockets: 10
});
// Agents in Anfragen verwenden
fetch(url, { agent: httpsAgent });

Verbindungseinstellungen

Parameter	Empfohlen	Begründung
maxSockets	50-100	Ausgewogenheit zwischen Parallelität und Ressourcennutzung
maxFreeSockets	10-20	Leerlaufverbindungen für Wiederverwendung behalten
keepAliveTimeout	60000ms	An Server-Timeout anpassen

Batch-Operationen

Kombinieren von Anfragen

Batch-Abfrage
// Anstatt mehrerer Anfragen
// GET /whales?asset=BTC
// GET /whales?asset=ETH
// GET /whales?asset=SOL
// Verwenden Sie eine Batch-Anfrage
GET /v1/whales?asset=BTC,ETH,SOL
// ~200 ms gespart im Vergleich zu 3 sequenziellen Anfragen

Batch-Grenzen

Max. Symbole pro Anfrage: 100
Max. Zeitraum: 365 Tage
Max. Ergebnisse: 10.000 Zeilen

Abfrageoptimierung

Anfrageoptimierung

Felder angeben — Nur benötigte Felder anfordern
Filter verwenden — Antwortgröße mit Filtern reduzieren
Paginierung — Limit-Parameter verwenden, nicht Offset
Zeitrahmen — Nur benötigte Daten anfordern

Optimierte Abfrage
// Weniger effizient: Viele Daten
GET /v1/whales?lookback=90d&limit=10000
// Effizienter: Spezifische Daten
GET /v1/whales?
  asset=BTC&
  metric=accumulation&
  lookback=7d&
  limit=100

Antwortkompression

Gzip-Kompression

Anfragekompression
// Kompression in Anfragen aktivieren
fetch(url, {
  headers: {
    'Accept-Encoding': 'gzip, deflate'
  }
});
// API komprimiert automatisch, falls unterstützt
// Typische Komprimierung: 70-80% Größenreduktion

Komprimierungseinsparungen

Datentyp	Unkomprimiert	Komprimiert	Einsparungen
JSON-Antworten	500KB	85KB	83%
Große Tabellen	2MB	350KB	82%

Async/Parallel-Muster

Gleichzeitige Anfragen

Parallele Anfragen
// Ineffizient: Sequenziell
const btc = await fetch('/whales/BTC');
const eth = await fetch('/whales/ETH');
const sol = await fetch('/whales/SOL');
// Gesamtzeit: ~300ms
// Effizient: Parallel
const [btc, eth, sol] = await Promise.all([
  fetch('/whales/BTC'),
  fetch('/whales/ETH'),
  fetch('/whales/SOL')
]);
// Gesamtzeit: ~100ms (3x schneller!)

Leistungsmetriken

Wichtige Metriken

Metrik	Ziel	Messung
P50-Latenz	<50ms	Median-Antwortzeit
P95-Latenz	<100ms	95. Perzentil
P99-Latenz	<500ms	99. Perzentil
Durchsatz	>1000 req/s	Anfragen pro Sekunde

Leistungsüberwachung

Leistungsüberwachung
// Antwortzeit verfolgen
const start = performance.now();
const response = await fetch(url);
const duration = performance.now() - start;
// Zur Analyse protokollieren
console.log(`Anfrage dauerte ${duration}ms`);

Benchmarking

Lasttests

Benchmarken Sie Ihre Integration, um Engpässe zu identifizieren:

Tool: Apache Bench, wrk oder Locust
Testen Sie mit realistischen Parallelitätsgraden
Messen Sie die Latenzverteilung, nicht nur den Durchschnitt
Testen Sie mit warmem und kaltem Cache

Optimierungsempfehlungen

Schnelle Erfolge

Aktivieren Sie HTTP-Verbindungspooling (1-5x Verbesserung)
Implementieren Sie lokales Caching (10-50x für wiederholte Anfragen)
Nutzen Sie Batch-Operationen (2-5x Reduktion der Anfragen)
Aktivieren Sie gzip-Komprimierung (3-5x Bandbreitenreduktion)

Erweiterte Optimierungen

Implementieren Sie CDN-Caching für historische Daten
Nutzen Sie Datenbankverbindungspools für lokales Caching
Implementieren Sie das Circuit-Breaker-Muster
Nutzen Sie Streaming-Antworten für große Datensätze

Maximale Leistung erzielen

Smart Money API ist für Geschwindigkeit optimiert. Implementieren Sie diese Optimierungsstrategien für Latenzen unter 100ms und maximalen Durchsatz.

Leistungsstufen anzeigen

Pro- und Enterprise-Pläne beinhalten erweiterte Caching- und Leistungsfunktionen.