Daftar Isi

Ikhtisar Strategi Caching Connection Pooling Operasi Batch Optimasi Kueri Kompresi Pola Async Metrik Performa Benchmarking Rekomendasi Optimasi

Dokumentasi API

Optimasi Performa API dan Pengurangan Latensi

Capai waktu respons di bawah 100ms dengan Smart Money API. Kuasai caching, connection pooling, operasi batch, dan optimasi kueri untuk throughput maksimal.

Diterbitkan 21 Maret 2026 • 17 menit baca • Performa

Ikhtisar Performa

Smart Money API dioptimalkan untuk latensi rendah dan throughput tinggi. Raih performa maksimal dengan menerapkan pola yang direkomendasikan di sisi integrasi Anda.

Lapisan optimasi performa:

Caching — Caching lokal dan CDN mengurangi permintaan ke origin
Connection Pooling — Gunakan kembali koneksi, kurangi overhead
Operasi Batch — Gabungkan beberapa permintaan menjadi satu
Optimasi Kueri — Minta hanya data yang diperlukan
Async/Paralel — Proses beberapa permintaan secara bersamaan

Target Performa: Latensi P95 <100ms, P99 <500ms, uptime 99.9% dengan tingkat error <0.1%.

Strategi Caching

Caching Respons

Cache Lokal
// Hormati 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;
}

Pembatalan Cache

Data akumulasi whale: TTL 5 menit
Funding rates: TTL 1 menit
Data OHLCV: TTL 1 jam
Data historis: TTL 24 jam

Dapatkan kunci API dalam 30 detik

Siap membangun? Ambil kunci API gratis (100 panggilan/hari, tanpa kartu) dan mulai menarik data whale, funding, dan on-chain langsung.

Dapatkan kunci API →

Connection Pooling

Penggunaan Kembali Koneksi HTTP

Pool Koneksi
// HTTP Agent Node.js dengan 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
});
// Gunakan agent dalam permintaan
fetch(url, { agent: httpsAgent });

Pengaturan Koneksi

Parameter	Rekomendasi	Alasan
maxSockets	50-100	Seimbangkan konkurensi dengan penggunaan sumber daya
maxFreeSockets	10-20	Pertahankan koneksi idle untuk digunakan kembali
keepAliveTimeout	60000ms	Sesuaikan dengan timeout server

Operasi Batch

Menggabungkan Permintaan

Kueri Batch
// Alih-alih beberapa permintaan
// GET /whales?asset=BTC
// GET /whales?asset=ETH
// GET /whales?asset=SOL
// Gunakan satu permintaan batch
GET /v1/whales?asset=BTC,ETH,SOL
// ~200ms lebih hemat dibanding 3 permintaan berurutan

Batas Batch

Maks simbol per permintaan: 100
Maks rentang waktu: 365 hari
Maks hasil: 10.000 baris

Optimasi Kueri

Optimasi Permintaan

Tentukan field — Minta hanya field yang diperlukan
Gunakan filter — Kurangi ukuran respons dengan filter
Paginasi — Gunakan parameter limit, bukan offset
Rentang Waktu — Minta hanya data yang Anda butuhkan

Kueri yang Dioptimasi
// Kurang efisien: Banyak data
GET /v1/whales?lookback=90d&limit=10000
// Lebih efisien: Data spesifik
GET /v1/whales?
  asset=BTC&
  metric=accumulation&
  lookback=7d&
  limit=100

Kompresi Respons

Kompresi Gzip

Permintaan Kompresi
// Aktifkan kompresi dalam permintaan
fetch(url, {
  headers: {
    'Accept-Encoding': 'gzip, deflate'
  }
});
// API secara otomatis mengompresi jika didukung
// Kompresi tipikal: pengurangan ukuran 70-80%

Penghematan Kompresi

Tipe Data	Tidak Terkompresi	Terkompresi	Penghematan
Respons JSON	500KB	85KB	83%
Tabel Besar	2MB	350KB	82%

Pola Async/Parallel

Permintaan Bersamaan

Permintaan Paralel
// Tidak Efisien: Berurutan
const btc = await fetch('/whales/BTC');
const eth = await fetch('/whales/ETH');
const sol = await fetch('/whales/SOL');
// Total waktu: ~300ms
// Efisien: Paralel
const [btc, eth, sol] = await Promise.all([
  fetch('/whales/BTC'),
  fetch('/whales/ETH'),
  fetch('/whales/SOL')
]);
// Total waktu: ~100ms (3x lebih cepat!)

Metrik Kinerja

Metrik Utama

Metrik	Target	Pengukuran
Latensi P50	<50ms	Waktu respons median
Latensi P95	<100ms	Persentil ke-95
Latensi P99	<500ms	Persentil ke-99
Throughput	>1000 req/s	Permintaan per detik

Memantau Kinerja

Pemantauan Kinerja
// Lacak waktu respons
const start = performance.now();
const response = await fetch(url);
const duration = performance.now() - start;
// Catat untuk analisis
console.log(`Permintaan memakan waktu ${duration}ms`);

Benchmarking

Pengujian Beban

Benchmark integrasi Anda untuk mengidentifikasi hambatan:

Alat: Apache Bench, wrk, atau Locust
Uji dengan tingkat konkurensi yang realistis
Ukur distribusi latensi, bukan hanya rata-rata
Uji dengan cache hangat dan dingin

Rekomendasi Optimasi

Kemenangan Cepat

Aktifkan koneksi HTTP pooling (peningkatan 1-5x)
Terapkan caching lokal (10-50x untuk permintaan berulang)
Gunakan operasi batch (pengurangan permintaan 2-5x)
Aktifkan kompresi gzip (pengurangan bandwidth 3-5x)

Optimasi Lanjutan

Terapkan caching CDN untuk data historis
Gunakan koneksi database pooling untuk caching lokal
Terapkan pola circuit breaker
Gunakan respons streaming untuk dataset besar

Capai Kinerja Maksimal

Smart Money API dibangun untuk kecepatan. Terapkan strategi optimasi ini untuk latensi di bawah 100ms dan throughput maksimal.

Lihat Tingkat Kinerja

Paket Pro dan Enterprise mencakup fitur caching dan kinerja lanjutan.