Table of Contents

Overview Caching Strategies Connection Pooling Batch Operations Query Optimization Compression Async Patterns Performance Metrics Benchmarking Optimization Recommendations

API Documentation

API Performance Optimization and Latency Reduction

Achieve sub-100ms response times with Smart Money API. Master caching, connection pooling, batch operations, and query optimization for maximum throughput.

Published March 21, 2026 • 17 min read • Performance

Performance Overview

Smart Money API is optimized for low latency and high throughput. Achieve maximum performance by implementing recommended patterns on your integration side.

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 automatically compresses if supported
// Typical compression: 70-80% size reduction

Compression Savings

Data Type	Uncompressed	Compressed	Savings
JSON responses	500KB	85KB	83%
Large tables	2MB	350KB	82%

Async/Parallel Patterns

Concurrent Requests

Parallel Requests
// Inefficient: Sequential
const btc = await fetch('/whales/BTC');
const eth = await fetch('/whales/ETH');
const sol = await fetch('/whales/SOL');
// Total time: ~300ms
// Efficient: Parallel
const [btc, eth, sol] = await Promise.all([
  fetch('/whales/BTC'),
  fetch('/whales/ETH'),
  fetch('/whales/SOL')
]);
// Total time: ~100ms (3x faster!)

Performance Metrics

Key Metrics

Metric	Target	Measurement
P50 Latency	<50ms	Median response time
P95 Latency	<100ms	95th percentile
P99 Latency	<500ms	99th percentile
Throughput	>1000 req/s	Requests per second

Monitoring Performance

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.