O Dev PortalCases de Sucesso
Referência da API

Rate Limit

O rate limit, ou limite de taxa, em APIs é uma prática usada para controlar a quantidade de solicitações que um cliente pode fazer a um servidor em um determinado período. Isso ajuda a prevenir abusos, garantir a qualidade do serviço e proteger os recursos do servidor. O rate limit pode ser definido por várias métricas, como número de requisições por minuto, hora ou dia.

📘

Exemplos Práticos

API Pública de Dados de Clima:

  • Limite: 60 requisições por minuto.
  • Descrição: Um serviço de clima pode permitir até 60 chamadas por minuto para obter dados de temperatura e previsão do tempo. Isso evita que um único usuário sobrecarregue o serviço com requisições excessivas.

API de Rede Social:

  • Limite: 500 requisições por hora.
  • Descrição: Uma API de rede social pode limitar o número de postagens, leituras de feed e outras interações a 500 por hora para garantir que todos os usuários tenham acesso justo e para prevenir abusos que possam afetar a experiência de outros usuários.

API de Pagamentos:

  • Limite: 1000 requisições por dia.
  • Descrição: Um serviço de processamento de pagamentos pode restringir a 1000 transações por dia para garantir a integridade do sistema e prevenir fraudes.

📘

Por padrão, a plataforma Vindi possui um limite de 120 requisições por minuto.

Status do Limite

Para obter o status do limite, consulte os cabeçalhos abaixo no retorno de qualquer chamada à API:

Rate LimitDescrição
Rate-Limit-LimitLimite de requisições por minuto.
Rate-Limit-RemainingNúmero de requisições restantes antes de atingir o limite.
Rate-Limit-ResetHorário em que o limite será reiniciado no formato Unix Time, fuso horário UTC.

🚧

Excedendo o Rate Limit

Caso o limite de requisições seja atingido (Rate-Limit-Remaining igual à zero), a plataforma irá rejeitar a requisição seguinte e retornar o status HTTP 429 Too Many Requests, incluindo o header Retry-After, que indica o número de segundos restantes para realizar uma nova tentativa.

O limite contempla todos os tipos de requisição, inclusive requisições inválidas do tipo 422.

Evite polling

Polling é o nome do procedimento usado para buscar o status de determinada informação em intervalos de tempo consecutivos. Sabemos que é comum implementar rotinas diárias de consulta de status de pagamento da fatura. Enquanto este procedimento funciona satisfatoriamente com um número baixo de faturas, você poderá esbarrar no limite de requisições caso o número de consultas aumente.

É justamente por isso que a plataforma Vindi oferece os webhooks. Em vez de gastar recursos computacionais com polling, configure a plataforma Vindi para avisar seu backend via POST imediatamente no evento de um pagamento, por exemplo.

Com isso você não desperdiça recursos e garante que sua plataforma estará com os dados sempre atualizados. Se você precisar de um tipo de webhook que ainda não esteja disponível, converse com nossa equipe e ficaremos felizes em criar um novo tipo de disparo que ajude você a se manter dentro do limite de requisições.

Use cache

Recursos que não são atualizados frequentemente podem ser armazenados em cache localmente. Por exemplo, em vez de efetuar uma requisição de listagem de planos GET /plans toda vez que um cliente quiser efetuar uma assinatura, faça uma única consulta à API e armazene o resultado em memória, configurando o tempo de expiração que julgar necessário.

👍

Soluções baseadas em memcache ou Redis funcionam muito bem nesses casos.

Exemplo de código

require 'net/http'
require 'uri'
require 'json'
require 'dalli'

# Configuração do cache
cache = Dalli::Client.new('localhost:11211', namespace: 'api_cache', compress: true)

def get_plans
  cached_data = cache.get('plans')
  return cached_data if cached_data

  uri = URI.parse("https://app.vindi.com.br/api/v1/plans")
  request = Net::HTTP::Get.new(uri)
  request['Authorization'] = 'Basic SEUgbGHEYW5jZSBXZXIgbGVuZG8gZW50cmUgb3V0cm9zIGNvbnRyb3M=' # Substitua pelo seu token de autenticação

  response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
    http.request(request)
  end

  if response.code.to_i == 200
    data = JSON.parse(response.body)
    cache.set('plans', data, 300) # Cache por 5 minutos
    return data
  end

  nil
end

# Chamada para obter os planos
plans = get_plans
puts plans

Rate Limiting Client-Side com Cabeçalhos de Resposta:

Utilize os cabeçalhos Rate-Limit-Limit, Rate-Limit-Remaining e Rate-Limit-Reset retornados pela API para gerenciar o rate limit client-side.

Exemplo de parse no Json com Ruby

👍

O uso adequado de rate limits, aproveitando os cabeçalhos de resposta fornecidos pela API da Vindi e realizando o parsing do JSON da resposta, é essencial para manter a estabilidade e a performance das APIs. Ao seguir essas boas práticas, podemos minimizar os impactos negativos do uso indevido e melhorar a eficiência das aplicações.

require 'net/http'
require 'uri'
require 'json'
require 'time'

def make_api_call
  uri = URI.parse("https://app.vindi.com.br/api/v1/plans")
  request = Net::HTTP::Get.new(uri)
  request['Authorization'] = 'Basic SEUgbGHEYW5jXXXXXXXXXXZW50cm9zIGNvbnRyb3M=' # Substitua pelo seu token de autenticação
  response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
    http.request(request)
  end
  
  case response.code.to_i
  when 200
    handle_successful_response(response)
  when 429
    handle_rate_limit(response)
  else
    handle_error_response(response)
  end
end

def handle_successful_response(response)
  plans = JSON.parse(response.body)
  puts plans
end

def handle_rate_limit(response)
  rate_limit_reset = response['Rate-Limit-Reset'].to_i
  sleep_time = rate_limit_reset - Time.now.to_i
  sleep(sleep_time) if sleep_time > 0
  make_api_call
end

def handle_error_response(response)
  puts "Erro: #{response.code} - #{response.message}"
end

# Chamada para obter os planos com gestão de rate limiting
make_api_call