Documentation de l'API

Optimisation des performances de l'API et réduction de la latence

Atteignez des temps de réponse inférieurs à 100 ms avec Smart Money API. Maîtrisez la mise en cache, le regroupement de connexions, les opérations par lots et l'optimisation des requêtes pour un débit maximal.

Publié le 21 mars 2026 • 17 min de lecture • Performance

Aperçu de la performance

Smart Money API est optimisé pour une faible latence et un haut débit. Atteignez une performance maximale en implémentant les modèles recommandés côté intégration.

Couches d'optimisation des performances :

  • Mise en cache — La mise en cache locale et CDN réduit les requêtes à l'origine
  • Regroupement de connexions — Réutilisez les connexions, réduisez la surcharge
  • Opérations par lots — Combinez plusieurs requêtes en une seule
  • Optimisation des requêtes — Demandez uniquement les données nécessaires
  • Asynchrone/Parallèle — Traitez plusieurs requêtes simultanément

Objectif de performance : Latence P95 <100ms, P99 <500ms, disponibilité de 99,9 % avec un taux d'erreur <0,1 %.

Stratégies de mise en cache

Mise en cache des réponses

Cache local
// Respectez les en-têtes 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;
}

Invalidation du cache

  • Données d'accumulation des baleines : TTL de 5 minutes
  • Taux de financement : TTL de 1 minute
  • Données OHLCV : TTL de 1 heure
  • Données historiques : TTL de 24 heures
Obtenez votre clé API en 30 secondes

Prêt à construire ? Obtenez une clé API gratuite (200 appels/jour, sans carte) et commencez à récupérer des données en direct sur les baleines, le financement et les données on-chain.

Obtenez votre clé API →

Regroupement de connexions

Réutilisation des connexions HTTP

Pool de connexions
// Agent HTTP Node.js avec regroupement
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
});
// Utilisez les agents dans les requêtes
fetch(url, { agent: httpsAgent });

Paramètres de connexion

Paramètre Recommandé Justification
maxSockets 50-100 Équilibrez la concurrence avec l'utilisation des ressources
maxFreeSockets 10-20 Gardez les connexions inactives pour une réutilisation
keepAliveTimeout 60000ms Correspond au délai d'attente du serveur

Opérations par lots

Combinaison des requêtes

Requête par lots
// Au lieu de plusieurs requêtes
// GET /whales?asset=BTC
// GET /whales?asset=ETH
// GET /whales?asset=SOL
// Utilisez une seule requête par lots
GET /v1/whales?asset=BTC,ETH,SOL
// ~200ms économisés par rapport à 3 requêtes séquentielles

Limites des lots

  • Nombre maximal de symboles par requête : 100
  • Plage de temps maximale : 365 jours
  • Nombre maximal de résultats : 10 000 lignes

Optimisation des requêtes

Optimisation des requêtes

  • Spécifiez les champs — Demandez uniquement les champs nécessaires
  • Utilisez des filtres — Réduisez la taille de la réponse avec des filtres
  • Pagination — Utilisez le paramètre limit, pas offset
  • Intervalles de temps — Demandez uniquement les données dont vous avez besoin
Requête optimisée
// Moins efficace : Beaucoup de données
GET /v1/whales?lookback=90d&limit=10000
// Plus efficace : Données spécifiques
GET /v1/whales?
asset=BTC&
metric=accumulation&
lookback=7d&
limit=100

Compression des réponses

Compression Gzip

Compression des requêtes
// Activez la compression dans les requêtes
fetch(url, {
headers: {
'Accept-Encoding': 'gzip, deflate'
}
});
// L'API compresse automatiquement si pris en charge
// Compression typique : réduction de 70 à 80% de la taille

Économies de compression

Type de données Non compressé Compressé Économies
Réponses JSON 500KB 85KB 83%
Grandes tables 2MB 350KB 82%

Modèles Async/Parallèles

Requêtes concurrentes

Requêtes parallèles
// Inefficace : Séquentiel
const btc = await fetch('/whales/BTC');
const eth = await fetch('/whales/ETH');
const sol = await fetch('/whales/SOL');
// Temps total : ~300ms
// Efficace : Parallèle
const [btc, eth, sol] = await Promise.all([
fetch('/whales/BTC'),
fetch('/whales/ETH'),
fetch('/whales/SOL')
]);
// Temps total : ~100ms (3x plus rapide !)

Mesures de performance

Indicateurs clés

Métrique Cible Mesure
Latence P50 <50ms Temps de réponse médian
Latence P95 <100ms 95e percentile
Latence P99 <500ms 99e percentile
Débit >1000 req/s Requêtes par seconde

Surveillance des performances

Surveillance des performances
// Suivre le temps de réponse
const start = performance.now();
const response = await fetch(url);
const duration = performance.now() - start;
// Journaliser pour analyse
console.log(`La requête a pris ${duration}ms`);

Benchmarking

Test de charge

Évaluez votre intégration pour identifier les goulots d'étranglement :

  • Outil : Apache Bench, wrk ou Locust
  • Testez avec des niveaux de concurrence réalistes
  • Mesurez la distribution de latence, pas seulement la moyenne
  • Testez avec cache chaud et froid

Recommandations d'optimisation

Gains rapides

  1. Activez le regroupement de connexions HTTP (amélioration de 1 à 5x)
  2. Implémentez un cache local (10 à 50x pour les requêtes répétées)
  3. Utilisez des opérations par lots (réduction de 2 à 5x des requêtes)
  4. Activez la compression gzip (réduction de 3 à 5x de la bande passante)

Optimisations avancées

  1. Implémentez un cache CDN pour les données historiques
  2. Utilisez des pools de connexions de base de données pour le cache local
  3. Implémentez le modèle de disjoncteur
  4. Utilisez des réponses en streaming pour les grands ensembles de données

Atteignez des performances maximales

Smart Money API est conçue pour la vitesse. Appliquez ces stratégies d'optimisation pour une latence inférieure à 100ms et un débit maximal.

Voir les niveaux de performance
Les plans Pro et Enterprise incluent des fonctionnalités avancées de cache et de performance.

Ressources connexes

Cache des réponses →

Stratégies de cache avancées

Opérations par lots →

Opérations efficaces sur des données en vrac

Surveillance →

Surveillance des performances et alertes
Commencez gratuitement — 200 appels/jour, sans carte

Obtenez des données en direct sur les flux de baleines, le financement, l'intérêt ouvert et les données on-chain sur 3 exchanges via une seule API. Niveau gratuit, sans carte de crédit, mise à niveau à tout moment.

Commencez gratuitement →
Essayez la console API en direct → (aucun compte nécessaire)