Inhoudsopgave

Overzicht Cachingstrategieën Verbindingspooling Batchbewerkingen Query-optimalisatie Compressie Asynchrone patronen Prestatiemetingen Benchmarking Optimalisatie-aanbevelingen

API-documentatie

API-prestatieoptimalisatie en latentievermindering

Behaal responstijden van minder dan 100ms met Smart Money API. Beheers caching, verbindingspooling, batchbewerkingen en query-optimalisatie voor maximale doorvoer.

Gepubliceerd op 21 maart 2026 • 17 minuten leestijd • Prestaties

Prestatieoverzicht

Smart Money API is geoptimaliseerd voor lage latentie en hoge doorvoer. Bereik maximale prestaties door de aanbevolen patronen in uw integratie te implementeren.

Lagen van prestatieoptimalisatie:

Caching — Lokale en CDN-caching vermindert oorspronkelijke verzoeken
Verbindingspooling — Hergebruik verbindingen, verminder overhead
Batchbewerkingen — Combineer meerdere verzoeken in één
Query-optimalisatie — Vraag alleen benodigde gegevens op
Asynchroon/Parallel — Verwerk meerdere verzoeken gelijktijdig

Prestatiedoel: P95 latentie <100ms, P99 <500ms, 99,9% uptime met <0,1% foutpercentage.

Cachingstrategieën

Response Caching

Lokale cache
// Respecteer Cache-Control-headers
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-invalidatie

Walvisaccumulatiedata: 5 minuten TTL
Funding rates: 1 minuut TTL
OHLCV-data: 1 uur TTL
Historische data: 24 uur TTL

Live funding en open interest — gratis API

Funding, open interest en long/short-verhoudingen van de beurzen die we dekken, live in onze screener.

Bekijk live funding →

Verbindingspooling

HTTP-verbindinghergebruik

Verbindingspool
// Node.js HTTP Agent met 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
});
// Gebruik agents in verzoeken
fetch(url, { agent: httpsAgent });

Verbindingsinstellingen

Parameter	Aanbevolen	Reden
maxSockets	50-100	Balans tussen gelijktijdigheid en resourcegebruik
maxFreeSockets	10-20	Houd inactieve verbindingen voor hergebruik
keepAliveTimeout	60000ms	Match server timeout

Batchbewerkingen

Combineren van verzoeken

Batchquery
// In plaats van meerdere verzoeken
// GET /whales?asset=BTC
// GET /whales?asset=ETH
// GET /whales?asset=SOL
// Gebruik één batchverzoek
GET /v1/whales?asset=BTC,ETH,SOL
// ~200ms bespaard ten opzichte van 3 opeenvolgende verzoeken

Batchlimieten

Max. symbolen per verzoek: 100
Max. tijdsbereik: 365 dagen
Max. resultaten: 10.000 rijen

Query-optimalisatie

Verzoekoptimalisatie

Specificeer velden — Vraag alleen benodigde velden op
Gebruik filters — Verminder de responsgrootte met filters
Paginering — Gebruik limit-parameter, niet offset
Tijdframes — Vraag alleen de data op die u nodig hebt

Geoptimaliseerde query
// Minder efficiënt: Veel data
GET /v1/whales?lookback=90d&limit=10000
// Efficiënter: Specifieke data
GET /v1/whales?
  asset=BTC&
  metric=accumulation&
  lookback=7d&
  limit=100

Responsecompressie

Gzip-compressie

Verzoekcompressie
// Schakel compressie in voor verzoeken
fetch(url, {
  headers: {
    'Accept-Encoding': 'gzip, deflate'
  }
});
// API comprimeert automatisch indien ondersteund
// Typische compressie: 70-80% groottereductie

Compressiebesparingen

Gegevenstype	Niet gecomprimeerd	Gecomprimeerd	Besparingen
JSON-reacties	500KB	85KB	83%
Grote tabellen	2MB	350KB	82%

Async/Parallelle patronen

Gelijktijdige verzoeken

Parallelle verzoeken
// Inefficiënt: Sequentieel
const btc = await fetch('/whales/BTC');
const eth = await fetch('/whales/ETH');
const sol = await fetch('/whales/SOL');
// Totale tijd: ~300ms
// Efficiënt: Parallel
const [btc, eth, sol] = await Promise.all([
  fetch('/whales/BTC'),
  fetch('/whales/ETH'),
  fetch('/whales/SOL')
]);
// Totale tijd: ~100ms (3x sneller!)

Prestatiemetingen

Belangrijke metrieken

Metriek	Doel	Meting
P50 Latency	<50ms	Mediane responstijd
P95 Latency	<100ms	95e percentiel
P99 Latency	<500ms	99e percentiel
Doorvoer	>1000 req/s	Verzoeken per seconde

Prestatiebewaking

Prestatiebewaking
// Volg responstijd
const start = performance.now();
const response = await fetch(url);
const duration = performance.now() - start;
// Log voor analyse
console.log(`Verzoek duurde ${duration}ms`);

Benchmarking

Belastingtesten

Benchmark je integratie om knelpunten te identificeren:

Tool: Apache Bench, wrk, of Locust
Test met realistische gelijktijdigheidsniveaus
Meet de latentieverdeling, niet alleen het gemiddelde
Test met warme en koude cache

Optimalisatieaanbevelingen

Snelle winsten

Schakel HTTP-verbindingspooling in (1-5x verbetering)
Implementeer lokale caching (10-50x voor herhaalde verzoeken)
Gebruik batchbewerkingen (2-5x reductie in verzoeken)
Schakel gzip-compressie in (3-5x bandbreedtereductie)

Geavanceerde optimalisaties

Implementeer CDN-caching voor historische gegevens
Gebruik databaseverbindingspools voor lokale caching
Implementeer het circuit breaker-patroon
Gebruik streaming-reacties voor grote datasets

Bereik maximale prestaties

Smart Money API is gebouwd voor snelheid. Implementeer deze optimalisatiestrategieën voor sub-100ms latentie en maximale doorvoer.

Bekijk prestatiecategorieën

Pro- en Enterprise-abonnementen bevatten geavanceerde caching- en prestatiekenmerken.