Come gestire l'impaginazione

L’impaginazione è il livello di navigazione di uno scraper. Dopo aver recuperato, visualizzato ed estratto una pagina, deve rispondere a una domanda pratica: dove si trova il gruppo di record successivo e come capire quando non ne restano altri? La maggior parte degli errori deriva dal considerare ogni sito un elenco di pagine numerate. Un catalogo può invece usare parametri URL, un pulsante successivo, scorrimento infinito, “Carica altro”, un offset API o un token cursore opaco. Alcuni siti combinano più schemi.

Parti dalla richiesta, non dall’interfaccia

Prima di scrivere la logica, apri DevTools e osserva che cosa cambia passando al gruppo successivo.

Apri la scheda Network e filtra Fetch/XHR.
Fai clic sulla pagina successiva, scorri o premi “Carica altro”.
Esamina URL, parametri della query, corpo della richiesta e risposta.
Decidi se seguire link, interagire con la pagina o chiamare direttamente un endpoint API.

Usa l’interfaccia come indizio, ma considera decisiva la richiesta di rete. Un pulsante “Carica altro” potrebbe chiamare una semplice API con offset=40; un link potrebbe caricare i risultati con JavaScript dopo la modifica dell’URL.

Che cosa cambia	Primo tentativo consigliato
L’URL contiene `page=2`, `p=2` o `/page/2`	Esegui un ciclo sugli URL numerati
Un link `<a>` porta alla pagina successiva	Segui `href` finché scompare o viene disabilitato
I contenuti compaiono scorrendo	Trova la richiesta XHR; scorri nel browser solo se necessario
I contenuti compaiono facendo clic	Riutilizza la richiesta API o fai clic in una sessione browser
Il JSON contiene `next_cursor`, `endCursor`, `has_more` o `offset`	Gestisci l’impaginazione tramite la risposta API

Pagine numerate

È il caso più semplice, perché la posizione successiva è visibile nell’URL:

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

Lo scraper incrementa il numero e si arresta quando la risposta non contiene elementi, ne contiene meno del previsto o restituisce una pagina 404/vuota nota.

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))

Controlla gli indici che iniziano da 0, parametri come p o start e siti che restituiscono nuovamente la prima pagina quando il numero è fuori intervallo. La ripetizione della prima pagina è peggiore di una pagina vuota, perché crea duplicati senza errori evidenti.

Link alla pagina successiva

Alcuni siti mostrano soltanto un link “Successiva” o una freccia. Se è una normale ancora, seguilo:

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 protezione seen_urls è importante: alcuni siti configurati male fanno puntare l’ultimo link alla pagina corrente o alla prima. Verifica anche stati disabilitati come aria-disabled="true", disabled o una classe disabled.

Scorrimento infinito

Sembra un problema risolvibile solo nel browser, ma di solito utilizza un’API. Scorri una volta con DevTools aperto e cerca la richiesta che recupera il gruppo successivo; i parametri sono spesso offset, page, after, cursor o limit. Quando l’endpoint è utilizzabile, chiamalo direttamente:

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)

Usa un browser soltanto quando autenticazione, parametri firmati o stato lato client rendono difficile chiamare l’API all’esterno della pagina.

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()

Non affidarti soltanto all’altezza della pagina, che può cambiare per annunci, immagini o elenchi virtualizzati. Numero di elementi, inattività della rete e limite massimo di scorrimenti sono una combinazione più sicura.

Pulsanti Carica altro

Un pulsante Carica altro è uno scorrimento infinito controllato: la pagina attende un clic prima di richiedere il gruppo successivo. Lo scraper può quindi attendere, convalidare il nuovo numero di elementi e riprovare in caso di errore. Se il pulsante chiama un’API chiara, usa l’API; altrimenti fai clic in un ciclo browser:

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()

Il controllo importante non è “il pulsante è stato premuto”, ma “sono comparsi nuovi record”. I pulsanti possono non rispondere, disabilitarsi o restare visibili dopo l’ultimo gruppo.

API con offset e cursore

I siti moderni gestiscono spesso l’impaginazione a livello API. L’offset richiede una posizione numerica:

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

Il cursore richiede il token opaco restituito dalla risposta precedente:

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

Il cursore è più stabile quando i record vengono aggiunti o rimossi durante lo scraping: anziché “salta le prime 40 righe”, indica “continua dopo questa posizione nota”.

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")

Gestisci consapevolmente i limiti di frequenza: rispetta Retry-After, riprova gli errori temporanei con backoff e salva l’avanzamento se ricominciare dalla prima pagina sarebbe costoso.

Impaginazione ibrida

I siti reali combinano spesso più schemi:

Una categoria ha pagine numerate, ma ogni pagina carica altri prodotti durante lo scorrimento.
Una ricerca inizia con Carica altro e poi passa ai link numerati.
Un’interfaccia a schede ha impaginazioni separate per “Nuovi”, “Popolari” e “In offerta”.
Una pagina di elenco impagina gli URL dei risultati e ogni dettaglio ha recensioni o commenti a loro volta impaginati.

Gestiscili come cicli annidati. Il ciclo esterno controlla l’unità di navigazione più ampia e ogni ciclo interno una singola azione ripetuta. Traccia ID univoci per tutta l’esecuzione per evitare duplicati nell’output.

Misure di sicurezza pratiche

Definisci un segnale di arresto. Risultati vuoti, link successivi assenti, pulsanti disabilitati, hasNextPage: false, cursori ripetuti e limiti massimi di iterazione sono tutti validi.
Rileva i duplicati. Scorrimento infinito e API con cursore possono ripetere record se i dati cambiano durante l’esecuzione. Conserva ID stabili o URL canonici.
Regola la navigazione. Aggiungi brevi attese casuali tra i gruppi. L’automazione deve attendere modifiche dei contenuti, non soltanto timeout fissi.
Registra gli errori. Se una pagina non riesce dopo più tentativi, registra URL o cursore e continua quando possibile.
Preferisci le API quando sono legittime e stabili. L’impaginazione API diretta è solitamente più veloce e facile da convalidare del controllo di un browser.
Usa uno strumento visuale quando la velocità conta più del codice personalizzato. In Octoparse, i comuni flussi con pagina successiva, Carica altro e scorrimento infinito si configurano visivamente e si eseguono in locale o nel cloud.

L’impaginazione non significa soltanto “vai alla pagina successiva”: è il ciclo di controllo dello scraper. Con una logica chiara per il passaggio successivo, una condizione di arresto affidabile e protezione dai duplicati, lo scraper può attraversare il sito senza fermarsi silenziosamente alla prima pagina né continuare all’infinito.

PER INIZIARE

FONDAMENTI DEL WEB SCRAPING

COME FUNZIONANO I WEB SCRAPER

CASI D’USO

GUIDE

Come gestire l'impaginazione

Parti dalla richiesta, non dall’interfaccia

Pagine numerate

Link alla pagina successiva

Scorrimento infinito

Pulsanti Carica altro

API con offset e cursore

Impaginazione ibrida

Misure di sicurezza pratiche

​Parti dalla richiesta, non dall’interfaccia

​Pagine numerate

​Link alla pagina successiva

​Scorrimento infinito

​Pulsanti Carica altro

​API con offset e cursore

​Impaginazione ibrida

​Misure di sicurezza pratiche

Parti dalla richiesta, non dall’interfaccia

Pagine numerate

Link alla pagina successiva

Scorrimento infinito

Pulsanti Carica altro

API con offset e cursore

Impaginazione ibrida

Misure di sicurezza pratiche