Limitação de Taxa e Cotas

Entenda os limites de taxa da Smart Money API, cotas diárias para cada nível de assinatura e estratégias de otimização para maximizar o uso da API.

Visão Geral

A Smart Money API implementa cotas de requisições diárias para garantir qualidade de serviço e justiça para todos os usuários. Cada nível de assinatura inclui um limite diário diferente. Quando você excede sua cota diária, recebe um erro 429 Too Many Requests até que sua cota seja redefinida à meia-noite UTC.

Os limites de taxa são aplicados por chave de API. Cada chave tem sua própria cota independente. Você pode gerar várias chaves para diferentes aplicações e monitorar o uso de cada uma separadamente.

Cotas por Nível de Assinatura

Nível	Requisições Diárias	Preço	Recursos
Grátis	20 requisições/dia	$0	BTC, ETH, SOL, taxas de funding, liquidações
Trader	400 requisições/dia	$29/mês	Todos os símbolos, posições de baleias, dados de OI
Pro	4.000 requisições/dia	$79/mês	Pontuações de confirmação, dados on-chain, webhooks
Enterprise	Personalizado	Personalizado	Suporte dedicado, integrações personalizadas

Cabeçalhos de Resposta de Limitação de Taxa

Cada resposta da API inclui cabeçalhos que indicam o status atual da sua cota:

Cabeçalhos HTTP

X-Requests-Limit: 200
X-Requests-Remaining: 147
X-Requests-Reset: 1711116000
X-Requests-Reset-ISO: 2026-03-22T00:00:00Z

Cabeçalho	Descrição
`X-Requests-Limit`	Total de requisições permitidas por dia (ex.: 200 para Trader)
`X-Requests-Remaining`	Requisições restantes no dia atual
`X-Requests-Reset`	Timestamp Unix quando a cota é redefinida
`X-Requests-Reset-ISO`	Timestamp ISO 8601 para redefinição da cota

Verificando a Cota Antes de Fazer Requisições

Python

import requests
from datetime import datetime

def check_quota_before_request(api_key):
    response = requests.head(
        "https://api.smartmoneyapi.com/v1/whales/events",
        headers={"Authorization": f"Bearer {api_key}"}
    )

    limit = int(response.headers.get("X-Requests-Limit", 0))
    remaining = int(response.headers.get("X-Requests-Remaining", 0))
    reset_unix = int(response.headers.get("X-Requests-Reset", 0))

    reset_time = datetime.fromtimestamp(reset_unix)
    percent_used = (limit - remaining) / limit * 100

    print(f"Quota: {remaining}/{limit} requisições ({percent_used:.1f}% usadas)")
    print(f"Redefine às: {reset_time}")

    if remaining < 5:
        print("AVISO: Aproximando-se do limite da cota!")
        return False

    return True

# Verifique antes de fazer requisições
if check_quota_before_request("sk_live_abc123xyz789"):
    print("Seguro para prosseguir com chamadas à API")

Janela de Taxa Diária

Os limites de taxa operam em uma janela contínua de 24 horas. Sua cota é redefinida diariamente à meia-noite UTC (00:00 UTC). O horário exato de redefinição é fornecido no X-Requests-Reset-ISO cabeçalho.

Exemplo: Nível Trader (400 requisições/dia)

Dia 1 (21 de março): 200 requisições disponíveis às 00:00 UTC
10:30 UTC: Feitas 75 requisições, 125 restantes
15:45 UTC: Feitas mais 100 requisições, 25 restantes
23:59 UTC: Ainda 25 requisições restantes (não podem ser acumuladas)
Dia 2 (22 de março, 00:00 UTC): Cota redefinida para 200

Estratégias de Otimização

1. Armazene em Cache as Respostas da API

As posições das baleias não mudam a cada segundo. Armazene os resultados em cache por 30-60 segundos e sirva os dados em cache em vez de fazer novas chamadas à API.

Python

import requests
import time

class CachedClient:
    def __init__(self, api_key, cache_ttl=60):
        self.api_key = api_key
        self.cache_ttl = cache_ttl
        self.cache = {}
        self.cache_time = {}

    def get_whale_positions(self, symbol):
        cache_key = f"whales:{symbol}"
        now = time.time()

        # Retorna dados em cache se ainda estiverem frescos
        if cache_key in self.cache:
            age = now - self.cache_time[cache_key]
            if age < self.cache_ttl:
                print(f"Servido do cache (idade: {age:.1f}s)")
                return self.cache[cache_key]

        # Busca dados novos
        response = requests.get(
            f"https://api.smartmoneyapi.com/v1/whales/events?symbol={symbol}",
            headers={"Authorization": f"Bearer {self.api_key}"}
        )

        data = response.json()
        self.cache[cache_key] = data
        self.cache_time[cache_key] = now
        return data

# Uso: Cache por 60 segundos
client = CachedClient("sk_live_abc123xyz789", cache_ttl=60)
whales1 = client.get_whale_positions("BTCUSDT")  # Chamada à API
whales2 = client.get_whale_positions("BTCUSDT")  # Do cache
whales3 = client.get_whale_positions("BTCUSDT")  # Do cache

2. Use WebSocket para Dados em Tempo Real

Conexões WebSocket entregam atualizações instantaneamente sem contar contra seu limite de taxa. Inscreva-se em streams e receba atualizações conforme ocorrem, reduzindo o número de chamadas REST API necessárias.

3. Agrupe Requisições Estrategicamente

Faça uma requisição com múltiplos símbolos quando possível, em vez de requisições separadas para cada símbolo. Isso reduz as chamadas à API em até 10x.

4. Use Filtros no Momento da Requisição

Aplique filtros (símbolo, exchange, tamanho mínimo de posição) nos parâmetros da query para obter exatamente os dados que você precisa, evitando a necessidade de pós-processamento.

Como Lidar com Erros de Limite de Taxa

Tente Novamente com Backoff Exponencial

Python

import requests
import time

def request_with_retry(url, api_key, max_retries=5):
    for attempt in range(max_retries):
        try:
            response = requests.get(
                url,
                headers={"Authorization": f"Bearer {api_key}"},
                timeout=10
            )

            if response.status_code == 200:
                return response.json()

            elif response.status_code == 429:
                # Limite de taxa atingido - backoff exponencial
                wait_time = min(2 ** attempt, 300)  # Máximo de 5 minutos
                reset_time = response.headers.get("X-Requests-Reset-ISO")
                print(f"Limite de taxa atingido. Tentando novamente em {wait_time}s (redefine às {reset_time})")
                time.sleep(wait_time)

            elif response.status_code >= 500:
                # Erro de servidor - tente novamente
                wait_time = 2 ** attempt
                print(f"Erro de servidor {response.status_code}. Tentando novamente em {wait_time}s")
                time.sleep(wait_time)
            else:
                # Outro erro - não tente novamente
                raise Exception(f"HTTP {response.status_code}: {response.text}")

        except requests.exceptions.Timeout:
            wait_time = 2 ** attempt
            print(f"Timeout. Tentando novamente em {wait_time}s")
            time.sleep(wait_time)

    raise Exception("Máximo de tentativas excedido")

# Uso
data = request_with_retry(
    "https://api.smartmoneyapi.com/v1/whales/events",
    "sk_live_abc123xyz789"
)
print(data)

Pronto para Atualizar?

O nível gratuito não é suficiente? Atualize para Trader ou Pro para cotas maiores e acesso a recursos avançados como pontuações de confirmação e dados on-chain.

Ver Preços

Otimize Seu Uso da API Hoje

Implemente cache, use WebSocket para dados em tempo real e lide com limites de taxa de forma elegante.

Ler Documentação

Comece grátis — 200 chamadas/dia, sem cartão

Obtenha fluxo de baleias ao vivo, funding, open interest e dados on-chain em 3 exchanges a partir de uma única API. Nível gratuito, sem cartão de crédito, atualize quando quiser.

Comece grátis →

Experimente o console da API ao vivo → (sem conta necessária)

Obtenha sua chave de API em 30 segundos

Pronto para construir? Pegue uma chave de API grátis (200 chamadas/dia, sem cartão) e comece a puxar dados de baleias, funding e on-chain ao vivo.

Obtenha sua chave de API →