Innehållsförteckning

Översikt Cachelagringsstrategier Anslutningspoolning Batchoperationer Frågeoptimering Komprimering Asynkrona mönster Prestandamått Prestandamätning Optimiseringsrekommendationer

API-dokumentation

API-prestandaoptimering och latensreducering

Uppnå svarstider under 100 ms med Smart Money API. Bemästra cachelagring, anslutningspoolning, batchoperationer och frågeoptimering för maximal genomströmning.

Publicerad 21 mars 2026 • 17 min läsning • Prestanda

Prestandaöversikt

Smart Money API är optimerad för låg latens och hög genomströmning. Uppnå maximal prestanda genom att implementera rekommenderade mönster på din integrationssida.

Prestandaoptimeringslager:

Cachelagring — Lokal och CDN-cachelagring minskar ursprungsförfrågningar
Anslutningspoolning — Återanvänd anslutningar, minska overhead
Batchoperationer — Kombinera flera förfrågningar till en
Frågeoptimering — Begär endast nödvändig data
Asynkron/parallell — Bearbeta flera förfrågningar samtidigt

Prestandamål: P95-latens <100 ms, P99 <500 ms, 99,9 % uppetid med <0,1 % felhastighet.

Cachelagringsstrategier

Svars-cachelagring

Lokal cache
// Respektera Cache-Control-huvuden
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-ogiltigförklaring

Valackumuleringsdata: 5 minuters TTL
Finansieringsräntor: 1 minuts TTL
OHLCV-data: 1 timmes TTL
Historisk data: 24 timmars TTL

Live funding och open interest — gratis API

Funding, open interest och long/short-kvoter för de börser vi täcker, live i vår screener.

Se live funding →

Anslutningspoolning

HTTP-anslutningsåteranvändning

Anslutningspool
// Node.js HTTP Agent med poolning
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
});
// Använd agenter i förfrågningar
fetch(url, { agent: httpsAgent });

Anslutningsinställningar

Parameter	Rekommenderat	Motivering
maxSockets	50-100	Balansera samtidighet med resursanvändning
maxFreeSockets	10-20	Behåll inaktiva anslutningar för återanvändning
keepAliveTimeout	60000ms	Matcha server-timeout

Batchoperationer

Kombinera förfrågningar

Batchfråga
// Istället för flera förfrågningar
// GET /whales?asset=BTC
// GET /whales?asset=ETH
// GET /whales?asset=SOL
// Använd en batchförfrågan
GET /v1/whales?asset=BTC,ETH,SOL
// ~200ms sparad jämfört med 3 sekventiella förfrågningar

Batchgränser

Max antal symboler per förfrågan: 100
Max tidsintervall: 365 dagar
Max resultat: 10 000 rader

Frågeoptimering

Specificera fält — Begär endast nödvändiga fält
Använd filter — Minska svarsstorleken med filter
Paginering — Använd limit-parameter, inte offset
Tidsramar — Begär endast data du behöver

Optimerad fråga
// Mindre effektiv: Mycket data
GET /v1/whales?lookback=90d&limit=10000
// Mer effektiv: Specifik data
GET /v1/whales?
  asset=BTC&
  metric=accumulation&
  lookback=7d&
  limit=100

Svarskomprimering

Gzip-komprimering

Förfrågningskomprimering
// Aktivera komprimering i förfrågningar
fetch(url, {
  headers: {
    'Accept-Encoding': 'gzip, deflate'
  }
});
// API komprimerar automatiskt om det stöds
// Typisk komprimering: 70-80% storleksminskning

Komprimeringsbesparingar

Datatyp	Okomprimerad	Komprimerad	Besparingar
JSON-svar	500KB	85KB	83%
Stora tabeller	2MB	350KB	82%

Async/Parallel-mönster

Samtidiga förfrågningar

Parallella förfrågningar
// Ineffektivt: Sekventiellt
const btc = await fetch('/whales/BTC');
const eth = await fetch('/whales/ETH');
const sol = await fetch('/whales/SOL');
// Total tid: ~300ms
// Effektivt: Parallellt
const [btc, eth, sol] = await Promise.all([
  fetch('/whales/BTC'),
  fetch('/whales/ETH'),
  fetch('/whales/SOL')
]);
// Total tid: ~100ms (3x snabbare!)

Prestandamått

Nyckelmått

Mått	Mål	Mätning
P50-latens	<50ms	Median svartid
P95-latens	<100ms	95:e percentilen
P99-latens	<500ms	99:e percentilen
Genomströmning	>1000 req/s	Förfrågningar per sekund

Prestandaövervakning

Prestandaövervakning
// Spåra svartid
const start = performance.now();
const response = await fetch(url);
const duration = performance.now() - start;
// Logga för analys
console.log(`Förfrågan tog ${duration}ms`);

Prestandatestning

Belastningstestning

Testa din integration för att identifiera flaskhalsar:

Verktyg: Apache Bench, wrk eller Locust
Testa med realistiska samtidighetsnivåer
Mät latensfördelning, inte bara genomsnitt
Testa med varm och kall cache

Optimeringsrekommendationer

Snabba vinster

Aktivera HTTP-anslutningspool (1-5x förbättring)
Implementera lokal cachelagring (10-50x för upprepade förfrågningar)
Använd batchoperationer (2-5x minskning i förfrågningar)
Aktivera gzip-komprimering (3-5x bandbreddsreducering)

Avancerade optimeringar

Implementera CDN-cachelagring för historisk data
Använd databasanslutningspooler för lokal cachelagring
Implementera kretsbrytarmönster
Använd strömmande svar för stora datamängder

Uppnå maximal prestanda

Smart Money API är byggd för hastighet. Implementera dessa optimeringsstrategier för under 100ms latens och maximal genomströmning.

Visa prestandanivåer

Pro- och Enterprise-planer inkluderar avancerad cachelagring och prestandafunktioner.