> ## Documentation Index
> Fetch the complete documentation index at: https://docs.connectadesk.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Limites de uso

> Limite de requisições por empresa na API do Connecta DESK: headers RateLimit, resposta 429 e o que fazer ao atingir o limite.

A API limita o número de requisições **por empresa**, em janelas fixas de um minuto. Todos os
tokens da empresa dividem o mesmo limite, então criar um segundo token não aumenta a quantidade de
chamadas permitidas.

<Info>
  O padrão é **120 requisições por minuto**. Empresas que precisam de mais podem ter um limite
  próprio definido no plano. Se a sua integração vai precisar de mais que isso, fale com o
  comercial antes de planejá-la em cima do limite padrão.
</Info>

## Os headers

Toda resposta informa a situação atual da janela. Confie nesses headers em vez de contar as
requisições do seu lado, porque a contagem inclui as outras integrações da empresa.

<ResponseField name="RateLimit-Limit" type="integer">
  Limite de requisições da empresa no minuto atual.
</ResponseField>

<ResponseField name="RateLimit-Remaining" type="integer">
  Quantas requisições ainda cabem na janela atual.
</ResponseField>

<ResponseField name="RateLimit-Reset" type="integer">
  Segundos até a janela terminar e o contador voltar a zero.
</ResponseField>

```bash theme={null}
RateLimit-Limit: 120
RateLimit-Remaining: 96
RateLimit-Reset: 34
```

## Quando o limite é atingido

```json theme={null}
{
  "error": {
    "code": "ERR_API_RATE_LIMIT",
    "message": "Limite de requisições por minuto excedido para esta empresa."
  }
}
```

A resposta é `429` e traz mais um header:

<ResponseField name="Retry-After" type="integer">
  Segundos de espera antes de tentar de novo. Corresponde ao tempo que falta para a janela
  terminar.
</ResponseField>

<Warning>
  Respeite o `Retry-After`. Se você repetir a chamada na hora, só consome a próxima janela e a
  integração continua recebendo `429`. As outras integrações da empresa também são prejudicadas,
  porque dividem o mesmo limite.
</Warning>

## Como tratar o 429

<CodeGroup>
  ```javascript Node.js theme={null}
  async function chamar(caminho, init = {}, tentativas = 4) {
    for (let i = 1; i <= tentativas; i++) {
      const res = await fetch(`${process.env.CONNECTA_URL}${caminho}`, {
        ...init,
        headers: {
          Authorization: `Bearer ${process.env.CONNECTA_TOKEN}`,
          ...init.headers
        }
      });

      if (res.status !== 429) return res;

      // O servidor já diz quanto esperar; o jitter evita que várias instâncias
      // voltem exatamente no mesmo instante e estourem a janela de novo.
      const espera = Number(res.headers.get('Retry-After') ?? 60);
      await new Promise((r) => setTimeout(r, (espera + Math.random() * 2) * 1000));
    }

    throw new Error('Limite de requisições persistente');
  }
  ```

  ```python Python theme={null}
  import os, time, random, requests

  def chamar(caminho, tentativas=4, **kwargs):
      for _ in range(tentativas):
          res = requests.get(
              f"{os.environ['CONNECTA_URL']}{caminho}",
              headers={"Authorization": f"Bearer {os.environ['CONNECTA_TOKEN']}"},
              **kwargs,
          )

          if res.status_code != 429:
              return res

          espera = int(res.headers.get("Retry-After", 60))
          time.sleep(espera + random.uniform(0, 2))

      raise RuntimeError("Limite de requisições persistente")
  ```
</CodeGroup>

## Como ficar longe do limite

<AccordionGroup>
  <Accordion title="Aumente o perPage antes de aumentar a frequência" icon="list">
    Ler uma lista com `perPage=100` custa 1 requisição a cada 100 registros. Com o padrão de 20,
    custa 5. É o ajuste que mais reduz o consumo e também o mais fácil de fazer. Veja
    [Paginação](/essentials/paginacao).
  </Accordion>

  <Accordion title="Evite consultas muito frequentes" icon="timer">
    Consultar `GET /messages/jobs/{jobId}` a cada 200 ms consome a janela inteira em pouco mais de
    20 segundos. Comece com intervalos de 1 segundo e vá aumentando.
  </Accordion>

  <Accordion title="Guarde o que não muda" icon="database">
    Filas, tags, tipos de qualificação, canais e campos personalizados mudam pouco. Buscar essas
    listas a cada operação é o desperdício mais comum. Leia uma vez e guarde uma cópia do seu
    lado.
  </Accordion>

  <Accordion title="Distribua as rotinas" icon="clock">
    Se três integrações fazem carga completa à meia-noite, elas disputam o mesmo limite. Espalhe
    os horários.
  </Accordion>
</AccordionGroup>

## Envio de mensagens e o limite

`POST /messages` responde `202` na hora e faz o envio em segundo plano. A requisição conta para o
limite, mas o envio em si não. A velocidade de saída das mensagens depende do provedor do canal.

<Note>
  Você consegue enfileirar 120 mensagens em um minuto, mas elas não vão sair todas nesse mesmo
  minuto. Para envios em volume, use [campanhas](/api-reference/introduction) em vez de um laço
  sobre `POST /messages`. A campanha foi feita para esse ritmo e permite pausar, retomar e
  acompanhar o envio pelo relatório.
</Note>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.