Indice dei contenuti

Panoramica Strategie di caching Pool di connessioni Operazioni in batch Ottimizzazione delle query Compressione Pattern asincroni Metriche di prestazione Benchmarking Raccomandazioni per l'ottimizzazione

Documentazione API

Ottimizzazione delle prestazioni API e riduzione della latenza

Ottieni tempi di risposta inferiori a 100ms con Smart Money API. Padroneggia il caching, il pool di connessioni, le operazioni in batch e l'ottimizzazione delle query per ottenere la massima velocità.

Pubblicato il 21 marzo 2026 • 17 min di lettura • Prestazioni

Panoramica delle prestazioni

Smart Money API è ottimizzato per bassa latenza e alta velocità. Ottieni le massime prestazioni implementando i pattern raccomandati sul tuo lato di integrazione.

Livelli di ottimizzazione delle prestazioni:

Caching — Il caching locale e CDN riduce le richieste all'origine
Pool di connessioni — Riutilizza le connessioni, riduci il sovraccarico
Operazioni in batch — Combina più richieste in una
Ottimizzazione delle query — Richiedi solo i dati necessari
Async/Parallelo — Elabora più richieste contemporaneamente

Obiettivo di prestazione: Latenza P95 <100ms, P99 <500ms, uptime del 99.9% con tasso di errore <0.1%.

Strategie di caching

Caching delle risposte

Cache locale
// Rispetta gli header 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;
}

Invalidazione della cache

Dati di accumulo whale: TTL 5 minuti
Tassi di funding: TTL 1 minuto
Dati OHLCV: TTL 1 ora
Dati storici: TTL 24 ore

Ottieni la tua API key in 30 secondi

Pronto a sviluppare? Ottieni una API key gratuita (200 chiamate/giorno, nessuna carta) e inizia a recuperare dati live su whale, funding e on-chain.

Ottieni la tua API key →

Pool di connessioni

Riutilizzo connessioni HTTP

Pool di connessioni
// HTTP Agent di Node.js con 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
});
// Usa gli agent nelle richieste
fetch(url, { agent: httpsAgent });

Impostazioni connessione

Parametro	Consigliato	Motivazione
maxSockets	50-100	Bilancia concorrenza con uso risorse
maxFreeSockets	10-20	Mantieni connessioni inattive per riutilizzo
keepAliveTimeout	60000ms	Allinea timeout server

Operazioni in batch

Combinazione richieste

Query in batch
// Invece di più richieste
// GET /whales?asset=BTC
// GET /whales?asset=ETH
// GET /whales?asset=SOL
// Usa una richiesta batch
GET /v1/whales?asset=BTC,ETH,SOL
// ~200ms risparmiati vs 3 richieste sequenziali

Limiti batch

Max simboli per richiesta: 100
Max intervallo temporale: 365 giorni
Max risultati: 10,000 righe

Ottimizzazione delle query

Ottimizzazione richieste

Specifica campi — Richiedi solo i campi necessari
Usa filtri — Riduci dimensione risposta con filtri
Paginazione — Usa parametro limit, non offset
Intervalli temporali — Richiedi solo i dati che ti servono

Query ottimizzata
// Meno efficiente: Troppi dati
GET /v1/whales?lookback=90d&limit=10000
// Più efficiente: Dati specifici
GET /v1/whales?
  asset=BTC&
  metric=accumulation&
  lookback=7d&
  limit=100

Compressione risposte

Compressione Gzip

Richiedi compressione
// Abilita compressione nelle richieste
fetch(url, {
  headers: {
    'Accept-Encoding': 'gzip, deflate'
  }
});
// L'API comprime automaticamente se supportato
// Compressione tipica: riduzione del 70-80% delle dimensioni

Risparmio di Compressione

Tipo di Dati	Non compresso	Compresso	Risparmi
Risposte JSON	500KB	85KB	83%
Tabelle grandi	2MB	350KB	82%

Pattern Async/Paralleli

Richieste Concorrenti

Richieste Parallele
// Inefficiente: Sequenziale
const btc = await fetch('/whales/BTC');
const eth = await fetch('/whales/ETH');
const sol = await fetch('/whales/SOL');
// Tempo totale: ~300ms
// Efficiente: Parallelo
const [btc, eth, sol] = await Promise.all([
  fetch('/whales/BTC'),
  fetch('/whales/ETH'),
  fetch('/whales/SOL')
]);
// Tempo totale: ~100ms (3x più veloce!)

Metriche di Performance

Metriche Chiave

Metrica	Obiettivo	Misurazione
Latenza P50	<50ms	Tempo di risposta mediano
Latenza P95	<100ms	95° percentile
Latenza P99	<500ms	99° percentile
Throughput	>1000 req/s	Richieste al secondo

Monitoraggio delle Performance

Monitoraggio delle Performance
// Traccia il tempo di risposta
const start = performance.now();
const response = await fetch(url);
const duration = performance.now() - start;
// Registra per l'analisi
console.log(`La richiesta ha impiegato ${duration}ms`);

Benchmarking

Test di Carico

Esegui il benchmark della tua integrazione per identificare i colli di bottiglia:

Strumento: Apache Bench, wrk o Locust
Testa con livelli di concorrenza realistici
Misura la distribuzione della latenza, non solo la media
Testa con cache calda e fredda

Raccomandazioni per l'Ottimizzazione

Vittorie Rapide

Abilita il connection pooling HTTP (miglioramento di 1-5x)
Implementa la cache locale (10-50x per richieste ripetute)
Usa operazioni batch (riduzione di 2-5x delle richieste)
Abilita la compressione gzip (riduzione di 3-5x della banda)

Ottimizzazioni Avanzate

Implementa la cache CDN per dati storici
Usa pool di connessioni al database per la cache locale
Implementa il pattern circuit breaker
Usa risposte in streaming per dataset grandi

Ottieni la Massima Performance

Smart Money API è costruita per la velocità. Implementa queste strategie di ottimizzazione per una latenza inferiore a 100ms e il massimo throughput.

Visualizza i Livelli di Performance

I piani Pro ed Enterprise includono funzionalità avanzate di caching e performance.