Tartalomjegyzék

Áttekintés Gyorsítótárazási stratégiák Kapcsolatkészlet (Connection Pooling) Kötegelt műveletek Lekérdezésoptimalizálás Tömörítés Aszinkron minták Teljesítménymetrikák Teljesítménytesztelés Optimalizálási javaslatok

API dokumentáció

API teljesítményoptimalizálás és késleltetés csökkentése

Érj el 100 ms alatti válaszidőt a Smart Money API-val. Elsajátíthatod a gyorsítótárazást, kapcsolatkészletet, kötegelt műveleteket és lekérdezésoptimalizálást a maximális átviteli sebesség érdekében.

Közzétéve: 2026. március 21. • 17 perc olvasás • Teljesítmény

Teljesítmény áttekintése

A Smart Money API alacsony késleltetésre és nagy átviteli sebességre van optimalizálva. A maximális teljesítmény eléréséhez implementáld az ajánlott mintákat az integrációs oldalon.

Teljesítményoptimalizálási rétegek:

Gyorsítótárazás — A helyi és CDN gyorsítótár csökkenti az eredeti kéréseket
Kapcsolatkészlet — Kapcsolatok újrafelhasználása, terhelés csökkentése
Kötegelt műveletek — Több kérés összevonása egybe
Lekérdezésoptimalizálás — Csak a szükséges adatok lekérése
Aszinkron/párhuzamos feldolgozás — Több kérés egyidejű feldolgozása

Teljesítménycél: P95 késleltetés <100 ms, P99 <500 ms, 99,9% üzemidő <0,1% hibaráta mellett.

Gyorsítótárazási stratégiák

Válasz gyorsítótárazása

Helyi gyorsítótár
// Tiszteld a Cache-Control fejléceket
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;
}

Gyorsítótár érvénytelenítés

Bálna felhalmozási adatok: 5 perces TTL
Finanszírozási ráta: 1 perces TTL
OHLCV adatok: 1 órás TTL
Történelmi adatok: 24 órás TTL

Élő funding és open interest — ingyenes API

Az általunk lefedett tőzsdék fundingja, open interestje és long/short aránya élőben a screenerünkben.

Élő funding megtekintése →

Kapcsolatkészlet (Connection Pooling)

HTTP kapcsolat újrafelhasználása

Kapcsolatkészlet
// Node.js HTTP Agent készlettel
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
});
// Agensek használata kérésekben
fetch(url, { agent: httpsAgent });

Kapcsolat beállítások

Paraméter	Ajánlott	Indoklás
maxSockets	50-100	Egyensúly a párhuzamosság és erőforrás-használat között
maxFreeSockets	10-20	Üresjárati kapcsolatok megtartása újrafelhasználáshoz
keepAliveTimeout	60000ms	Szerver időtúllépésének megfelelően

Kötegelt műveletek

Kérések összevonása

Kötegelt lekérdezés
// Több kérés helyett
// GET /whales?asset=BTC
// GET /whales?asset=ETH
// GET /whales?asset=SOL
// Használj egy kötegelt kérést
GET /v1/whales?asset=BTC,ETH,SOL
// ~200 ms megtakarítás 3 egymás utáni kéréshez képest

Kötegelt korlátok

Maximális szimbólum/kérés: 100
Maximális időtartam: 365 nap
Maximális eredmény: 10 000 sor

Lekérdezésoptimalizálás

Kérésoptimalizálás

Mezők meghatározása — Csak a szükséges mezők lekérése
Szűrők használata — Válasz méret csökkentése szűrőkkel
Lapozás — Használd a limit paramétert, ne az offset-et
Időkeretek — Csak a szükséges adatok lekérése

Optimalizált lekérdezés
// Kevésbé hatékony: Sok adat
GET /v1/whales?lookback=90d&limit=10000
// Hatékonyabb: Konkrét adatok
GET /v1/whales?
  asset=BTC&
  metric=accumulation&
  lookback=7d&
  limit=100

Válasz tömörítés

Gzip tömörítés

Kérés tömörítése
// Tömörítés engedélyezése kérésekben
fetch(url, {
  headers: {
    'Accept-Encoding': 'gzip, deflate'
  }
});
// Az API automatikusan tömörít, ha támogatott
// Tipikus tömörítés: 70-80%-os méretcsökkenés

Tömörítési megtakarítások

Adattípus	Tömörítetlen	Tömörített	Megtakarítás
JSON válaszok	500KB	85KB	83%
Nagy táblák	2MB	350KB	82%

Async/Párhuzamos minták

Egyidejű kérések

Párhuzamos kérések
// Hatástalan: Soros
const btc = await fetch('/whales/BTC');
const eth = await fetch('/whales/ETH');
const sol = await fetch('/whales/SOL');
// Teljes idő: ~300ms
// Hatékony: Párhuzamos
const [btc, eth, sol] = await Promise.all([
  fetch('/whales/BTC'),
  fetch('/whales/ETH'),
  fetch('/whales/SOL')
]);
// Teljes idő: ~100ms (3x gyorsabb!)

Teljesítmény metrikák

Kulcsmetrikák

Metrika	Cél	Mérés
P50 Késleltetés	<50ms	Medián válaszidő
P95 Késleltetés	<100ms	95. percentilis
P99 Késleltetés	<500ms	99. percentilis
Átviteli sebesség	>1000 req/s	Kérések másodpercenként

Teljesítmény monitorozása

Teljesítmény monitorozás
// Követse a válaszidőt
const start = performance.now();
const response = await fetch(url);
const duration = performance.now() - start;
// Naplózás elemzéshez
console.log(`A kérés ${duration}ms-ig tartott`);

Teljesítménytesztelés

Terhelés tesztelése

Teszteld az integrációt a szűk keresztmetszetek azonosításához:

Eszköz: Apache Bench, wrk vagy Locust
Tesztelj valós egyidejűségi szinteken
Mérd a késleltetés eloszlását, ne csak az átlagot
Tesztelj meleg és hideg gyorsítótárral

Optimalizációs ajánlások

Gyors győzelmek

Engedélyezd a HTTP kapcsolatkészletet (1-5x javulás)
Implementálj helyi gyorsítótárazást (10-50x ismétlődő kéréseknél)
Használj kötegelt műveleteket (2-5x csökkenés a kérésekben)
Engedélyezd a gzip tömörítést (3-5x sávszélesség csökkenés)

Haladó optimalizációk

Implementálj CDN gyorsítótárazást történelmi adatokhoz
Használj adatbázis kapcsolatkészleteket helyi gyorsítótárazáshoz
Implementálj áramköri megszakító mintát
Használj streamelő válaszokat nagy adathalmazokhoz

Érd el a maximális teljesítményt

A Smart Money API sebességre épül. Implementáld ezeket az optimalizációs stratégiákat a 100ms alatti késleltetés és a maximális átviteli sebesség érdekében.

Tekintsd meg a teljesítmény szinteket

A Pro és Enterprise csomagok tartalmaznak haladó gyorsítótárazási és teljesítményfunkciókat.