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

# Rate Limits

> A API Pontua não aplica rate limiting hoje. Boas práticas client-side para integrações eficientes.

A API Pontua **não aplica rate limiting** hoje. Não há limite numérico de
requisições por minuto/dia, nem header `X-RateLimit-*` nas respostas, nem
status `429 Too Many Requests`.

Isso **não é licença para abusar**. Chamadas excessivas degradam a
experiência para todos os tenants e podem disparar ações operacionais
manuais do nosso lado. Use as boas práticas abaixo para integrar bem.

## Boas práticas client-side

### 1. Pagine com `limite` alto

Use `limite=100` nas listagens em vez de iterar com páginas pequenas.
10x menos chamadas pra cobrir o mesmo dataset.

→ Detalhes em [Paginação](/conceitos/paginacao).

### 2. Throttling do lado do cliente

Mesmo sem 429, controle a concorrência por token. Por exemplo, no Node:

```javascript theme={null}
import pLimit from 'p-limit'

const limit = pLimit(10) // no máximo 10 simultâneas
const tasks = ids.map((id) =>
  limit(() => fetch(`https://api.pontua.com.br/colaborador/${id}`, { headers })),
)
const respostas = await Promise.all(tasks)
```

Em Python, use `asyncio.Semaphore`. Em Go, channels com buffer.

### 3. Cache de dados pouco voláteis

Departamentos, cargos, centros de custo, turnos cadastrados raramente
mudam. Cache no seu lado por 5–60 minutos em vez de re-fetch a cada
operação.

### 4. Backoff exponencial em 5xx

Se você recebe sequência de 500/502/503, **pare por alguns segundos**.
Significa pressão temporária no backend — não amplifique:

```javascript theme={null}
async function comBackoff(fn, maxAttempts = 5) {
  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    try {
      return await fn()
    } catch (err) {
      if (err.status < 500 || attempt === maxAttempts - 1) throw err
      const delay = Math.pow(2, attempt) * 1000 + Math.random() * 500
      await new Promise((r) => setTimeout(r, delay))
    }
  }
}
```

### 5. Jobs pesados em horário de baixa carga

Sincronizações de quadro completo, geração de relatórios anuais, exports
massivos: agende para **22h–6h BRT**. Custo de latência cai
significativamente fora do horário comercial.

### 6. Reaproveite sessões HTTP / connection pooling

Crie **um cliente HTTP reutilizável** e mantenha conexões keep-alive.
Não abra TCP+TLS handshake por chamada:

```javascript theme={null}
// Node — reutilize a mesma instância de fetch/agent
const agent = new https.Agent({ keepAlive: true })
```

```python theme={null}
# Python — use Session para connection pool
session = requests.Session()
```

## Volumes altos ou streaming

Se sua integração precisa de volume grande de chamadas (>100 mil/dia)
ou latência baixa para eventos em tempo real, fale com sua gerência de
conta antes de subir para produção.