> For the complete documentation index, see [llms.txt](https://kb.stoque.com.br/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://kb.stoque.com.br/zeev/apis/como-utilizar-as-apis-do-zeev/como-controlar-o-volume-maximo-de-requisicoes-a-apis.md).

# 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.