# Como controlar o volume máximo de requisições à APIs

## Visão geral

Em todas as APIs do Zeev existe um volume máximo de requisições por segundo, por minuto, por hora e por dia. Caso o limite extrapole, a chamada à API retornará um com código 429 *- Too Many Requests*.

Esse limite é fundamental para manter e assegurar a performance geral do sistema. Altos volumes de requisições à API podem comprometer a experiência geral dos usuários finais no uso do dia-a-dia.

## Quais os limites

Para ambientes hospedados na nuvem SaaS da Zeev, os limites são definidos conforme o seu volume de licenciamento. Você pode encontrar essa informação em nossos [Termos Técnicos de Uso](https://sales.zeev.it/technical.html#chapter_10).

## Técnicas para respeitar o limite

### Implemente *Sleep*

Em geral, um algoritmo em linguagem de programação executa em milissegundos, e não em segundos. Isso significa que se você tiver 2 chamadas de API em sequencia, provavelmente receberá erro 429 pois ela será executada abaixo do tempo mínimo de 1 segundo entre chamadas.

Todas as linguagens de programação possuem funções de *sleep*, que consistem em parar o código por um determinado momento. Adicionar uma função de *sleep* de 1 segundo após cada chamada de API assegura que a próxima chamada não executará com erro.

Veja abaixo 3 exemplos de implementação teórica de sleep, com javascript, C# e Python

{% tabs %}
{% tab title="Node.js" %}

```javascript
async function fetchData() {
  const url = 'https://api.exemplo.com/dados';
  const headers = { 
    'Content-Type': 'application/json',
    'Authorization': 'Bearer token-de-autenticação' 
  };

  try {
    const response1 = await fetch(url, { headers: headers });
    const data1 = await response1.json();
    console.log('Response 1:', data1);

    //Espera por 200 millisegundos
    await new Promise(resolve => setTimeout(resolve, 200));

    const response2 = await fetch(url, { headers: headers });
    const data2 = await response2.json();
    console.log('Response 2:', data2);
  } catch (error) {
    console.error('Error:', error);
  }
}

fetchData();
```

{% endtab %}

{% tab title="C#" %}

```csharp
static async Task Main()
{
    using (HttpClient client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", "Bearer token-de-autenticação");

        try
        {
            HttpResponseMessage response1 = await client.GetAsync("https://api.exemplo.com/dados");
            response1.EnsureSuccessStatusCode();
            string responseBody1 = await response1.Content.ReadAsStringAsync();
            Console.WriteLine("Response 1: " + responseBody1);

            Thread.Sleep(200); // Pause for 200 milliseconds

            HttpResponseMessage response2 = await client.GetAsync("https://api.exemplo.com/dados");
            response2.EnsureSuccessStatusCode();
            string responseBody2 = await response2.Content.ReadAsStringAsync();
            Console.WriteLine("Response 2: " + responseBody2);
        }
        catch (HttpRequestException e)
        {
            Console.WriteLine("\nException Caught!");
            Console.WriteLine("Message :{0} ", e.Message);
        }
    }
}
```

{% endtab %}

{% tab title="Python" %}

```python
import requests
import time

async def fetchData():
    url = "https://api.exemplo.com/dados"
    headers = {"Authorization": "Bearer token-de-autenticação"}

    response1 = requests.get(url, headers=headers)
    print('Response 1:', response1.status_code, response1.text)

    time.sleep(0.2)  # Sleep for 200 milliseconds

    response2 = requests.get(url, headers=headers)
    print('Response 2:', response2.status_code, response2.text)

fetchData()
```

{% endtab %}
{% endtabs %}

### Implemente *Backoff Exponencial*

Se você atingir o limite de solicitações por segundo, implemente uma estratégia de *backoff exponencial*. Isso significa que, ao receber um código de resposta 429, você deve esperar um período de tempo crescente antes de fazer outra tentativa. 

Comece com uma pequena pausa e aumente progressivamente o tempo de espera em cada tentativa subsequente.

Por exemplo, no primeiro erro 429, aguarde 1 segundo. No segundo erro 429, aguarde 2 segundos. E assim sucessicamente.

### Implemente biblioteca ou módulo de *Rate Limiting*

Muitas linguagens de programação têm bibliotecas ou módulos que facilitam o gerenciamento de *rate limits*. Essas ferramentas podem ajudar a automatizar a lógica de *backoff exponencial* e monitorar o uso da cota. Procure por bibliotecas especializadas com base na linguagem de programação que você está utilizando.

### Implemente c**ache local**

Considere implementar um mecanismo de cache local para armazenar as respostas das solicitações anteriores feitas ao Zeev. Isso pode reduzir a necessidade de fazer repetidas solicitações ao mesmo serviço.

### **Estabeleça limites próprios**

Mesmo que o Zeev imponha limites, você pode implementar seus próprios limites de taxa para evitar atingir os limites do serviço. Isso pode ajudar a controlar seu próprio uso da API e evitar atingir os limites impostos pelo serviço.

### **Monitore e registre solicitações**

Mantenha registros detalhados de todas as solicitações feitas ao serviço do Zeev, incluindo horários, códigos de resposta e quaisquer cabeçalhos relevantes. Isso pode ajudar na depuração e no ajuste fino de sua estratégia de rate limiting.

## Como aumentar esse limite

Após análise e aprovação técnica, é possível avaliar o aumento dos limites através da contratação de pacotes adicionais. Contate nossas equipes comerciais para mais detalhes.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://kb.stoque.com.br/zeev/apis/como-utilizar-as-apis-do-zeev/como-controlar-o-volume-maximo-de-requisicoes-a-apis.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.