Come usare Puppeteer per il web scraping e alternative più semplici

Ti sarà capitato almeno una volta di provare a tirare giù dati da un sito che carica i contenuti man mano che scorri, che ti nasconde i prezzi dietro il login o che pare cambiare layout ogni due settimane: e allora sai bene quanto sia una rogna. Gli scraper statici, ormai, hanno fatto il loro tempo. Tanto per dare i numeri: oltre il 67% dei consulenti finanziari statunitensi si appoggia oggi al web scraping per i dati alternativi, e l’81% dei retailer statunitensi tiene sotto controllo i prezzi della concorrenza in automatico. Il nodo, però, è proprio questo: gran parte di quei dati vive su siti dinamici, generati da JavaScript e sepolti dietro le azioni dell’utente. Ed è qui che entrano in scena l’automazione del browser headless e strumenti come Puppeteer.

Dopo anni passati a costruire strumenti di automazione e AI (e sì, a fare scraping di parecchi siti per team sales e operations), ho toccato con mano come Puppeteer riesca a sbloccare dati che gli scraper tradizionali si fanno sfuggire. Ma ho visto anche l’altra faccia della medaglia: per chi lavora in azienda, il codice può diventare un muro. In questa guida ti faccio vedere nero su bianco cos’è uno scraper Puppeteer, come metterlo al lavoro per il web scraping e in quali casi potrebbe convenirti qualcosa di molto più immediato, tipo Thunderbit, il nostro web scraper no-code basato su AI.

Cos’è Puppeteer Scraper? Una panoramica rapida

Partiamo dall’ABC. Puppeteer è una libreria open-source per Node.js firmata Google che ti dà il pieno controllo su un browser Chrome o Chromium headless tramite JavaScript. Detto in parole povere: è come avere un robot che apre pagine web, clicca pulsanti, compila moduli, scorre e—soprattutto—estrae dati, il tutto senza che sullo schermo compaia nulla.

Cos’ha di speciale Puppeteer?

Sa renderizzare i contenuti dinamici: in pratica aspetta che JavaScript finisca di caricare, esattamente come farebbe una persona in carne e ossa.
Sa imitare le azioni dell’utente: clic, digitazione, scroll e perfino la gestione dei popup.
È il candidato ideale per fare scraping di siti dove i dati saltano fuori solo dopo un’interazione: inserzioni e-commerce, feed social, dashboard.

Come se la cava rispetto agli altri strumenti?

Selenium: il veterano dell’automazione del browser. Gira su tanti browser e linguaggi, ma è più ingombrante e un filo invecchiato. Resta ottimo per i test cross-browser, però su progetti Chrome/Node.js Puppeteer è più scattante.
Thunderbit: e qui mi parte l’entusiasmo. Thunderbit è un web scraper no-code, basato su AI, che vive dentro il browser. Niente script da scrivere: clicchi “AI Suggest Fields” e lasci che l’AI capisca da sola cosa estrarre. Perfetto per chi in azienda vuole i dati senza nemmeno sfiorare il codice (tra poco ci torno).

In due righe: Puppeteer = controllo al massimo (se sai programmare). Thunderbit = comodità al massimo (se non hai voglia di programmare).

Perché il web scraping con Puppeteer è importante per chi lavora in azienda

Cos’è il data scraping e come farlo nel 2026 Get Started Free

Sgombriamo il campo da un equivoco: il web scraping non è più affare riservato ad hacker o data scientist. Team sales, operations, marketing e persino chi lavora nell’immobiliare ormai si nutrono di dati dal web per guadagnarsi un vantaggio. E con così tante informazioni cruciali ingabbiate dentro siti dinamici, Puppeteer è spesso il grimaldello giusto per liberarle.

Qualche caso d’uso preso dalla vita reale:

Caso d’uso	Chi ne beneficia	Impatto / ROI
Generazione di lead	Sales, Business Development	Automatizza la creazione di liste prospect; risparmia oltre 8 ore a settimana per commerciale (case study)
Monitoraggio prezzi	E-commerce, Product Ops	Tracciamento in tempo reale dei concorrenti; un’azienda ha risparmiato 3,8 milioni di dollari l’anno (source)
Ricerche di mercato	Marketing, Strategy, Finance	Il 67% dei consulenti finanziari usa dati estratti dal web; in alcuni casi il ROI arriva fino al 890% (source)
Aggregazione immobiliare	Agenti, analisti	Estrai dati da oltre 50 pagine immobiliari in pochi minuti, non in ore (source)
Monitoraggio della compliance	Operations, Legal	Automatizza il controllo; una compagnia assicurativa ha evitato 50 milioni di dollari di sanzioni (source)

E c’è un altro dato che vale la pena ricordare: oltre il 40% dei lavoratori brucia un quarto della settimana in attività ripetitive come la raccolta dati. Mandare in automatico tutto questo con il web scraping non è un semplice “di più”: è un vantaggio competitivo bello e buono.

Per iniziare: configurare il tuo scraper Puppeteer

Voglia di sporcarti le mani? Ecco come avviare Puppeteer in meno di 10 minuti (sempre che con JavaScript te la cavi almeno un pochino):

1. Installa Node.js
Puppeteer poggia su Node.js. Scarica l’ultima versione LTS da nodejs.org.

2. Crea una nuova cartella di progetto
Apri il terminale e lancia:

mkdir puppeteer-scraper-demo
cd puppeteer-scraper-demo
npm init -y

3. Installa Puppeteer

npm install puppeteer

Insieme alla libreria verrà scaricata anche una versione compatibile di Chromium (circa 100 MB).

4. Scrivi il tuo primo script
Crea un file e chiamalo scrape.js:

const puppeteer = require('puppeteer');

(async () => {
  const browser = await puppeteer.launch();
  const page = await browser.newPage();
  await page.goto('https://example.com', { waitUntil: 'domcontentloaded' });
  const title = await page.title();
  console.log('Titolo della pagina:', title);
  await browser.close();
})();

Eseguilo con:

node scrape.js

Se sul terminale compare “Titolo della pagina: Example Domain”, tanti auguri: hai appena automatizzato Chrome!

Costruire il tuo primo script di web scraping con Puppeteer

Adesso passiamo dalla teoria alla pratica. Mettiamo che tu voglia raccogliere qualche citazione da quotes.toscrape.com (un sito demo pensato apposta per gli scraper).

Passo 1: vai alla pagina

await page.goto('http://quotes.toscrape.com', { waitUntil: 'networkidle0' });

Passo 2: estrai i dati

const quotes = await page.evaluate(() => {
  return Array.from(document.querySelectorAll('.quote')).map(node => ({
    text: node.querySelector('.text')?.innerText.trim(),
    author: node.querySelector('.author')?.innerText.trim(),
    tags: Array.from(node.querySelectorAll('.tag')).map(tag => tag.innerText.trim())
  }));
});
console.log(quotes);

Passo 3: gestisci la paginazione

let hasNext = true;
let allQuotes = [];
while (hasNext) {
  // Estrai le citazioni come sopra
  const quotes = await page.evaluate(/* ... */);
  allQuotes.push(...quotes);

  const nextButton = await page.$('li.next > a');
  if (nextButton) {
    await Promise.all([
      page.click('li.next > a'),
      page.waitForNavigation({ waitUntil: 'networkidle0' })
    ]);
  } else {
    hasNext = false;
  }
}

Passo 4: salva in JSON

const fs = require('fs');
fs.writeFileSync('quotes.json', JSON.stringify(allQuotes, null, 2));

Ed ecco servito: uno scraper Puppeteer di base che naviga, estrae, gestisce la paginazione e mette in salvo i dati.

Tecniche avanzate per Puppeteer scraper: gestire contenuti dinamici

I siti del mondo reale, nella maggior parte dei casi, non sono lineari come una listina statica. Ecco come venire a capo delle situazioni più spinose:

1. Attendere elementi dinamici

await page.waitForSelector('.product-list-item');

Così sei sicuro che il contenuto che ti serve sia già caricato prima di provare a estrarlo.

2. Simulare le azioni dell’utente

Cliccare un pulsante: await page.click('#load-more');
Digitare in un campo: await page.type('#search', 'laptop');

Scorrere per gestire l’infinite scroll:

// Nota: page.waitForTimeout è stato rimosso in Puppeteer v22. Usa invece una semplice promise.
const sleep = (ms) => new Promise(r => setTimeout(r, ms));

let previousHeight = await page.evaluate('document.body.scrollHeight');
while (true) {
  await page.evaluate('window.scrollTo(0, document.body.scrollHeight)');
  await sleep(1500);
  const newHeight = await page.evaluate('document.body.scrollHeight');
  if (newHeight === previousHeight) break;
  previousHeight = newHeight;
}


**3. Gestire i login**
```javascript
await page.goto('https://exampleshop.com/login');
await page.type('#login-username', 'myusername');
await page.type('#login-password', 'mypassword');
await page.click('#login-button');
await page.waitForNavigation({ waitUntil: 'networkidle0' });

4. Gestire dati caricati via AJAX A volte i dati non stanno nel DOM ma arrivano da una chiamata API. Puoi metterti in ascolto sulle risposte di rete e intercettarle così:

page.on('response', async response => {
  if (response.url().includes('/api/products')) {
    const data = await response.json();
    // Elabora i dati
  }
});

Esempio reale: estrarre dati prodotto da un sito e-commerce

Adesso mettiamo insieme tutti i pezzi. Immagina di voler raccogliere nomi prodotto, prezzi e immagini da un sito e-commerce (demo) dopo aver fatto login.

const puppeteer = require('puppeteer');
const fs = require('fs');

(async () => {
  const browser = await puppeteer.launch({ headless: true });
  const page = await browser.newPage();

  // Passo 1: accedi
  await page.goto('https://exampleshop.com/login');
  await page.type('#login-username', 'myusername');
  await page.type('#login-password', 'mypassword');
  await page.click('#login-button');
  await page.waitForNavigation({ waitUntil: 'networkidle0' });

  // Passo 2: vai alla pagina della categoria
  await page.goto('https://exampleshop.com/category/laptops', { waitUntil: 'networkidle0' });

  // Passo 3: estrai i prodotti
  const products = await page.evaluate(() => {
    return Array.from(document.querySelectorAll('.product-item')).map(item => ({
      name: item.querySelector('.product-title')?.innerText.trim() || '',
      price: item.querySelector('.product-price')?.innerText.trim() || '',
      image: item.querySelector('img.product-image')?.src || ''
    }));
  });

  // Passo 4: salva in JSON
  fs.writeFileSync('products.json', JSON.stringify(products, null, 2));

  await browser.close();
})();

Questo script fa il login, naviga, estrae e salva il tutto da solo. Se hai bisogno di spingerti oltre, puoi aggiungere cicli per la paginazione o aprire la scheda di ogni singolo prodotto per pescare più dettagli.

Thunderbit: rendere lo scraper Puppeteer più semplice con l’AI

Prova l’estensione Chrome di Thunderbit Estrai qualsiasi sito web con l’AI in 2 clic. Get Started Free

Se sei arrivato fin qui e ti è venuto da pensare “Bello, ma non ho voglia di scrivere codice ogni santa volta che mi serve un dataset nuovo”, non sei certo l’unico. È esattamente la ragione per cui abbiamo tirato su Thunderbit.

Cosa rende Thunderbit diverso dagli altri?

Zero codice: installi la Thunderbit Chrome Extension, apri la pagina che vuoi estrarre e clicchi “AI Suggest Fields”. Fine.
Rilevamento dei campi basato su AI: Thunderbit legge la pagina e ti propone le colonne più sensate da estrarre, tipo “Nome prodotto”, “Prezzo”, “Immagine” e via dicendo.
Gestione dei contenuti dinamici: scroll infinito, popup, sottopagine? L’AI di Thunderbit ci pensa lei, cliccando attraverso la paginazione o spingendosi perfino dentro la scheda dettagli di ogni prodotto per arricchire i dati.
Export immediato: mandi i dati dritti su Excel, Google Sheets, Notion o Airtable con un solo clic. E senza nessun sovrapprezzo per l’esportazione.
Template per i siti più gettonati: ti serve estrarre da Amazon, Zillow o LinkedIn? Thunderbit ha template già pronti, zero configurazione.
Scraping da cloud o da browser: per i lavori più corposi, Thunderbit estrae fino a 50 pagine in parallelo direttamente nel cloud.

Ho visto utenti passare da “magari potessi avere questi dati” a “ecco qua il mio foglio di calcolo” in meno di cinque minuti. E la ciliegina? Niente più ansia per gli script che si rompono appena il sito cambia: l’AI di Thunderbit si adatta al volo.

Prova gratis Thunderbit AI Web Scraper

Puppeteer vs Thunderbit: scegliere lo strumento giusto per il web scraping

E quindi, su quale dei due puntare? Ecco come lo metterei a fuoco ragionando in ottica di team:

Fattore	Puppeteer (codice)	Thunderbit (no-code, AI)
Facilità d’uso	Richiede JavaScript e conoscenza del DOM	Punto e clic, l’AI suggerisce i campi
Velocità di setup	Da ore a giorni per attività complesse	Minuti: installa e via
Controllo/Flessibilità	Massimo: puoi scrivere logiche personalizzate e integrarlo con altro codice	Alto per i casi standard; meno adatto a workflow molto personalizzati
Contenuti dinamici	Script manuali per attese, clic e scroll	L’AI integrata gestisce automaticamente contenuti dinamici, paginazione e sottopagine
Manutenzione	Gli script sono tuoi: vanno aggiornati quando i siti cambiano	L’AI si adatta ai cambi di layout; meno manutenzione per l’utente
Export dei dati	Devi scrivere tu la logica di esportazione	Export con un clic verso Excel, Sheets, Notion, Airtable, CSV, JSON
Ideale per	Sviluppatori, scraping molto personalizzato o su larga scala	Utenti business, progetti rapidi, team non tecnici
Costo	Gratis (a parte il tuo tempo e l’infrastruttura)	Piano gratuito disponibile; piani a pagamento basati su crediti (vedi Thunderbit Pricing)

Per riassumere:

Vai di Puppeteer se ti serve il controllo totale, hai risorse di sviluppo a disposizione o vuoi incastonare lo scraping dentro un’app più grande.
Vai di Thunderbit se cerchi risultati veloci, non vuoi programmare o devi mettere in mano lo strumento a colleghi non tecnici.

A dirla tutta, ho visto team usarli entrambi: Thunderbit per i risultati lampo e la prototipazione, Puppeteer per le integrazioni più in profondità o i casi limite.

Checklist passo passo: come far partire con successo un progetto di web scraping con Puppeteer

Ecco la mia checklist di fiducia per far filare liscio un progetto di scraping con Puppeteer:

Definisci gli obiettivi: quali dati ti servono? E dove stanno di casa?
Studia il sito: è dinamico? Chiede il login? Ci sono difese anti-bot?
Prepara l’ambiente: Node.js, Puppeteer e tutte le librerie di contorno.
Scrivi una proof of concept: parti da una pagina sola e trova i selettori giusti.
Gestisci i contenuti dinamici: tira fuori waitForSelector, simula clic e scroll quando serve.
Aggiungi paginazione o cicli: raccogli tutte le pagine, non fermarti alla prima.
Metti in campo tecniche anti-blocco: randomizza i ritardi, imposta un User-Agent credibile, usa proxy se necessario.
Esporta e verifica i dati: salva in JSON/CSV e controlla che non manchi nulla.
Ottimizza e gestisci gli errori: aggiungi try/catch, traccia l’avanzamento e tratta con garbo i dati mancanti.
Monitora e mantieni: i siti cambiano, quindi tieniti pronto ad aggiornare lo script.

Qualche dritta per il troubleshooting:

Se i selettori ti restituiscono null, ricontrolla l’HTML e affidati alle attese.
Se ti beccano e ti bloccano, rallenta, ruota gli IP o passa a plugin stealth.
Se lo script va in crash, vai a caccia di memory leak o eccezioni non gestite.

Conclusione e punti chiave

Per i team che vivono di dati, il web scraping è diventato una competenza che non puoi più permetterti di ignorare. Puppeteer ti mette in mano la potenza di estrarre dati anche dai siti più dinamici e infarciti di JavaScript, ma in cambio ti chiede un minimo di dimestichezza con il codice e manutenzione costante. Per chi in azienda preferisce saltare a piè pari il codice e arrivare dritto ai dati, Thunderbit offre un’alternativa no-code basata su AI: rapida, flessibile e robusta più di quanto immagini.

Ecco cosa ti consiglierei di fare:

Se sei tecnico e ti serve personalizzare in profondità, parti da Puppeteer.
Se vuoi velocità, semplicità e meno grane di manutenzione, dai una chance a Thunderbit (la estensione Chrome gratuita è un punto di partenza coi fiocchi).
Per la maggior parte dei team, un mix dei due copre il 99% delle esigenze di dati dal web.

Hai voglia di altre guide come questa? Fai un giro sul Thunderbit Blog, dove trovi tutorial, confronti e le ultime novità sul web scraping basato su AI.

Prova Thunderbit AI Web Scraper Get Started Free

FAQ

1. Cos’è uno scraper Puppeteer e perché si usa per il web scraping?
Puppeteer è una libreria Node.js che ti permette di pilotare un browser Chrome headless tramite JavaScript. La si usa nel web scraping perché sa caricare contenuti dinamici, imitare le azioni dell’utente ed estrarre dati da siti che gli scraper tradizionali non riescono nemmeno a sfiorare.

2. Come si confronta Puppeteer con Selenium e Thunderbit?
Selenium gira su più browser e linguaggi, ma è più pesante. Puppeteer è più agile su Chrome/Node.js e su molte attività di scraping risulta più veloce. Thunderbit, invece, è uno strumento no-code basato su AI che mette anche chi non è tecnico in condizione di estrarre dati in pochi clic.

3. Quali sono i principali vantaggi business del web scraping con Puppeteer?
Automatizzare la raccolta dati fa risparmiare tempo, taglia gli errori e apre la porta a insight in tempo reale per sales, marketing, operations e altro ancora. I casi d’uso spaziano dalla generazione di lead al monitoraggio prezzi, fino alle ricerche di mercato.

4. Quali sono le sfide principali nello scraping con Puppeteer?
Le grane più grosse sono gestire i contenuti dinamici, scansare i blocchi anti-bot e tenere in piedi gli script quando i siti cambiano. Ti toccherà scrivere codice per gestire le attese, simulare le interazioni e domare gli errori.

5. Quando dovrei usare Thunderbit invece di Puppeteer?
Scegli Thunderbit se vuoi evitare di programmare, se ti servono risultati rapidi o se vuoi dare una mano ai colleghi non tecnici. È perfetto per attività di scraping standard, progetti veloci o quando vuoi esportare dati su Excel o Google Sheets con il minimo sforzo.

Pronto a provare un modo più furbo di fare scraping? Scarica Thunderbit oppure scava più a fondo con le altre guide del Thunderbit Blog. Buon scraping!

Scopri di più