Índice

Visão Geral Estratégias de Cache Pool de Conexões Operações em Lote Otimização de Consultas Compactação Padrões Assíncronos Métricas de Desempenho Benchmarking Recomendações de Otimização

Documentação da API

Otimização de Desempenho e Redução de Latência da API

Alcance tempos de resposta abaixo de 100ms com a Smart Money API. Domine cache, pool de conexões, operações em lote e otimização de consultas para máxima taxa de transferência.

Publicado em 21 de março de 2026 • 17 min de leitura • Desempenho

Visão Geral de Desempenho

A Smart Money API é otimizada para baixa latência e alta taxa de transferência. Alcance o máximo desempenho implementando os padrões recomendados no seu lado da integração.

Camadas de otimização de desempenho:

Cache — Cache local e CDN reduz solicitações à origem
Pool de Conexões — Reutilize conexões, reduza sobrecarga
Operações em Lote — Combine múltiplas solicitações em uma
Otimização de Consultas — Solicite apenas os dados necessários
Assíncrono/Paralelo — Processe múltiplas solicitações simultaneamente

Meta de Desempenho: Latência P95 <100ms, P99 <500ms, 99.9% de disponibilidade com taxa de erro <0.1%.

Estratégias de Cache

Cache de Resposta

Cache Local
// Respeite os cabeçalhos 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;
}

Invalidação de Cache

Dados de acumulação de baleias: TTL de 5 minutos
Taxas de funding: TTL de 1 minuto
Dados OHLCV: TTL de 1 hora
Dados históricos: TTL de 24 horas

Funding e open interest ao vivo — API gratuita

Funding, open interest e razões long/short das corretoras que cobrimos, ao vivo em nosso screener.

Ver funding ao vivo →

Pool de Conexões

Reutilização de Conexão HTTP

Pool de Conexões
// Agente HTTP do Node.js com pool
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 agentes em solicitações
fetch(url, { agent: httpsAgent });

Configurações de Conexão

Parâmetro	Recomendado	Razão
maxSockets	50-100	Equilibre concorrência com uso de recursos
maxFreeSockets	10-20	Mantenha conexões ociosas para reutilização
keepAliveTimeout	60000ms	Corresponda ao timeout do servidor

Operações em Lote

Combinação de Solicitações

Consulta em Lote
// Em vez de múltiplas solicitações
// GET /whales?asset=BTC
// GET /whales?asset=ETH
// GET /whales?asset=SOL
// Use uma solicitação em lote
GET /v1/whales?asset=BTC,ETH,SOL
// ~200ms economizados vs 3 solicitações sequenciais

Limites de Lote

Máximo de símbolos por solicitação: 100
Máximo intervalo de tempo: 365 dias
Máximo de resultados: 10.000 linhas

Otimização de Consultas

Otimização de Solicitação

Especifique campos — Solicite apenas os campos necessários
Use filtros — Reduza o tamanho da resposta com filtros
Paginação — Use o parâmetro limit, não offset
Intervalos de Tempo — Solicite apenas os dados que você precisa

Consulta Otimizada
// Menos eficiente: Muitos dados
GET /v1/whales?lookback=90d&limit=10000
// Mais eficiente: Dados específicos
GET /v1/whales?
  asset=BTC&
  metric=accumulation&
  lookback=7d&
  limit=100

Compactação de Resposta

Compactação Gzip

Solicitação de Compactação
// Ative a compactação em solicitações
fetch(url, {
  headers: {
    'Accept-Encoding': 'gzip, deflate'
  }
});
// API comprime automaticamente se suportado
// Redução típica de tamanho: 70-80%

Economias de Compressão

Tipo de Dados	Não Comprimido	Comprimido	Economias
Respostas JSON	500KB	85KB	83%
Tabelas Grandes	2MB	350KB	82%

Padrões Assíncronos/Paralelos

Requisições Concorrentes

Requisições Paralelas
// Ineficiente: Sequencial
const btc = await fetch('/whales/BTC');
const eth = await fetch('/whales/ETH');
const sol = await fetch('/whales/SOL');
// Tempo total: ~300ms
// Eficiente: Paralelo
const [btc, eth, sol] = await Promise.all([
  fetch('/whales/BTC'),
  fetch('/whales/ETH'),
  fetch('/whales/SOL')
]);
// Tempo total: ~100ms (3x mais rápido!)

Métricas de Desempenho

Métricas Principais

Métrica	Objetivo	Medição
Latência P50	<50ms	Tempo médio de resposta
Latência P95	<100ms	95º percentil
Latência P99	<500ms	99º percentil
Taxa de Transferência	>1000 req/s	Requisições por segundo

Monitoramento de Desempenho

Monitoramento de Desempenho
// Acompanhar tempo de resposta
const start = performance.now();
const response = await fetch(url);
const duration = performance.now() - start;
// Registrar para análise
console.log(`Requisição levou ${duration}ms`);

Testes de Carga

Faça benchmarking da sua integração para identificar gargalos:

Ferramenta: Apache Bench, wrk ou Locust
Teste com níveis realistas de concorrência
Meça a distribuição de latência, não apenas a média
Teste com cache quente e frio

Recomendações de Otimização

Ganhos Rápidos

Ative o pool de conexões HTTP (melhoria de 1-5x)
Implemente cache local (10-50x para requisições repetidas)
Use operações em lote (redução de 2-5x em requisições)
Ative compressão gzip (redução de 3-5x na largura de banda)

Otimizações Avançadas

Implemente cache CDN para dados históricos
Use pools de conexão de banco de dados para cache local
Implemente o padrão circuit breaker
Use respostas em streaming para grandes conjuntos de dados

Alcance o Desempenho Máximo

A Smart Money API foi construída para velocidade. Implemente estas estratégias de otimização para latência abaixo de 100ms e máxima taxa de transferência.

Ver Planos de Desempenho

Planos Pro e Enterprise incluem recursos avançados de cache e desempenho.