Limitações da API

Para garantir a qualidade do serviço para todos os usuários, nossa API possui algumas limitações de uso.

Rate Limiting

Limites Padrão

Plano	Requisições/minuto	Requisições/dia	Requisições/mês
Starter	60	1.000	30.000
Professional	300	10.000	300.000
Enterprise	Ilimitado	Ilimitado	Ilimitado

Headers de Controle

Cada resposta inclui headers informativos sobre seu consumo:

X-RateLimit-Limit: 1000
X-RateLimit-Remaining: 999
X-RateLimit-Reset: 1640995200

Header	Descrição
X-RateLimit-Limit	Limite total de requisições no período
X-RateLimit-Remaining	Requisições restantes no período
X-RateLimit-Reset	Timestamp Unix de quando o limite será resetado

Quando Você Excede o Limite

Se você exceder o limite de requisições, receberá um erro 429:

{
  "statusCode": 429,
  "error": {
    "code": "RATE_LIMIT_EXCEEDED",
    "message": "Rate limit exceeded. Try again in 60 seconds.",
    "retryAfter": 60
  }
}

Headers de Retry

HTTP/1.1 429 Too Many Requests
Retry-After: 60

Limites de Consultas em Lote

Recurso	Limite
Tamanho máximo do arquivo	10 MB
Itens por arquivo	10.000
Consultas simultâneas	3
Arquivos em processamento	5

Limites de Payload

Tipo	Limite
Tamanho máximo do body	1 MB
Tamanho máximo de resposta	10 MB
Timeout de requisição	30 segundos
Timeout de consulta	60 segundos

Retry com Backoff Exponencial

JavaScript

async function fetchWithRetry(url, options, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      const response = await fetch(url, options);
      
      if (response.status === 429) {
        const retryAfter = response.headers.get('Retry-After') || Math.pow(2, attempt);
        console.log(`Rate limited. Retrying in ${retryAfter}s...`);
        await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
        continue;
      }
      
      if (response.status === 503) {
        const waitTime = Math.pow(2, attempt) * 1000;
        console.log(`Service unavailable. Retrying in ${waitTime}ms...`);
        await new Promise(resolve => setTimeout(resolve, waitTime));
        continue;
      }
      
      return response;
    } catch (error) {
      if (attempt === maxRetries - 1) throw error;
      const waitTime = Math.pow(2, attempt) * 1000;
      await new Promise(resolve => setTimeout(resolve, waitTime));
    }
  }
}

Python

import time
import requests

def fetch_with_retry(url, headers, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = requests.get(url, headers=headers)
            
            if response.status_code == 429:
                retry_after = int(response.headers.get('Retry-After', 2 ** attempt))
                print(f'Rate limited. Retrying in {retry_after}s...')
                time.sleep(retry_after)
                continue
            
            if response.status_code == 503:
                wait_time = 2 ** attempt
                print(f'Service unavailable. Retrying in {wait_time}s...')
                time.sleep(wait_time)
                continue
            
            return response
        except Exception as e:
            if attempt == max_retries - 1:
                raise e
            wait_time = 2 ** attempt
            time.sleep(wait_time)
    
    return None

Melhores Práticas

⚡ Otimize suas Requisições

1. Implemente cache local: Armazene resultados de consultas recentes
2. Use retry com backoff: Implemente retry exponencial para erros temporários
3. Monitore uso nos headers: Acompanhe seu consumo através dos headers
4. Faça requisições apenas quando necessário: Evite consultas duplicadas

📊 Monitore seu Consumo

// Monitore os headers de rate limit
async function monitoredFetch(url, options) {
  const response = await fetch(url, options);
  
  const limit = response.headers.get('X-RateLimit-Limit');
  const remaining = response.headers.get('X-RateLimit-Remaining');
  const reset = response.headers.get('X-RateLimit-Reset');
  
  console.log(`Rate Limit: ${remaining}/${limit}`);
  
  if (remaining < 10) {
    console.warn('⚠️ Approaching rate limit!');
  }
  
  return response;
}

🔄 Cache Inteligente

const cache = new Map();
const CACHE_TTL = 5 * 60 * 1000; // 5 minutos

async function cachedQuery(plate) {
  const cached = cache.get(plate);
  
  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
    console.log('Using cached result');
    return cached.data;
  }
  
  const result = await queryVehicle(plate);
  cache.set(plate, { data: result, timestamp: Date.now() });
  
  return result;
}

Limites Customizados

Precisa de limites maiores? Entre em contato com nossa equipe:

• 📧 Email: contato@checktudo.com.br
• 📱 WhatsApp: (11) 2222-1119

Planos Enterprise

Benefício	Descrição
Rate limit ilimitado	Sem restrições de requisições
Suporte prioritário	Atendimento em até 1 hora
SLA garantido	99.9% de uptime
IP dedicado	IP exclusivo para sua conta
Webhook customizado	Notificações em tempo real

Estatísticas da API

• 99.9% de uptime garantido
• < 200ms tempo médio de resposta
• 1M+ consultas processadas mensalmente
• 24/7 suporte técnico especializado

Segurança e Confiabilidade

Todos os dados são tratados com máxima segurança:

• ✅ Criptografia TLS 1.3
• ✅ Tokens JWT para autenticação
• ✅ Rate limiting inteligente
• ✅ Logs auditáveis de acesso
• ✅ Conformidade com LGPD

Próximos Passos

• Autenticação
• Tratamento de Erros
• Consultas Veiculares