---
title: "Paginação na API do CRM Datacrazy (take, skip)"
description: "Aprenda a paginar chamadas de API usando `take`, `skip` e `pageCount`, buscando os registros em partes e identificando quando não existem mais itens."
url: https://help.datacrazy.io/pt-br/articles/10670829-paginacao-na-api-do-crm-datacrazy-take-skip
collection: "APIs CRM Datacrazy"
updated: 2026-11-18
language: pt-br
alternates: [en, es]
---

# Paginação na API do CRM Datacrazy (take, skip)

Aprenda a paginar chamadas de API usando `take`, `skip` e `pageCount`, buscando os registros em partes e identificando quando não existem mais itens.

## Como realizar paginação nas APIs do CRM Datacrazy

Aprenda a paginar chamadas de API usando `take`, `skip` e `pageCount`, tanto no n8n quanto em códigos próprios.

## Paginação de API pelo n8n

Ao ativar a paginação no n8n, você pode usar o `pageCount` para identificar qual página está sendo buscada.

Os principais valores são:

-   `take`: quantidade máxima de itens buscados em cada chamada.
    
-   `skip`: quantidade de itens que devem ser ignorados antes de iniciar a busca.
    
-   `pageCount`: número da página atual. A contagem começa em `0`.
    

### Exemplo com 1.000 itens por página

Defina o `take` como:

```text
take = 1000

```

Na primeira chamada, o `pageCount` será `0`:

```text
pageCount = 0
skip = 1000 × 0
skip = 0

```

Assim, o n8n busca os primeiros 1.000 itens.

Na segunda chamada, o `pageCount` será `1`:

```text
pageCount = 1
skip = 1000 × 1
skip = 1000

```

Agora, o n8n pula os primeiros 1.000 itens e busca os próximos 1.000.

A expressão utilizada no campo `skip` é:

```javascript
{{ $pageCount * 1000 }}

```

A fórmula geral é:

```text
skip = take × pageCount

```

## Exemplo de configuração da paginação no n8n, da query skip

![](https://staticfiles.gleap.io/ghelparticle/QzHfdfubRfb0lu4MVcVpaxDC74owncG5XVyLUusg1ikdEMBDqOslMUuVyifmIXl0Bwt91f5L2JL.png)

* * *

## Paginação de API via código

Para realizar a paginação por meio de um código, como JavaScript ou Python, podemos usar a mesma lógica do n8n.

Primeiro, definimos:

-   `take = 1000`: quantidade máxima de itens buscados por chamada.
    
-   `pageCount = 0`: número inicial da página.
    
-   `skip`: quantidade de itens que a API deverá pular.
    

O valor de `skip` é calculado assim:

```text
skip = take × pageCount

```

### Primeira chamada

```text
pageCount = 0
skip = 1000 × 0
skip = 0

```

A API busca os primeiros 1.000 itens.

### Segunda chamada

```text
pageCount = 1
skip = 1000 × 1
skip = 1000

```

A API pula os primeiros 1.000 itens e busca os próximos 1.000.

### Terceira chamada

```text
pageCount = 2
skip = 1000 × 2
skip = 2000

```

A API pula os primeiros 2.000 itens e busca os próximos 1.000.

Depois de cada chamada, o código deve aumentar o `pageCount` em `1` e repetir a busca.

## Como saber quando a paginação terminou?

Como as rotas da API não retornam mais o total de registros (`count`), devemos verificar quantos itens foram recebidos em cada chamada.

Considerando `take = 1000`:

-   Se a API retornar 1.000 itens, pode existir outra página.
    
-   Se retornar menos de 1.000 itens, essa é a última página.
    
-   Se não retornar nenhum item, não existem mais registros.
    

A regra é:

```text
Continuar enquanto a quantidade de itens retornados for igual ao take.

Parar quando a quantidade de itens retornados for menor que o take.

```

## Atenção aos totais exatos

Se existirem exatamente 1.000, 2.000 ou 3.000 registros, a última página será retornada completa.

Nesse caso, será necessário fazer mais uma chamada. Ela retornará uma lista vazia, confirmando que não existem mais itens.

Exemplo com exatamente 2.000 registros:

```text
Primeira chamada:  1.000 itens
Segunda chamada:   1.000 itens
Terceira chamada:  0 itens

```

Ao receber `0` itens na terceira chamada, a paginação deve ser encerrada.

## Resultado final

Os itens recebidos em cada chamada devem ser adicionados a uma única lista. No final da paginação, essa lista conterá todos os registros encontrados pela API.
