ເອກະສານ API

API Performance Optimization and Latency Reduction

ບັນລຸເວລາຕອບສະໜອງຕ່ຳກວ່າ 100ms ດ້ວຍ Smart Money API. ເຈົ້າສາມາດເຂົ້າໃຈການເກັບຂໍ້ມູນໄວ້ໃນຄັງ, ການຈັດກຸ່ມການເຊື່ອມຕໍ່, ການດຳເນີນການເປັນຊຸດ, ແລະ ການປັບປຸງການສອບຖາມເພື່ອຄວາມໄວສູງສຸດ.

ເຜີຍແຜ່ເມື່ອວັນທີ 21 ມີນາ 2026 • 17 ນາທີອ່ານ • ປະສິດທິພາບ

ພາບລວມປະສິດທິພາບ

Smart Money API ຖືກປັບປຸງໃຫ້ເປັນລະບົບທີ່ມີເວລາຕອບສະໜອງຕ່ຳ ແລະ ປະສິດທິພາບສູງ. ບັນລຸປະສິດທິພາບສູງສຸດໂດຍການນຳໃຊ້ຮູບແບບທີ່ແນະນຳໃນການປະສານງານຂອງທ່ານ.

ຊັ້ນການປັບປຸງປະສິດທິພາບ:

  • ການເກັບຂໍ້ມູນໄວ້ໃນຄັງ — ການເກັບຂໍ້ມູນໄວ້ໃນຄັງທ້ອງຖິ່ນ ແລະ CDN ຫຼຸດການຮ້ອງຂໍຈາກແຫຼ່ງຂໍ້ມູນ
  • ການຈັດກຸ່ມການເຊື່ອມຕໍ່ — ນຳໃຊ້ການເຊື່ອມຕໍ່ໃຫ້ຄົງຢູ່, ຫຼຸດພາລະການເຮັດວຽກ
  • ການດຳເນີນການເປັນຊຸດ — ລວມການຮ້ອງຂໍຫຼາຍອັນເປັນອັນດຽວ
  • ການປັບປຸງການສອບຖາມ — ຮ້ອງຂໍເອົາແຕ່ຂໍ້ມູນທີ່ຈຳເປັນ
  • Async/Parallel — ປະມວນຜົນການຮ້ອງຂໍຫຼາຍອັນໃນເວລາດຽວກັນ

ເປົ້າໝາຍປະສິດທິພາບ: P95 latency <100ms, P99 <500ms, 99.9% uptime ດ້ວຍອັດຕາຜິດພາດ <0.1%.

ຍຸດທະສາດການເກັບຂໍ້ມູນໄວ້ໃນຄັງ

ການເກັບຂໍ້ມູນຕອບສະໜອງ

ຄັງທ້ອງຖິ່ນ
// ເຄົາລົບຫົວຂໍ້ 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;
}

ການຍົກເລີກການເກັບຂໍ້ມູນໄວ້ໃນຄັງ

  • ຂໍ້ມູນການສະສົມຂອງ whale: ໄລຍະເວລາ TTL 5 ນາທີ
  • ອັດຕາການສະໜອງທຶນ: ໄລຍະເວລາ TTL 1 ນາທີ
  • ຂໍ້ມູນ OHLCV: ໄລຍະເວລາ TTL 1 ຊົ່ວໂມງ
  • ຂໍ້ມູນປະຫວັດ: ໄລຍະເວລາ TTL 24 ຊົ່ວໂມງ
Funding ແລະ open interest ສົດ — API ຟຣີ

Funding, open interest ແລະ ອັດຕາ long/short ຂອງ exchange ທີ່ພວກເຮົາຄຸມ ສົດໃນ screener ຂອງພວກເຮົາ.

ເບິ່ງ funding ສົດ →

ການຈັດກຸ່ມການເຊື່ອມຕໍ່

ການນຳໃຊ້ການເຊື່ອມຕໍ່ HTTP ຄືນໃໝ່

ກຸ່ມການເຊື່ອມຕໍ່
// Node.js HTTP Agent ທີ່ມີການຈັດກຸ່ມ
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
});
// ນຳໃຊ້ agents ໃນການຮ້ອງຂໍ
fetch(url, { agent: httpsAgent });

ການຕັ້ງຄ່າການເຊື່ອມຕໍ່

ພາຣາມີເຕີ ຄຳແນະນຳ ເຫດຜົນ
maxSockets 50-100 ດຸ່ນດ່ຽງການເຮັດວຽກພ້ອມກັນກັບການໃຊ້ຊັບພະຍາກອນ
maxFreeSockets 10-20 ຮັກສາການເຊື່ອມຕໍ່ທີ່ບໍ່ໄດ້ໃຊ້ໄວ້ສຳລັບການນຳໃຊ້ຄືນ
keepAliveTimeout 60000ms ກົງກັບເວລາລໍຖ້າຂອງເຊີບເວີ

ການດຳເນີນການເປັນຊຸດ

ການລວມການຮ້ອງຂໍ

ການສອບຖາມເປັນຊຸດ
// ແທນທີ່ຈະເປັນການຮ້ອງຂໍຫຼາຍອັນ
// GET /whales?asset=BTC
// GET /whales?asset=ETH
// GET /whales?asset=SOL
// ໃຊ້ການຮ້ອງຂໍເປັນຊຸດດຽວ
GET /v1/whales?asset=BTC,ETH,SOL
// ປະຢັດໄດ້ ~200ms ເມື່ອທຽບກັບການຮ້ອງຂໍ 3 ຄັ້ງຕໍ່ໆກັນ

ຂອບເຂດການດຳເນີນການເປັນຊຸດ

  • ຈຳນວນສັນຍາລັກສູງສຸດຕໍ່ການຮ້ອງຂໍ: 100
  • ໄລຍະເວລາສູງສຸດ: 365 ມື້
  • ຜົນໄດ້ຮັບສູງສຸດ: 10,000 ແຖວ

ການປັບປຸງການສອບຖາມ

ການປັບປຸງການຮ້ອງຂໍ

  • ລະບຸຟິວລ໌ — ຮ້ອງຂໍເອົາແຕ່ຟິວລ໌ທີ່ຈຳເປັນ
  • ໃຊ້ຕົວກັ່ນ — ຫຼຸດຂະໜາດຂໍ້ມູນຕອບສະໜອງດ້ວຍຕົວກັ່ນ
  • ການເລກຫນ້າ — ໃຊ້ພາຣາມີເຕີ limit, ບໍ່ແມ່ນ offset
  • ໄລຍະເວລາ — ຮ້ອງຂໍເອົາແຕ່ຂໍ້ມູນທີ່ທ່ານຕ້ອງການ
ການສອບຖາມທີ່ຖືກປັບປຸງ
// ບໍ່ມີປະສິດທິພາບ: ຂໍ້ມູນຫຼາຍ
GET /v1/whales?lookback=90d&limit=10000
// ມີປະສິດທິພາບຫຼາຍ: ຂໍ້ມູນສະເພາະ
GET /v1/whales?
asset=BTC&
metric=accumulation&
lookback=7d&
limit=100

ການບີບອັດຂໍ້ມູນຕອບສະໜອງ

ການບີບອັດ Gzip

ການຮ້ອງຂໍການບີບອັດ
// ເປີດໃຊ້ການບີບອັດໃນການຮ້ອງຂໍ
fetch(url, {
headers: {
'Accept-Encoding': 'gzip, deflate'
}
});
// API ຈະບີບອັດໂດຍອັດຕະໂນມັດຖ້າສະໜັບສະໜູນ
// ການບີບອັດທົ່ວໄປ: ຫຼຸດຂະໜາດ 70-80%

ການປະຢັດຈາກການບີບອັດ

ປະເພດຂໍ້ມູນ ບໍ່ບີບອັດ ບີບອັດ ການປະຢັດ
ຕອບກັບ JSON 500KB 85KB 83%
ຕາຕະລາງຂະໜາດໃຫຍ່ 2MB 350KB 82%

ຮູບແບບ Async/Parallel

ຄຳຂໍພ້ອມໆກັນ

ຄຳຂໍຂະຫຍາຍ
// ບໍ່ມີປະສິດທິພາບ: ຕາມລຳດັບ
const btc = await fetch('/whales/BTC');
const eth = await fetch('/whales/ETH');
const sol = await fetch('/whales/SOL');
// ເວລາທັງໝົດ: ~300ms
// ມີປະສິດທິພາບ: ຂະຫຍາຍ
const [btc, eth, sol] = await Promise.all([
fetch('/whales/BTC'),
fetch('/whales/ETH'),
fetch('/whales/SOL')
]);
// ເວລາທັງໝົດ: ~100ms (ໄວຂຶ້ນ 3 ເທົ່າ!)

ຕົວຊີ້ວັດປະສິດທິພາບ

ຕົວຊີ້ວັດຫຼັກ

ຕົວຊີ້ວັດ ເປົ້າໝາຍ ການວັດແທກ
P50 Latency <50ms ເວລາຕອບກັບກາງ
P95 Latency <100ms ອັດຕາສ່ວນທີ 95
P99 Latency <500ms ອັດຕາສ່ວນທີ 99
Throughput >1000 req/s ຄຳຂໍຕໍ່ວິນາທີ

ການຕິດຕາມປະສິດທິພາບ

ການຕິດຕາມປະສິດທິພາບ
// ຕິດຕາມເວລາຕອບໂຕ້
const start = performance.now();
const response = await fetch(url);
const duration = performance.now() - start;
// ບັນທຶກເພື່ອວິເຄາະ
console.log(`Request took ${duration}ms`);

ການປຽບທຽບປະສິດທິພາບ

ການທົດສອບພາລະການໂຫຼດ

ປຽບທຽບການປະສານງານຂອງທ່ານເພື່ອຊອກຫາຈຸດອ່ອນ:

  • ເຄື່ອງມື: Apache Bench, wrk, ຫຼື Locust
  • ທົດສອບດ້ວຍລະດັບຄວາມຄຽງທີ່ເປັນຈິງ
  • ວັດແທກການແຈກຢາຍຄວາມຊ້າ, ບໍ່ພຽງແຕ່ຄ່າສະເລ່ຍ
  • ທົດສອບດ້ວຍ cache ອຸ່ນແລະເຢັນ

ຄຳແນະນຳການປັບປຸງ

ຊະນະໄວ

  1. ເປີດໃຊ້ HTTP connection pooling (ປັບປຸງ 1-5x)
  2. ປະຕິບັດ local caching (ປັບປຸງ 10-50x ສຳລັບຄຳຂໍທີ່ຊ້ຳຊ້ອນ)
  3. ໃຊ້ batch operations (ຫຼຸດຄຳຂໍ 2-5x)
  4. ເປີດໃຊ້ gzip compression (ຫຼຸດ bandwidth 3-5x)

ການປັບປຸງຂັ້ນສູງ

  1. ປະຕິບັດ CDN caching ສຳລັບຂໍ້ມູນປະຫວັດ
  2. ໃຊ້ database connection pools ສຳລັບ local caching
  3. ປະຕິບັດ circuit breaker pattern
  4. ໃຊ້ streaming responses ສຳລັບຊຸດຂໍ້ມູນຂະໜາດໃຫຍ່

ບັນລຸປະສິດທິພາບສູງສຸດ

Smart Money API ຖືກສ້າງຂຶ້ນເພື່ອຄວາມໄວ. ປະຕິບັດຍຸດທະສາດການປັບປຸງເຫຼົ່ານີ້ເພື່ອຄວາມຊ້າຕ່ຳກວ່າ 100ms ແລະປະສິດທິພາບສູງສຸດ.

ເບິ່ງລະດັບປະສິດທິພາບ
ແຜນ Pro ແລະ Enterprise ປະກອບມີຄຸນສົມບັດການເກັບຂໍ້ມູນແລະປະສິດທິພາບຂັ້ນສູງ.
ເລີ່ມຟຣີ — 200 ການເອີ້ນຕໍ່ມື້ ບໍ່ຕ້ອງໃຊ້ບັດ

ຮັບ whale flow, funding, open interest ແລະ ຂໍ້ມູນ on-chain ສົດຈາກ API ດຽວ. ຊັ້ນຟຣີ ບໍ່ຕ້ອງໃຊ້ບັດ ອັບເກຣດໄດ້ທຸກເວລາ.

ເລີ່ມຟຣີ →
ລອງໃຊ້ API console ສົດ → (ບໍ່ຕ້ອງມີບັນຊີ)