Cuprins

Prezentare generală Strategii de Caching Pool de Conexiuni Operațiuni Batch Optimizare Interogări Compresie Modele Async Metrici de Performanță Benchmarking Recomandări de Optimizare

Documentație API

Optimizare Performanță API și Reducere Latență

Obțineți timpi de răspuns sub 100ms cu Smart Money API. Stăpâniți caching-ul, pool-ul de conexiuni, operațiunile batch și optimizarea interogărilor pentru debit maxim.

Publicat pe 21 martie 2026 • 17 min de citit • Performanță

Prezentare generală Performanță

Smart Money API este optimizat pentru latență redusă și debit ridicat. Obțineți performanță maximă implementând modelele recomandate în integrarea dumneavoastră.

Straturi de optimizare performanță:

Caching — Caching local și CDN reduce cererile către origine
Pool de Conexiuni — Reutilizați conexiuni, reduceți overhead
Operațiuni Batch — Combinați mai multe cereri într-una singură
Optimizare Interogări — Solicitați doar datele necesare
Async/Paralel — Procesați mai multe cereri concurent

Țintă Performanță: Latență P95 <100ms, P99 <500ms, uptime 99.9% cu rată de eroare <0.1%.

Strategii de Caching

Caching Răspunsuri

Cache Local
// Respectă headerele Cache-Control
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;
}

Invalidare Cache

Date acumulare balene: TTL 5 minute
Rate de funding: TTL 1 minut
Date OHLCV: TTL 1 oră
Date istorice: TTL 24 ore

Obține cheia API în 30 secunde

Gata să construiești? Obține o cheie API gratuită (200 apeluri/zi, fără card) și începe să extragi date live despre balene, funding și on-chain.

Obține cheia API →

Pool de Conexiuni

Reutilizare Conexiuni HTTP

Pool de Conexiuni
// Agent HTTP Node.js cu pool
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
});
// Folosește agenți în cereri
fetch(url, { agent: httpsAgent });

Setări Conexiuni

Parametru	Recomandat	Rațiune
maxSockets	50-100	Echilibrează concurența cu utilizarea resurselor
maxFreeSockets	10-20	Păstrează conexiuni inactive pentru reutilizare
keepAliveTimeout	60000ms	Potrivește timeout server

Operațiuni Batch

Combinare Cereri

Interogare Batch
// În loc de mai multe cereri
// GET /whales?asset=BTC
// GET /whales?asset=ETH
// GET /whales?asset=SOL
// Folosește o singură cerere batch
GET /v1/whales?asset=BTC,ETH,SOL
// ~200ms economisiți vs 3 cereri secvențiale

Limitări Batch

Max simboluri/cerere: 100
Max interval timp: 365 zile
Max rezultate: 10.000 rânduri

Optimizare Interogări

Optimizare Cereri

Specifică câmpuri — Solicită doar câmpurile necesare
Folosește filtre — Reduce dimensiunea răspunsului cu filtre
Paginare — Folosește parametrul limit, nu offset
Intervale de timp — Solicită doar datele de care ai nevoie

Interogare Optimizată
// Mai puțin eficient: Multă date
GET /v1/whales?lookback=90d&limit=10000
// Mai eficient: Date specifice
GET /v1/whales?
  asset=BTC&
  metric=accumulation&
  lookback=7d&
  limit=100

Compresie Răspuns

Compresie Gzip

Cerere Compresie
// Activează compresia în cereri
fetch(url, {
  headers: {
    'Accept-Encoding': 'gzip, deflate'
  }
});
// API comprimă automat dacă este suportat
// Compresie tipică: reducere de 70-80% în dimensiune

Economii prin compresie

Tip de date	Necomprimat	Comprimat	Economii
Răspunsuri JSON	500KB	85KB	83%
Tabele mari	2MB	350KB	82%

Modele Async/Paralele

Cereri concurente

Cereri paralele
// Ineficient: Secvențial
const btc = await fetch('/whales/BTC');
const eth = await fetch('/whales/ETH');
const sol = await fetch('/whales/SOL');
// Timp total: ~300ms
// Eficient: Paralel
const [btc, eth, sol] = await Promise.all([
  fetch('/whales/BTC'),
  fetch('/whales/ETH'),
  fetch('/whales/SOL')
]);
// Timp total: ~100ms (de 3 ori mai rapid!)

Metrici de performanță

Metrici cheie

Metrică	Țintă	Măsurătoare
Latență P50	<50ms	Timp mediu de răspuns
Latență P95	<100ms	Percentila a 95-a
Latență P99	<500ms	Percentila a 99-a
Debit	>1000 req/s	Cereri pe secundă

Monitorizarea performanței

Monitorizare performanță
// Urmărește timpul de răspuns
const start = performance.now();
const response = await fetch(url);
const duration = performance.now() - start;
// Loghează pentru analiză
console.log(`Cererea a durat ${duration}ms`);

Testare de performanță

Testare de încărcare

Testează integrarea pentru a identifica punctele slabe:

Unealtă: Apache Bench, wrk sau Locust
Testează cu niveluri realiste de concurență
Măsoară distribuția latenței, nu doar media
Testează cu cache încălzit și rece

Recomandări de optimizare

Câștiguri rapide

Activează pooling de conexiuni HTTP (îmbunătățire de 1-5x)
Implementează caching local (10-50x pentru cereri repetate)
Folosește operații batch (reducere de 2-5x în cereri)
Activează compresia gzip (reducere de 3-5x a lățimii de bandă)

Optimizări avansate

Implementează caching CDN pentru date istorice
Folosește pool-uri de conexiuni la baze de date pentru caching local
Implementează modelul circuit breaker
Folosește răspunsuri streaming pentru seturi mari de date

Obține performanță maximă

Smart Money API este construit pentru viteză. Implementează aceste strategii de optimizare pentru latență sub 100ms și debit maxim.

Vezi nivelurile de performanță

Planurile Pro și Enterprise includ funcții avansate de caching și performanță.