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

# Limites de requisições

> A Sorsa usa um limite simples de 20 requisições por segundo em todos os planos. Veja como respeitá-lo.

A Sorsa aplica um limite universal para manter o serviço rápido e estável. Não há faixas por endpoint nem janelas móveis.

## A regra: 20 requisições por segundo

Cada chave de API tem limite de **20 requisições por segundo**. Não há limites por endpoint, janelas de 15 minutos, reinícios por hora ou diferenças entre os planos padrão.

Coordene a frequência total de todos os workers que usam a mesma chave e trate respostas `429` mesmo ao controlar o ritmo localmente.

* O limite é **por chave**, não por IP. Cada chave tem sua própria franquia de 20 req/s.
* **Todas as chamadas contam igualmente.** Uma consulta `/info` e uma `/tweet-info-bulk` com 100 publicações consomem uma requisição cada.
* **A janela não é móvel.** O contador reinicia a cada segundo: 20 chamadas em `T+0.00` permitem outras 20 em `T+1.00`.

## Ao ultrapassar o limite

As chamadas excedentes retornam `429 Too Many Requests`. Não há perda de dados nem penalização da chave. Aguarde o próximo segundo e tente novamente.

Não são enviados cabeçalhos `x-ratelimit-remaining` ou `x-ratelimit-reset`. Como o limite reinicia a cada segundo, esses contadores acrescentariam complexidade com pouco benefício.

## Como respeitar o limite

Em operações comuns, você provavelmente ficará abaixo de 20 req/s. Para lotes grandes, use uma destas abordagens.

### Opção 1: espera fixa entre requisições

Em um único worker sequencial, uma pausa de pelo menos 50 ms após cada resposta limita a frequência. Use uma pausa maior para ter margem. Vários workers com a mesma chave precisam de um limitador compartilhado; pausas independentes de 50 ms não controlam o total.

**Python**

```python theme={null}
import time
import requests

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.sorsa.io/v3"

usernames = ["elonmusk", "naval", "paulg", "vaborsh"]

for username in usernames:
    response = requests.get(
        f"{BASE_URL}/info",
        params={"username": username},
        headers={"ApiKey": API_KEY},
        timeout=30,
    )
    response.raise_for_status()
    print(response.json()["display_name"])
    time.sleep(0.05)  # 50ms between requests
```

**JavaScript**

```javascript theme={null}
const API_KEY = "YOUR_API_KEY";
const BASE_URL = "https://api.sorsa.io/v3";

const usernames = ["elonmusk", "naval", "paulg", "vaborsh"];

for (const username of usernames) {
  const res = await fetch(`${BASE_URL}/info?username=${username}`, {
    headers: { ApiKey: API_KEY },
  });
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  const data = await res.json();
  console.log(data.display_name);
  await new Promise((r) => setTimeout(r, 50)); // 50ms between requests
}
```

### Opção 2: tentar novamente após 429

Trate respostas `429` com uma breve pausa antes de repetir a chamada.

**Python**

```python theme={null}
import time
import requests

def fetch_with_retry(url, headers, max_retries=3):
    for attempt in range(max_retries):
        response = requests.get(url, headers=headers, timeout=30)

        if response.status_code == 429:
            time.sleep(1)
            continue

        response.raise_for_status()
        return response.json()

    raise Exception("Rate limit: max retries exceeded")
```

**JavaScript**

```javascript theme={null}
async function fetchWithRetry(url, headers, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const res = await fetch(url, { headers });

    if (res.status === 429) {
      await new Promise((r) => setTimeout(r, 1000));
      continue;
    }

    if (!res.ok) throw new Error(`HTTP ${res.status}`);
    return await res.json();
  }
  throw new Error("Rate limit: max retries exceeded");
}
```

Combine uma pequena espera preventiva com tratamento de 429 como proteção adicional.

## Lotes reduzem a quantidade de chamadas

Antes de aumentar a velocidade, reduza o total de requisições:

* `/info-batch`: até 100 perfis por chamada.
* `/tweet-info-bulk`: até 100 publicações por chamada.

Uma chamada em lote conta como uma chamada comum, tanto no limite de frequência quanto na cota. Para muitos itens, isso costuma ser mais eficiente que consultas individuais paralelas. Veja [otimização do uso da API](https://docs.sorsa.io/pt-BR/optimizing-api-usage).

## Precisa de um limite maior?

Para volume contínuo acima de 20 req/s, como um pipeline de monitoramento a 100+ req/s, fale com a equipe por [Talk to Sales](https://api.sorsa.io/talk-to-sales) ou [Discord](https://discord.com/invite/uwAefKCj7X) sobre planos personalizados e infraestrutura dedicada.

## Próximos passos

* [Paginação](https://docs.sorsa.io/pt-BR/pagination): obtenha grandes conjuntos respeitando o limite.
* [Códigos de erro](https://docs.sorsa.io/pt-BR/error-codes): respostas 400, 401, 403, 404, 429 e 500.