Il mio scraper per le recensioni Amazon funzionava alla grande da sei settimane — poi, una mattina, ha cominciato a restituire 200 OK e una pagina completamente vuota. Nessun errore, nessun CAPTCHA, solo HTML vuoto al posto di centinaia di recensioni.
Se ti suona familiare, non sei l’unico. Alla fine del 2025 Amazon ha iniziato a proteggere le pagine complete delle recensioni dietro un login obbligatorio, e tantissimi script Python di scraping si sono rotti da un giorno all’altro. Negli ultimi mesi ho lavorato a Thunderbit affrontando il problema da entrambe le parti — sia costruendo il nostro scraper AI sia mantenendo la mia pipeline Python per le recensioni — quindi ho pensato che fosse il momento giusto per scrivere la guida che avrei voluto avere quando il mio script ha smesso di funzionare. Questo articolo copre l’approccio che oggi funziona davvero: autenticazione basata sui cookie, selettori stabili che resistono all’offuscamento CSS di Amazon, soluzioni alternative al limite di 10 pagine di paginazione, difese anti-bot e, in più, una sezione extra sull’analisi del sentiment che trasforma il testo grezzo delle recensioni in insight di business concreti. E se a metà lettura pensi: “Preferirei non dovermi tenere tutto questo codice sulle spalle”, ti mostrerò come Thunderbit fa lo stesso lavoro in circa due minuti, senza usare Python.
Cos’è lo scraping delle recensioni Amazon e perché conta?
Lo scraping delle recensioni Amazon è il processo di estrazione automatica dei dati delle recensioni clienti — valutazione in stelle, testo della recensione, nome dell’autore, data, badge di acquisto verificato — dalle pagine prodotto di Amazon. Dal momento che Amazon ha rimosso i contenuti delle recensioni dalla Product Advertising API nel 2010 (senza mai reinserirli), il web scraping è l’unico modo programmatico per accedere a questi dati.
I numeri parlano chiaro. Il 95% degli acquirenti legge le recensioni prima di comprare, e il 94% indica Amazon come fonte principale di recensioni prodotto. Mostrare anche solo 5 recensioni in una scheda prodotto può aumentare la conversione del 270%. Le aziende che analizzano in modo sistematico il sentiment delle recensioni ottengono fino al 15% di retention clienti in più. Non si tratta di teoria astratta di data science: è intelligence competitiva, segnale per migliorare il prodotto e linguaggio di marketing, tutto già disponibile in chiaro sui server di Amazon.
Perché usare Python per estrarre recensioni Amazon
Python resta il linguaggio di riferimento per questo tipo di lavoro. È il linguaggio più desiderato nella Stack Overflow Developer Survey 2024, e il suo ecosistema — requests, BeautifulSoup, pandas, Scrapy — rende lo scraping accessibile anche a chi non è uno sviluppatore full-time.
Team diversi sfruttano questi dati in modi diversi:
| Team | Caso d’uso | Cosa estraggono |
|---|---|---|
| Prodotto / R&D | Individuare reclami ricorrenti, dare priorità agli interventi | Testo delle recensioni 1–2 stelle, frequenza delle parole chiave |
| Sales | Monitorare il sentiment sui prodotti dei concorrenti | Valutazioni, andamento del volume di recensioni |
| Marketing | Trovare il linguaggio dei clienti per i copy pubblicitari | Frasi positive dalle recensioni, menzioni delle funzionalità |
| Operations Ecommerce | Monitorare nel tempo il sentiment dei propri prodotti | Distribuzione delle stelle, rapporto tra acquisti verificati |
| Ricerca di mercato | Confrontare i leader di categoria su più funzionalità | Dataset di recensioni multi-ASIN |
Un brand di utensili da cucina ha analizzato le recensioni negative e scoperto che il 22% citava che “il rivestimento antiaderente si consuma”, ha riformulato il prodotto e ha riconquistato il primo posto tra i Best Seller entro 60 giorni. Un’azienda di fitness tracker ha individuato “irritazione del cinturino” nel testo delle recensioni, ha identificato un problema di allergia al lattice, ha lanciato una variante ipoallergenica e ha ridotto i resi del 40%. Questo è il tipo di ritorno sull’investimento che rende l’impegno tecnico più che sensato.
Login wall: perché il tuo scraper di recensioni Amazon ha smesso di funzionare
Il 14 novembre 2024, Amazon ha iniziato a richiedere l’accesso per vedere la pagina completa delle recensioni prodotto. La modifica è stata confermata sia nei forum della community sia nei blog dei vendor di scraping. Se apri /product-reviews/{ASIN}/ in una finestra in incognito, verrai rimandato a una pagina di sign-in invece che ai dati delle recensioni.
I sintomi sono subdoli: lo script riceve una risposta 200 OK, ma il corpo HTML contiene un modulo di login (name="email", id="ap_password") invece delle recensioni. Nessun codice di errore. Nessun CAPTCHA. Solo… niente di utile.
Amazon ha introdotto questa barriera per motivi anti-bot e di conformità regionale. L’applicazione è incoerente — a volte una finestra del browser appena aperta mostra qualche recensione prima che scatti il blocco, soprattutto nella prima pagina — ma per qualsiasi scraper che lavori su scala conviene partire dal presupposto che il blocco sia sempre attivo.
I diversi domini nazionali di Amazon (.de, .co.uk, .co.jp) applicano il blocco in modo indipendente. Come ha scritto un utente in un forum: “serve un login per ogni paese.” I cookie di .com non funzioneranno su .co.uk.
Recensioni in evidenza vs recensioni complete: cosa puoi ancora vedere senza login
Le pagine prodotto Amazon (l’URL /dp/{ASIN}/) mostrano ancora circa 8 “featured reviews” senza autenticazione. Sono recensioni selezionate dall’algoritmo di Amazon e utili per un controllo rapido del sentiment, ma non si possono ordinare, filtrare o paginare.
Le pagine complete delle recensioni (/product-reviews/{ASIN}/) — con ordinamento per più recenti, filtro per stelle e paginazione su centinaia di recensioni — richiedono l’accesso.
Se ti servono solo poche recensioni per una verifica veloce, puoi prenderle dalla pagina prodotto. Se invece te ne servono centinaia o migliaia, devi gestire l’autenticazione.
Cosa ti serve prima di iniziare: setup Python e librerie
Prima di scrivere codice, ecco cosa serve:
- Difficoltà: intermedia (buona padronanza di Python, conoscenza base di HTML)
- Tempo richiesto: circa 45 minuti per la pipeline completa; circa 10 minuti per uno scraping base
- Occorrente: Python 3.8+, browser Chrome, account Amazon valido
Installa le librerie principali:
pip install requests beautifulsoup4 lxml pandas textblob
Opzionale (per un’analisi del sentiment più avanzata):
pip install transformers torch
Cos’è un ASIN? È l’identificativo prodotto di Amazon, composto da 10 caratteri. Lo trovi in qualsiasi URL prodotto — ad esempio, in amazon.com/dp/B0BCNKKZ91, l’ASIN è B0BCNKKZ91. È la chiave che userai nell’URL delle recensioni.
Step 1: superare il login wall con l’autenticazione basata sui cookie
L’approccio più affidabile è fare login su Amazon nel browser, copiare i cookie di sessione e inserirli nella tua requests.Session() di Python. Così eviti i CAPTCHA e l’autenticazione SMS 2FA che complicano le automazioni di login basate su Selenium.
Ti servono questi sette cookie:
| Nome cookie | Scopo |
|---|---|
session-id | Identificativo di sessione variabile |
session-id-time | Timestamp della sessione |
session-token | Token di sessione variabile |
ubid-main | Identificatore di navigazione dell’utente |
at-main | Token di autenticazione principale |
sess-at-main | Auth valida per la sessione |
x-main | Identificatore legato all’e-mail dell’utente |
Come estrarre i cookie da Chrome DevTools
- Accedi a amazon.com in Chrome
- Apri DevTools (F12 oppure tasto destro → Ispeziona)
- Vai su Application → Storage → Cookies →
https://www.amazon.com - Trova ogni nome cookie nella tabella e copia il valore
- Formattali come stringa separata da punto e virgola per Python
Configura la sessione così:
import requests
session = requests.Session()
# Incolla qui i valori dei cookie
cookies = {
"session-id": "YOUR_SESSION_ID",
"session-id-time": "YOUR_SESSION_ID_TIME",
"session-token": "YOUR_SESSION_TOKEN",
"ubid-main": "YOUR_UBID_MAIN",
"at-main": "YOUR_AT_MAIN",
"sess-at-main": "YOUR_SESS_AT_MAIN",
"x-main": "YOUR_X_MAIN",
}
headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
"Accept-Language": "en-US,en;q=0.5",
}
session.cookies.update(cookies)
session.headers.update(headers)
Importante: riusa sempre lo stesso oggetto session per tutte le richieste. In questo modo i cookie restano coerenti e la navigazione assomiglia a quella di un browser reale. In genere i cookie durano da giorni a settimane sotto carico di scraping, ma se ricominciano a comparire i redirect al login, aggiorna i cookie dal browser.
Per i marketplace diversi da .com, i nomi dei cookie cambiano leggermente — amazon.de usa at-acbde invece di at-main, amazon.co.uk usa at-acbuk, e così via. Ogni marketplace richiede una sessione indipendente.
Step 2: costruire la richiesta e analizzare l’HTML delle recensioni con BeautifulSoup
L’URL delle recensioni Amazon segue questo formato:
https://www.amazon.com/product-reviews/{ASIN}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1
La funzione principale:
from bs4 import BeautifulSoup
import time, random
def get_soup(session, url):
time.sleep(random.uniform(2, 5)) # Pausa gentile
response = session.get(url, timeout=15)
# Rileva il login wall
if "ap_email" in response.text or "Amazon Sign-In" in response.text:
raise Exception("Login wall rilevato — aggiorna i cookie")
if response.status_code != 200:
raise Exception(f"HTTP {response.status_code}")
return BeautifulSoup(response.text, "lxml")
Un piccolo trucco utile: prima di aprire la pagina delle recensioni, visita prima la pagina prodotto. Così la tua sessione segue un pattern di navigazione più naturale.
# Visita prima la pagina prodotto (simula la navigazione reale)
product_url = f"https://www.amazon.com/dp/{asin}"
session.get(product_url, timeout=15)
time.sleep(random.uniform(1, 3))
# Poi apri la pagina recensioni
reviews_url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1"
soup = get_soup(session, reviews_url)
Step 3: usare selettori stabili per estrarre i dati delle recensioni (smetti di dipendere dalle classi CSS)
Qui si rompe la maggior parte dei tutorial del 2022–2023. Amazon offusca i nomi delle classi CSS — cambiano periodicamente e, come ha scritto un developer frustrato in un thread di forum: “nessuno di loro aveva un pattern unico per i nomi delle classi dei tag span.”
La soluzione: Amazon usa attributi data-hook sugli elementi delle recensioni, e sono sorprendentemente stabili. Sono identificatori semantici su cui si basa il frontend di Amazon, quindi non vengono randomizzati.
| Campo recensione | Selettore stabile (data-hook) | Selettore fragile (classe) |
|---|---|---|
| Testo recensione | [data-hook="review-body"] | .review-text-content (cambia) |
| Valutazione in stelle | [data-hook="review-star-rating"] | .a-icon-alt (ambiguo) |
| Titolo recensione | [data-hook="review-title"] | .review-title (a volte) |
| Nome autore | span.a-profile-name | Relativamente stabile |
| Data recensione | [data-hook="review-date"] | .review-date (dipende dalla regione) |
| Acquisto verificato | [data-hook="avp-badge"] | span.a-size-mini |
Il codice di estrazione con i selettori data-hook:
import re
def extract_reviews(soup):
reviews = []
review_divs = soup.select('[data-hook="review"]')
for div in review_divs:
# Valutazione in stelle
rating_el = div.select_one('[data-hook="review-star-rating"]')
rating = None
if rating_el:
rating_text = rating_el.get_text(strip=True)
match = re.search(r'(\d\.?\d?)', rating_text)
if match:
rating = float(match.group(1))
# Titolo
title_el = div.select_one('[data-hook="review-title"]')
title = title_el.get_text(strip=True) if title_el else ""
# Corpo
body_el = div.select_one('[data-hook="review-body"]')
body = body_el.get_text(strip=True) if body_el else ""
# Autore
author_el = div.select_one('span.a-profile-name')
author = author_el.get_text(strip=True) if author_el else ""
# Data e paese
date_el = div.select_one('[data-hook="review-date"]')
date_text = date_el.get_text(strip=True) if date_el else ""
# Formato: "Reviewed in the United States on January 15, 2025"
country_match = re.search(r'Reviewed in (.+?) on', date_text)
date_match = re.search(r'on (.+)$', date_text)
country = country_match.group(1) if country_match else ""
date = date_match.group(1) if date_match else ""
# Acquisto verificato
verified_el = div.select_one('[data-hook="avp-badge"]')
verified = bool(verified_el)
reviews.append({
"author": author,
"rating": rating,
"title": title,
"content": body,
"date": date,
"country": country,
"verified": verified,
})
return reviews
Sto usando questo set di selettori su più ASIN da mesi, e gli attributi data-hook non sono mai cambiati. Le classi CSS, invece, nello stesso periodo sono cambiate almeno due volte.
Step 4: gestire la paginazione e il limite di 10 pagine di Amazon
Amazon limita il parametro pageNumber a 10 pagine da 10 recensioni ciascuna — un tetto rigido di circa 100 recensioni per ogni combinazione di filtri. Il pulsante “Pagina successiva” semplicemente sparisce dopo la pagina 10.
Loop base di paginazione:
all_reviews = []
for page in range(1, 11):
url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber={page}"
soup = get_soup(session, url)
page_reviews = extract_reviews(soup)
if not page_reviews:
break # Nessuna recensione in questa pagina
all_reviews.extend(page_reviews)
print(f"Pagina {page}: {len(page_reviews)} recensioni")
Come ottenere più di 10 pagine di recensioni Amazon
La soluzione alternativa è il raggruppamento per filtri. Ogni combinazione di filterByStar e sortBy ottiene la propria finestra indipendente di 10 pagine.
Valori del filtro stelle: one_star, two_star, three_star, four_star, five_star
Valori ordinamento: recent, helpful (predefinito)
Combinando tutti e 5 i filtri stelle × 2 ordinamenti, puoi arrivare a 100 pagine, cioè fino a 1.000 recensioni per prodotto — e per prodotti con distribuzioni delle stelle sbilanciate, spesso si riesce a recuperare quasi tutto il set di recensioni.
star_filters = ["one_star", "two_star", "three_star", "four_star", "five_star"]
sort_orders = ["recent", "helpful"]
all_reviews = []
seen_titles = set() # Deduplicazione semplice
for star in star_filters:
for sort in sort_orders:
for page in range(1, 11):
url = (
f"https://www.amazon.com/product-reviews/{asin}"
f"?filterByStar={star}&sortBy={sort}&pageNumber={page}"
)
soup = get_soup(session, url)
page_reviews = extract_reviews(soup)
if not page_reviews:
break
for review in page_reviews:
# Deduplica usando la combinazione titolo + autore
key = (review["title"], review["author"])
if key not in seen_titles:
seen_titles.add(key)
all_reviews.append(review)
print(f"[{star}/{sort}] Pagina {page}: {len(page_reviews)} recensioni")
print(f"Recensioni uniche totali: {len(all_reviews)}")
Ci sarà sovrapposizione tra i vari bucket, quindi la deduplicazione è fondamentale. Io uso la combinazione titolo recensione + nome autore come chiave rapida — non perfetta, ma intercetta la maggior parte dei duplicati.
Step 5: aggirare le difese anti-bot (rotazione, throttling, retry)
Amazon usa AWS WAF Bot Control, e negli ultimi tempi è diventato molto più aggressivo. Le contromisure a un solo livello (solo User-Agent rotanti, solo ritardi aggiunti) non bastano più.
| Tecnica | Implementazione |
|---|---|
| Rotazione User-Agent | Scelta casuale tra 10+ stringhe reali di browser |
| Exponential backoff | Ritardi di retry 2s → 4s → 8s sui 503 |
| Throttling delle richieste | random.uniform(2, 5) secondi tra le pagine |
| Rotazione proxy | Ciclo tra proxy residenziali |
| Fingerprint di sessione | Cookie + header coerenti per ogni sessione |
| Impersonificazione TLS | Usare curl_cffi invece di requests standard in produzione |
Un wrapper di retry adatto alla produzione:
import time, random
USER_AGENTS = [
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0",
"Mozilla/5.0 (Macintosh; Intel Mac OS X 15_7_5) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15",
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36",
]
def scrape_with_retries(session, url, max_retries=3):
for attempt in range(max_retries):
try:
session.headers["User-Agent"] = random.choice(USER_AGENTS)
time.sleep(random.uniform(2, 5))
response = session.get(url, timeout=15)
# Rileva blocchi
if "validateCaptcha" in response.url or "Robot Check" in response.text:
wait = (2 ** attempt) * 5
print(f"CAPTCHA rilevato. Attendo {wait}s...")
time.sleep(wait)
continue
if response.status_code in (429, 503):
wait = (2 ** attempt) * 2
print(f"Rate limit rilevato ({response.status_code}). Attendo {wait}s...")
time.sleep(wait)
continue
if "ap_email" in response.text:
raise Exception("Login wall — cookie scaduti")
return BeautifulSoup(response.text, "lxml")
except Exception as e:
if attempt == max_retries - 1:
raise
print(f"Tentativo {attempt + 1} fallito: {e}")
return None
Nota sui proxy: Amazon blocca gli intervalli IP noti dei datacenter (AWS, GCP, Azure, DigitalOcean) a livello di rete. Se scrapi più di qualche centinaio di pagine, i proxy residenziali diventano di fatto obbligatori — aspettati una spesa di 50–200+ $ al mese a seconda del volume. Per progetti piccoli (meno di 100 richieste al giorno), un throttling accurato dal tuo IP domestico spesso funziona bene.
Amazon inoltre ispeziona le fingerprint TLS. La libreria requests standard di Python ha un JA3 hash ben noto che i WAF bloccano in anticipo. Per scraper destinati alla produzione, valuta curl_cffi, che impersona stack TLS reali dei browser. Per scraping da livello tutorial (qualche centinaio di pagine), requests con header ben impostati di solito basta.
Step 6: esportare le recensioni Amazon raccolte in CSV o Excel
Una volta raccolte le recensioni, trasformarle in un formato utile è semplice con pandas:
import pandas as pd
df = pd.DataFrame(all_reviews)
df.to_csv("amazon_reviews.csv", index=False)
print(f"Esportate {len(df)} recensioni in amazon_reviews.csv")
Esempio di output:
| author | rating | title | content | date | country | verified |
|---|---|---|---|---|---|---|
| Sarah M. | 5.0 | Miglior acquisto dell’anno | La batteria dura tutto il giorno, lo schermo è fantastico... | January 15, 2025 | the United States | True |
| Mike T. | 2.0 | Deluso dopo 2 settimane | La porta di ricarica ha smesso di funzionare... | February 3, 2025 | the United States | True |
| Priya K. | 4.0 | Ottimo rapporto qualità-prezzo | Fa tutto quello che mi serve, solo un leggero ritardo con le app pesanti... | March 10, 2025 | the United States | False |
Per esportare in Excel: df.to_excel("amazon_reviews.xlsx", index=False) (richiede openpyxl).
Per Google Sheets, la libreria gspread funziona ma richiede 8+ passaggi di configurazione su Google Cloud — creare un progetto, abilitare due API, generare credenziali di service account, condividere il foglio. Se ti sembra più setup dello scraping stesso, non hai torto. (È uno di quei momenti in cui uno strumento come Thunderbit che esporta su Google Sheets con un clic inizia a sembrare davvero allettante.)
Bonus: aggiungere l’analisi del sentiment alle recensioni estratte in 5 righe di Python
La maggior parte dei tutorial sullo scraping si ferma all’export CSV. Ma assegnare un punteggio al sentiment è ciò che trasforma i dati grezzi in decisioni di business.
Il punto di partenza più veloce è TextBlob:
from textblob import TextBlob
df["sentiment"] = df["content"].apply(lambda x: TextBlob(str(x)).sentiment.polarity)
Otterrai un punteggio di polarità da -1.0 (molto negativo) a +1.0 (molto positivo) per ogni recensione. Esempio di output:
| content (troncato) | rating | sentiment |
|---|---|---|
| "La batteria dura tutto il giorno, lo schermo è fantastico..." | 5.0 | 0.65 |
| "La porta di ricarica ha smesso di funzionare dopo..." | 2.0 | -0.40 |
| "Fa tutto quello che mi serve, solo un po' di ritardo su..." | 4.0 | 0.25 |
| "Assolutamente pessimo. Reso immediato." | 1.0 | -0.75 |
| "Va bene. Nulla di speciale, ma funziona." | 3.0 | 0.10 |
Le righe più interessanti sono quelle che non coincidono: una recensione da 3 stelle con tono positivo, oppure una da 5 stelle con linguaggio negativo. Queste discrepanze spesso fanno emergere opinioni sfumate che le sole stelle non mostrano.
Per una precisione di livello produttivo, la raccomandazione è Hugging Face Transformers. VADER è stato addestrato sui tweet, non sulle recensioni prodotto, e i modelli transformer raggiungono oltre il 98% di accuratezza nella classificazione delle recensioni rispetto agli strumenti lessicali. Il modello nlptown/bert-base-multilingual-uncased-sentiment può persino prevedere direttamente il punteggio da 1 a 5 stelle:
from transformers import pipeline
clf = pipeline("sentiment-analysis",
model="nlptown/bert-base-multilingual-uncased-sentiment")
df["predicted_stars"] = df["content"].apply(
lambda x: int(clf(str(x)[:512])[0]["label"][0])
)
Le recensioni Amazon seguono una distribuzione a J — un forte picco a 5 stelle, un picco più piccolo a 1 stella e una valle al centro. Questo significa che la media delle stelle spesso è un pessimo indicatore della qualità reale del prodotto. Segmenta il cluster a 1 stella e analizza i temi ricorrenti: di solito è lì che si nasconde il difetto davvero correggibile.
Il compromesso onesto: Python fai-da-te vs API di scraping a pagamento vs Thunderbit
Ho mantenuto scraper Python per Amazon, e te lo dico con sincerità: si rompono. I selettori cambiano, i cookie scadono, Amazon introduce un nuovo livello di rilevamento bot, e all’improvviso il sabato mattina lo passi a debuggare uno scraper invece che ad analizzare dati. Anche nei forum molti raccontano la stessa frustrazione — script fai-da-te che “funzionavano il mese scorso” e ora richiedono patch continue.
Ecco come si confrontano i tre approcci principali:
| Criterio | Python fai-da-te (BS4/Selenium) | API di scraping a pagamento | Thunderbit (No-Code) |
|---|---|---|---|
| Tempo di setup | 1–3 ore | 30 min (API key) | 2 minuti |
| Costo | Gratis (+ costo proxy) | 50–200+ $/mese | Piano gratuito disponibile |
| Gestione login wall | Gestione manuale dei cookie | Di solito incluso | Gestito automaticamente |
| Manutenzione | Alta (i selettori si rompono) | Bassa (il provider mantiene) | Zero (l’AI si adatta) |
| Paginazione | Serve codice personalizzato | Inclusa | Inclusa |
| Supporto multi-paese | Sessioni separate per dominio | Di solito supportato | Basato sul browser = la tua locale |
| Analisi sentiment | Devi aggiungere il tuo codice | A volte inclusa | Esporta su Sheets, analizza ovunque |
| Ideale per | Apprendimento, controllo totale | Pipeline di produzione e scala | Estrazioni rapide, team non tecnici |
Python ti dà pieno controllo ed è davvero il modo migliore per capire come funziona lo scraping sotto il cofano. Le API a pagamento (ScrapingBee, Oxylabs, Bright Data) hanno senso per pipeline di produzione in cui la continuità conta più dei costi. E per i team che hanno bisogno di dati sulle recensioni senza il peso dello sviluppo — operations ecommerce che monitorano i concorrenti ogni settimana, team marketing che estraggono il linguaggio dei clienti per i copy — c’è una terza strada.
Come fare scraping delle recensioni Amazon con Thunderbit (senza codice, senza manutenzione)
Abbiamo creato Thunderbit proprio per gestire quei casi in cui mantenere uno scraper Python è troppo pesante. Il flusso è questo:
- Installa l'estensione Chrome di Thunderbit
- Apri nel browser la pagina delle recensioni del prodotto Amazon (sei già loggato, quindi il login wall non è un problema)
- Clicca “AI Suggest Fields” — Thunderbit legge la pagina e propone colonne come Autore, Valutazione, Titolo, Testo recensione, Data, Acquisto verificato
- Clicca “Scrape” — i dati vengono estratti subito, con paginazione integrata
- Esporta in Excel, Google Sheets, Airtable o Notion
Il vantaggio principale è che l’AI di Thunderbit legge la struttura della pagina da capo ogni volta. Nessun selettore CSS da mantenere, nessuna gestione dei cookie, nessun codice anti-bot. Quando Amazon cambia l’HTML, l’AI si adatta. Per chi vuole accesso programmatico senza dover costruire tutto da zero, Thunderbit offre anche una Extract API — estrazione dati strutturata via API con rilevamento campi guidato dall’AI, senza manutenzione dei selettori.
Per approfondimenti sui dati Amazon, vedi le nostre guide su come fare scraping di prodotti e recensioni Amazon e su estrarre e analizzare i dati di vendita Amazon.
Consigli per fare scraping delle recensioni Amazon su larga scala con Python
Se stai estraendo recensioni su molti ASIN, alcune buone pratiche ti risparmieranno parecchi grattacapi:
- Elabora gli ASIN a blocchi con pause tra i prodotti, non solo tra le pagine. Io uso pause di 10–15 secondi tra un ASIN e l’altro.
- Deduplica in modo aggressivo. Quando combini più filtri per stelle e ordini, otterrai recensioni sovrapposte. Usa un set di tuple
(title, author, date)come chiave di deduplicazione. - Registra i fallimenti. Tieni traccia di quali combinazioni ASIN + pagina + filtro sono fallite, così puoi ritentarle senza rifare tutto da capo.
- Usa un database per progetti grandi. Un semplice database SQLite scala molto meglio dei file CSV che continuano a crescere:
import sqlite3
conn = sqlite3.connect("reviews.db")
df.to_sql("reviews", conn, if_exists="append", index=False)
- Programma scraping ricorrenti. Per un monitoraggio continuativo, imposta un cron job oppure usa la funzione Scheduled Scraper di Thunderbit — descrivi l’URL e la frequenza, e il resto viene gestito senza bisogno di un server.
Per altri approcci, i nostri articoli su i migliori strumenti automatici di web scraping e su come estrarre dati dai siti web in Excel coprono ulteriori opzioni.
Una nota rapida su aspetti legali ed etici
Le Condizioni d’uso di Amazon vietano esplicitamente “l’uso di robot, spider, scraper o altri mezzi automatizzati per accedere ai servizi Amazon.” Detto questo, la giurisprudenza recente negli Stati Uniti è stata favorevole allo scraping di dati pubblici. In Meta Platforms v. Bright Data (gennaio 2024), un tribunale federale ha stabilito che lo scraping di dati accessibili pubblicamente non viola i termini di servizio quando lo scraper non è un “utente” autenticato.
La distinzione importante è questa: fare scraping dietro login (che è ciò che copre questo tutorial) ti porta nel campo del diritto contrattuale, perché hai accettato i ToS di Amazon quando hai creato l’account. Estrarre le featured reviews pubblicamente visibili comporta meno rischi legali rispetto allo scraping dietro il login wall.
Linee guida pratiche: non ridistribuire commercialmente i dati raccolti, non raccogliere dati personali oltre quelli già visibili pubblicamente, rispetta robots.txt e, per usi su larga scala o commerciali, consulta un legale. Questo non è un parere legale. Per saperne di più sul quadro normativo, vedi il nostro approfondimento su implicazioni legali del web scraping.
Conclusione: fai scraping delle recensioni Amazon con Python o elimina del tutto il codice
Ricapitolando cosa abbiamo visto in questa guida:
- Il login wall esiste, ma si può superare con l’autenticazione basata sui cookie — copia 7 cookie dal browser e inseriscili in una
requests.Session() - Usa selettori
data-hook, non classi CSS, per un’estrazione che non si rompa ogni poche settimane - Combina filtri stelle e ordini per superare il limite di 10 pagine e arrivare a 500+ recensioni per prodotto
- Aggiungi un’analisi del sentiment con TextBlob per una base rapida o con Hugging Face Transformers per una precisione da produzione
- Tieni attive le difese anti-bot: throttling, rotazione User-Agent, exponential backoff e proxy residenziali quando serve scala
Python ti offre il controllo totale ed è il modo migliore per capire cosa succede sotto il cofano. Ma se il tuo bisogno è “mi servono i dati delle recensioni dei concorrenti in un foglio di calcolo entro venerdì” più che “voglio costruire una pipeline dati in produzione”, il costo di manutenzione di uno scraper custom potrebbe non valere lo sforzo.
Thunderbit gestisce autenticazione, selettori, paginazione ed export con pochi clic — prova il piano gratuito e vedi se si adatta al tuo flusso di lavoro. Mentre Amazon continua a rafforzare le misure anti-bot, gli strumenti basati su AI che si adattano in tempo reale passeranno da “optional interessante” a necessità vera e propria.
Puoi anche esplorare il nostro canale YouTube di Thunderbit per video tutorial sui flussi di scraping.
FAQ
1. Si possono estrarre le recensioni Amazon senza fare login?
Sì, ma solo le circa 8 “featured reviews” mostrate nella pagina dettaglio prodotto (/dp/{ASIN}/). Le pagine complete delle recensioni, con ordinamento, filtri e paginazione, richiedono l’autenticazione dalla fine del 2024. Per la maggior parte dei casi d’uso business, devi gestire il login wall.
2. È legale fare scraping delle recensioni Amazon?
I Termini di servizio di Amazon vietano lo scraping automatizzato. Tuttavia, la giurisprudenza recente negli Stati Uniti (Meta v. Bright Data, 2024; hiQ v. LinkedIn) supporta lo scraping di dati accessibili pubblicamente. Lo scraping dietro login comporta un rischio legale maggiore, perché hai accettato i ToS di Amazon. Per usi commerciali, consulta un legale.
3. Quante recensioni Amazon posso estrarre per prodotto?
Amazon limita le pagine recensioni a 10 per ogni combinazione di ordinamento e filtro stelle. Usando tutti e 5 i filtri stelle × 2 ordini, puoi accedere fino a 100 pagine (circa 1.000 recensioni) per prodotto. Con i filtri per parole chiave, il limite teorico è molto più alto, anche se con una duplicazione significativa.
4. Qual è la miglior libreria Python per estrarre recensioni Amazon?
requests + BeautifulSoup per il parsing dell’HTML statico è la combinazione più comune e affidabile. Selenium è utile quando è necessario il rendering JavaScript. Per un’alternativa no-code che gestisce automaticamente login wall e paginazione, prova Thunderbit.
5. Come posso evitare di essere bloccato أثناء lo scraping di Amazon?
Ruota le stringhe User-Agent scegliendole da un pool di 10+ browser reali, aggiungi ritardi casuali di 2–5 secondi tra le richieste, implementa exponential backoff sugli errori 503/429, usa proxy residenziali quando lavori su scala (gli IP dei datacenter vengono bloccati in anticipo) e mantieni cookie di sessione coerenti tra le richieste. Per un approccio senza manutenzione, Thunderbit gestisce automaticamente le difese anti-bot tramite la sessione del browser.
Scopri di più
