Comment gérer la pagination

La Pagination est la couche de navigation d’un outil de scraping. Après avoir récupéré, affiché et extrait une page, il reste une question pratique : où se trouve le prochain lot d’enregistrements et comment savoir qu’il n’y en a plus ? La plupart des échecs viennent de l’idée que tous les sites utilisent des pages numérotées. Un catalogue peut employer des paramètres d’URL, un bouton Suivant, un défilement infini, un bouton Charger plus, un offset d’API ou un jeton de curseur opaque, parfois plusieurs à la fois.

Commencer par la requête, pas par l’interface

Avant d’écrire la logique, ouvrez les DevTools et observez les changements lors du passage au lot suivant.

Ouvrez l’onglet Network et filtrez sur Fetch/XHR.
Cliquez sur la page suivante, faites défiler ou appuyez sur Charger plus.
Examinez l’URL, les paramètres, le corps de la requête et la réponse.
Décidez s’il faut suivre des liens, interagir avec la page ou appeler directement une API.

L’interface fournit un indice, mais la requête réseau fait foi. Un bouton « Charger plus » peut appeler une API avec offset=40, tandis qu’un lien peut actualiser les résultats avec JavaScript après le changement d’URL.

Changement observé	Premier essai recommandé
URL avec `page=2`, `p=2` ou `/page/2`	Parcourir les URL numérotées
Lien `<a>` vers la page suivante	Suivre `href` jusqu’à sa disparition ou sa désactivation
Contenu après défilement	Trouver la requête XHR ; ne faire défiler le navigateur que si nécessaire
Contenu après un clic	Réutiliser l’API ou cliquer dans une session de navigateur
JSON avec `next_cursor`, `endCursor`, `has_more` ou `offset`	Paginer via la réponse de l’API

Pages numérotées

C’est le cas le plus simple, car l’emplacement suivant apparaît dans l’URL :

https://example.com/products?page=1
https://example.com/products?page=2
https://example.com/catalog/page/3

Incrémentez le numéro et arrêtez lorsque la réponse ne contient aucun élément, moins d’éléments que prévu ou une page 404/vide connue.

import requests
from bs4 import BeautifulSoup

all_products = []

for page in range(1, 100):
    html = requests.get(f"https://example.com/products?page={page}").text
    soup = BeautifulSoup(html, "html.parser")
    cards = soup.select(".product-card")

    if not cards:
        break

    for card in cards:
        all_products.append(card.select_one(".title").get_text(strip=True))

Attention aux index commençant à 0, aux paramètres p ou start et aux sites qui renvoient la première page lorsque le numéro dépasse la limite. Cette répétition est pire qu’une page vide, car elle crée silencieusement des doublons.

Liens Suivant

Certains sites n’affichent aucun numéro, seulement un lien ou une flèche « Suivant ». Si l’élément est une ancre normale, suivez le lien :

from urllib.parse import urljoin

import requests
from bs4 import BeautifulSoup

url = "https://example.com/products"
seen_urls = set()

while url and url not in seen_urls:
    seen_urls.add(url)
    soup = BeautifulSoup(requests.get(url).text, "html.parser")

    for card in soup.select(".product-card"):
        print(card.select_one(".title").get_text(strip=True))

    next_link = soup.select_one("a[rel='next'], a.next")
    url = urljoin(url, next_link["href"]) if next_link and next_link.get("href") else None

La protection seen_urls est importante : certains sites mal configurés renvoient depuis le dernier lien vers la page courante ou la première. Vérifiez aussi aria-disabled="true", disabled ou une classe disabled.

Défilement infini

Il semble exiger un navigateur, mais repose généralement sur une API. Faites défiler avec les DevTools ouverts et cherchez la requête du lot suivant ; les paramètres s’appellent souvent offset, page, after, cursor ou limit. Si l’endpoint est exploitable, appelez-le directement :

import requests

offset = 0
limit = 24
products = []

while True:
    data = requests.get(
        "https://example.com/api/products",
        params={"offset": offset, "limit": limit},
    ).json()

    batch = data.get("items", [])
    if not batch:
        break

    products.extend(batch)
    offset += len(batch)

N’utilisez un navigateur que si l’API est difficile à appeler hors de la page en raison de l’authentification, de paramètres signés ou d’un état client complexe.

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch()
    page = browser.new_page()
    page.goto("https://example.com/products")

    previous_count = 0
    for _ in range(40):
        page.mouse.wheel(0, 4000)
        page.wait_for_timeout(1500)

        current_count = page.locator(".product-card").count()
        if current_count == previous_count:
            break
        previous_count = current_count

    print(page.locator(".product-card").count())
    browser.close()

Ne vous fiez pas seulement à la hauteur de page : publicités, images et listes virtualisées peuvent la modifier continuellement. Combinez nombre d’éléments, inactivité réseau et nombre maximal de défilements.

Boutons Charger plus

Un tel bouton est un défilement infini contrôlé. Le clic permet d’attendre, valider le nouveau nombre d’éléments et réessayer en cas d’échec. Utilisez l’API si elle est propre ; sinon, cliquez en boucle :

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch()
    page = browser.new_page()
    page.goto("https://example.com/products")

    while page.locator("button.load-more").is_visible():
        before = page.locator(".product-card").count()
        page.locator("button.load-more").click()
        page.wait_for_function(
            "(count) => document.querySelectorAll('.product-card').length > count",
            before,
        )

    browser.close()

La vérification importante n’est pas seulement « bouton cliqué », mais « nouveaux enregistrements apparus ». Un bouton peut échouer silencieusement, se désactiver ou rester visible après le dernier lot.

API avec offset et curseur

Les sites modernes paginent souvent au niveau de l’API. L’offset demande une position numérique :

/api/products?offset=40&limit=20

Le curseur demande le prochain jeton opaque renvoyé par la réponse précédente :

{
  "items": [],
  "pageInfo": {
    "hasNextPage": true,
    "endCursor": "eyJpZCI6MTAwfQ=="
  }
}

Le curseur est plus stable lorsque des enregistrements changent pendant l’extraction : il signifie « continuer après cette position connue », et non « ignorer 40 lignes ».

import requests

cursor = None

while True:
    params = {"limit": 50}
    if cursor:
        params["after"] = cursor

    data = requests.get("https://example.com/api/products", params=params).json()
    for item in data.get("items", []):
        print(item["name"])

    page_info = data.get("pageInfo", {})
    if not page_info.get("hasNextPage"):
        break

    cursor = page_info.get("endCursor")

Gérez délibérément les limites de débit : respectez Retry-After, réessayez les échecs temporaires avec un délai progressif et enregistrez la progression si recommencer depuis la première page serait coûteux.

Pagination hybride

Les sites combinent souvent les modèles :

Une catégorie possède des pages numérotées, mais chacune charge davantage de produits après défilement.
Une page de recherche commence avec un bouton Charger plus, puis passe à des liens numérotés.
Une interface à onglets possède une Pagination distincte pour « Nouveau », « Populaire » et « Promotions ».
Une liste pagine les URL des résultats, puis chaque page détaillée possède ses propres avis ou commentaires paginés.

Traitez-les comme des boucles imbriquées : la boucle externe gère la grande unité de navigation et chaque boucle interne une action répétée. Suivez les ID uniques sur toute l’exécution pour éviter les doublons.

Mesures de protection pratiques

Définissez un signal d’arrêt. Résultat vide, lien absent, bouton désactivé, hasNextPage: false, curseur répété et limite d’itérations sont valides.
Détectez les doublons. Stockez des ID stables ou URL canoniques.
Limitez le rythme. Ajoutez de petites attentes aléatoires entre les lots ; attendez les changements de contenu plutôt qu’un délai fixe.
Journalisez les échecs. Après plusieurs tentatives, notez l’URL ou le curseur et continuez si possible.
Préférez les API lorsqu’elles sont légitimes et stables. Elles sont généralement plus rapides et faciles à valider.
Utilisez un outil visuel si la vitesse de configuration prime. Dans Octoparse, les flux Suivant, Charger plus et défilement infini se configurent visuellement, puis s’exécutent localement ou dans le cloud.

La Pagination ne consiste pas simplement à « passer à la page suivante » : c’est la boucle de contrôle de l’outil. Avec une prochaine étape claire, une condition d’arrêt fiable et une protection contre les doublons, il parcourt le site sans s’arrêter silencieusement à la première page ni tourner indéfiniment.

BIEN DÉMARRER

BASES DU WEB SCRAPING

FONCTIONNEMENT DES OUTILS DE WEB SCRAPING

CAS D’USAGE

GUIDES

Comment gérer la pagination

Commencer par la requête, pas par l’interface

Pages numérotées

Liens Suivant

Défilement infini

Boutons Charger plus

API avec offset et curseur

Mesures de protection pratiques

​Commencer par la requête, pas par l’interface

​Pages numérotées

​Liens Suivant

​Défilement infini

​Boutons Charger plus

​API avec offset et curseur

​Pagination hybride

​Mesures de protection pratiques

Commencer par la requête, pas par l’interface

Pages numérotées

Liens Suivant

Défilement infini

Boutons Charger plus

API avec offset et curseur

Pagination hybride

Mesures de protection pratiques