မာတိကာ

အခြေခံအကျဉ်း Caching Strategies Connection Pooling Batch Operations Query Optimization Compression Async Patterns Performance Metrics Benchmarking Optimization Recommendations

API Documentation

API Performance Optimization and Latency Reduction

Smart Money API ဖြင့် sub-100ms တုံ့ပြန်မှုအချိန်များရရှိပါ။ အများဆုံးစီးဆင်းမှုအတွက် caching၊ connection pooling၊ batch operations နှင့် query optimization တို့ကိုကျွမ်းကျင်စွာအသုံးပြုပါ။

မတ်လ ၂၁၊ ၂၀၂၆ တွင်ထုတ်ဝေသည် • ၁၇ မိနစ်ဖတ်ရန် • Performance

Performance Overview

Smart Money API ကို နိမ့်သော latency နှင့် အမြင့်ဆုံး throughput အတွက် အကောင်းဆုံးဖြစ်အောင် ပြင်ဆင်ထားပါသည်။ သင့်ရဲ့ပေါင်းစပ်မှုဘက်တွင် အကြံပြုထားသော pattern များကို အကောင်အထည်ဖော်ခြင်းဖြင့် အများဆုံးစွမ်းဆောင်ရည်ကို ရရှိပါ။

Performance optimization layers:

Caching — Local and CDN caching reduces origin requests
Connection Pooling — Reuse connections, reduce overhead
Batch Operations — Combine multiple requests into one
Query Optimization — Request only needed data
Async/Parallel — Process multiple requests concurrently

Performance Target: P95 latency <100ms, P99 <500ms, 99.9% uptime with <0.1% error rate.

Caching Strategies

Response Caching

Local Cache
// Respect Cache-Control headers
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;
}

Cache Invalidation

Whale accumulation data: 5 minute TTL
Funding rates: 1 minute TTL
OHLCV data: 1 hour TTL
Historical data: 24 hour TTL

Get your API key in 30 seconds

Ready to build? Grab a free API key (200 calls/day, no card) and start pulling live whale, funding and on-chain data.

Get your API key →

Connection Pooling

HTTP Connection Reuse

Connection Pool
// Node.js HTTP Agent with 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
});
// Use agents in requests
fetch(url, { agent: httpsAgent });

Connection Settings

Parameter	Recommended	Rationale
maxSockets	50-100	Balance concurrency with resource usage
maxFreeSockets	10-20	Keep idle connections for reuse
keepAliveTimeout	60000ms	Match server timeout

Batch Operations

Combining Requests

Batch Query
// Instead of multiple requests
// GET /whales?asset=BTC
// GET /whales?asset=ETH
// GET /whales?asset=SOL
// Use one batch request
GET /v1/whales?asset=BTC,ETH,SOL
// ~200ms saved vs 3 sequential requests

Batch Limits

Max symbols per request: 100
Max time range: 365 days
Max results: 10,000 rows

Query Optimization

Request Optimization

Specify fields — Only request needed fields
Use filters — Reduce response size with filters
Pagination — Use limit parameter, not offset
Timeframes — Request only data you need

Optimized Query
// Less efficient: Lots of data
GET /v1/whales?lookback=90d&limit=10000
// More efficient: Specific data
GET /v1/whales?
  asset=BTC&
  metric=accumulation&
  lookback=7d&
  limit=100

Response Compression

Gzip Compression

Request Compression
// Enable compression in requests
fetch(url, {
  headers: {
    'Accept-Encoding': 'gzip, deflate'
  }
});
// API က အထောက်အပံ့ရှိပါက အလိုအလျောက် ဖိသိပ်ပေးသည်
// ပုံမှန်ဖိသိပ်မှု- အရွယ်အစား ၇၀-၈၀% လျော့ကျ

ဖိသိပ်ခြင်းကြောင့် ချွေတာနိုင်မှု

ဒေတာအမျိုးအစား	ဖိသိပ်မထားသော	ဖိသိပ်ထားသော	ချွေတာမှု
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 (၃ ဆ မြန်သည်!)

စွမ်းဆောင်ရည် တိုင်းတာမှုများ

အဓိက တိုင်းတာမှုများ

တိုင်းတာမှု	ပစ်မှတ်	တိုင်းတာချက်
P50 Latency	<50ms	ပျမ်းမျှ တုံ့ပြန်ချိန်
P95 Latency	<100ms	95th percentile
P99 Latency	<500ms	99th percentile
Throughput	>1000 req/s	တစ်စက္ကန့်လျှင် တောင်းဆိုမှုအရေအတွက်

စွမ်းဆောင်ရည် စောင့်ကြည့်ခြင်း

Performance Monitoring
// Track response time
const start = performance.now();
const response = await fetch(url);
const duration = performance.now() - start;
// Log for analysis
console.log(`Request took ${duration}ms`);

Benchmarking

Load Testing

Benchmark your integration to identify bottlenecks:

Tool: Apache Bench, wrk, or Locust
Test with realistic concurrency levels
Measure latency distribution, not just average
Test with cache warm and cold

Optimization Recommendations

Quick Wins

Enable HTTP connection pooling (1-5x improvement)
Implement local caching (10-50x for repeated requests)
Use batch operations (2-5x reduction in requests)
Enable gzip compression (3-5x bandwidth reduction)

Advanced Optimizations

Implement CDN caching for historical data
Use database connection pools for local caching
Implement circuit breaker pattern
Use streaming responses for large datasets

Achieve Maximum Performance

Smart Money API is built for speed. Implement these optimization strategies for sub-100ms latency and maximum throughput.

View Performance Tiers

Pro and Enterprise plans include advanced caching and performance features.