Il mio scraper di recensioni Amazon ha funzionato alla perfezione per sei settimane — poi una mattina ha restituito 200 OK e una pagina completamente vuota. Nessun errore, nessun CAPTCHA, solo HTML vuoto dove prima c’erano centinaia di recensioni.
Se ti suona familiare, non sei il solo. Alla fine del 2025, Amazon ha iniziato a bloccare l’accesso alle pagine complete delle recensioni dietro un login wall, e moltissimi script Python per lo scraping si sono rotti da un giorno all’altro. Negli ultimi mesi ho lavorato in Thunderbit sul problema da due prospettive — sviluppando il nostro scraper AI e mantenendo anche la mia pipeline Python per le recensioni — quindi ho pensato fosse il momento di scrivere la guida che avrei voluto avere quando il mio script ha smesso di funzionare. Questo articolo copre l’approccio che funziona davvero: autenticazione basata su cookie, selettori stabili che resistono all’offuscamento CSS di Amazon, soluzioni alternative al limite di 10 pagine, difese anti-bot e, come bonus, una sezione di sentiment analysis che trasforma il testo grezzo delle recensioni in insight di business concreti. E se a metà lettura pensi: “Preferirei non dover mantenere tutto questo codice”, ti mostrerò come Thunderbit gestisce la stessa attività in circa due minuti, senza bisogno di Python.
Che cos’è lo scraping delle recensioni Amazon (e perché conta)?
Lo scraping delle recensioni Amazon è il processo di estrazione automatica dei dati delle recensioni dei clienti — valutazioni a 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 (e non li ha mai reinseriti), lo scraping web è l’unico modo programmatico per accedere a questi dati.
I numeri confermano quanto sia importante. Il 95% degli acquirenti legge le recensioni prima di comprare e il 94% indica Amazon come fonte numero uno per le recensioni dei prodotti. Mostrare solo 5 recensioni su una pagina prodotto può aumentare le conversioni del 270%. Le aziende che analizzano sistematicamente il sentiment delle recensioni vedono fino al 15% di retention clienti in più. Non si tratta di data science astratta: è competitive intelligence, segnali per migliorare il prodotto e linguaggio marketing, tutto in chiaro sui server di Amazon.
Perché fare scraping delle recensioni Amazon con Python
Python resta il linguaggio di riferimento per questo lavoro. È il linguaggio più desiderato nel 2024 secondo lo Stack Overflow Developer Survey, e il suo ecosistema — requests, BeautifulSoup, pandas, Scrapy — rende lo scraping accessibile anche a chi non è uno sviluppatore full-time.
Team diversi usano questi dati in modi diversi:
| Team | Caso d’uso | Cosa estraggono |
|---|---|---|
| Prodotto / R&D | Individuare reclami ricorrenti, dare priorità ai fix | Testi delle recensioni da 1–2 stelle, frequenza delle keyword |
| Vendite | Monitorare il sentiment dei prodotti dei concorrenti | Valutazioni, andamento del volume di recensioni |
| Marketing | Trovare il linguaggio dei clienti per i copy pubblicitari | Frasi positive, menzioni delle funzionalità |
| Ecommerce Ops | Tracciare nel tempo il sentiment dei propri prodotti | Distribuzione delle stelle, rapporto di acquisti verificati |
| Market Research | Confrontare i leader di categoria per funzionalità | Dataset di recensioni multi-ASIN |
Un brand di utensili da cucina ha analizzato le recensioni negative e scoperto che il 22% citava “il rivestimento antiaderente si rovina”, ha riformulato il prodotto e ha riconquistato la posizione di Best Seller numero 1 entro 60 giorni. Un’azienda di fitness tracker ha individuato “irritazione del cinturino” nel testo delle recensioni, ha rilevato un problema legato al lattice, ha lanciato una variante ipoallergenica e ha ridotto i resi del 40%. Questo è il tipo di ROI che giustifica lo sforzo tecnico.
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 visualizzare la pagina completa delle recensioni prodotto. La modifica è stata confermata sia nei forum della community sia nei blog dei provider di scraping. Se visiti /product-reviews/{ASIN}/ in una finestra in incognito, verrai reindirizzato a una pagina di login invece che ai dati delle recensioni.
I sintomi sono subdoli: lo script riceve una risposta 200 OK, ma nel corpo HTML trovi un modulo di accesso (name="email", id="ap_password") invece delle recensioni. Nessun codice di errore. Nessun CAPTCHA. Solo… nulla di utile.
Amazon ha introdotto questa protezione per motivi anti-bot e di conformità regionale. L’applicazione è incoerente — a volte una finestra del browser appena aperta mostra alcune recensioni prima che scatti il blocco, soprattutto nella prima pagina — ma per qualunque scraper che funzioni su larga scala, devi considerare il login wall sempre attivo.
I diversi domini Amazon per Paese (.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. Si tratta di recensioni selezionate dall’algoritmo di Amazon e sono utili per un controllo rapido del sentiment, ma non sono ordinabili, filtrabili né paginabili.
Le pagine complete delle recensioni (/product-reviews/{ASIN}/) — con ordinamento per più recenti, filtro per valutazione e navigazione su centinaia di recensioni — richiedono il login.
Se ti servono solo poche recensioni per un check veloce, puoi estrarle dalla pagina prodotto. Se invece ti servono centinaia o migliaia di dati, dovrai gestire l’autenticazione.
Cosa ti serve prima di iniziare: setup Python e librerie
Prima di scrivere codice, ecco la configurazione:
- Difficoltà: intermedia (padronanza di Python, conoscenze base di HTML)
- Tempo richiesto: ~45 minuti per l’intera pipeline; ~10 minuti per uno scrape base
- Cosa ti serve: Python 3.8+, browser Chrome, un account Amazon valido
Installa le librerie principali:
pip install requests beautifulsoup4 lxml pandas textblob
Opzionale (per sentiment analysis avanzata):
pip install transformers torch
Cos’è un ASIN? È l’identificativo prodotto di Amazon a 10 caratteri. Lo trovi in qualsiasi URL prodotto — per esempio, in amazon.com/dp/B0BCNKKZ91, l’ASIN è B0BCNKKZ91. È la chiave che userai nell’URL delle recensioni.
Passo 1: superare il login wall con l’autenticazione basata su cookie
L’approccio più affidabile è effettuare l’accesso ad Amazon nel browser, copiare i cookie di sessione e iniettarli nella requests.Session() di Python. In questo modo eviti i CAPTCHA e la 2FA via SMS che spesso complicano l’automazione del login con Selenium.
Ti servono questi sette cookie:
| Nome cookie | Scopo |
|---|---|
session-id | Identificatore di sessione rotante |
session-id-time | Timestamp della sessione |
session-token | Token di sessione rotante |
ubid-main | Identificatore di navigazione dell’utente |
at-main | Token di autenticazione principale |
sess-at-main | Autenticazione limitata alla sessione |
x-main | Identificatore associato all’email dell’utente |
Come estrarre i cookie da Chrome DevTools
- Accedi ad amazon.com in Chrome
- Apri DevTools (F12 oppure tasto destro → Ispeziona)
- Vai su Application → Storage → Cookies →
https://www.amazon.com - Trova ogni cookie nella tabella e copia il valore
- Formattali come stringa separata da punto e virgola per Python
Imposta 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. Questo mantiene coerenti i cookie e imita una normale sessione del browser. I cookie in genere durano da giorni a settimane sotto carico di scraping, ma se inizi a ricevere di nuovo reindirizzamenti al login, aggiornali dal browser.
Per i marketplace non .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 separata.
Passo 2: costruire la richiesta e analizzare l’HTML delle recensioni con BeautifulSoup
L’URL delle recensioni Amazon segue questo schema:
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)) # Ritardo prudente
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("Rilevato login wall — 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. In questo modo la sessione segue un comportamento di navigazione più naturale.
# Visita prima la pagina prodotto (simula una 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 delle 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)
Passo 3: usa selettori stabili per estrarre i dati delle recensioni (smetti di affidarti alle classi CSS)
Qui crollano la maggior parte dei tutorial del 2022–2023. Amazon offusca i nomi delle classi CSS — cambiano periodicamente e, come ha scritto un sviluppatore frustrato in un thread di forum, “nessuno aveva un pattern unico per i nomi delle classi dei tag span”.
La soluzione: Amazon usa attributi data-hook sugli elementi delle recensioni, e questi 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 a 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 a 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
Uso questo set di selettori contro più ASIN da mesi, e gli attributi data-hook non sono mai cambiati. Le classi CSS, invece, sono cambiate almeno due volte nello stesso periodo.
Passo 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 scompare dopo la decima pagina.
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 bucketing dei filtri. Ogni combinazione di filterByStar e sortBy ha una propria finestra indipendente di 10 pagine.
Valori del filtro stelle: one_star, two_star, three_star, four_star, five_star
Valori di ordinamento: recent, helpful (predefinito)
Combinando tutti e 5 i filtri stellari × 2 ordinamenti, puoi accedere fino a 100 pagine, cioè 1.000 recensioni per prodotto — e per prodotti con distribuzioni di stelle sbilanciate, spesso riesci ad avvicinarti al set completo.
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 con 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 bucket, quindi la deduplicazione è fondamentale. Io uso la combinazione titolo della recensione + nome autore come chiave rapida — non è perfetta, ma intercetta la grande maggioranza dei duplicati.
Passo 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 singolo livello (solo rotazione degli User-Agent, solo ritardi aggiuntivi) 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 |
| Limitazione richieste | random.uniform(2, 5) secondi tra una pagina e l’altra |
| Rotazione proxy | Ciclo tra proxy residenziali |
| Fingerprint di sessione | Cookie e header coerenti per ogni sessione |
| Impersonificazione TLS | Usare curl_cffi invece di requests puro in produzione |
Un wrapper di retry pronto per la 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 i 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"Limitazione rate ({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
Una nota sui proxy: Amazon blocca gli intervalli IP noti dei datacenter (AWS, GCP, Azure, DigitalOcean) a livello di rete. Se fai scraping di più di qualche centinaio di pagine, i proxy residenziali diventano praticamente obbligatori — aspettati una spesa di 50–200+ dollari al mese, a seconda del volume. Per progetti piccoli (meno di 100 richieste al giorno), un throttling attento dal tuo IP domestico spesso basta.
Amazon inoltre analizza le impronte TLS. La libreria requests di Python ha un hash JA3 ben noto che i WAF bloccano in anticipo. Per scraper in produzione, valuta curl_cffi, che impersona stack TLS reali dei browser. Per scraping su scala tutorial (qualche centinaio di pagine), requests con header ben configurati di solito è sufficiente.
Passo 6: esportare le recensioni Amazon estratte in CSV o Excel
Una volta raccolte le recensioni, trasformarle in un formato utilizzabile è 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")
Output di esempio:
| author | rating | title | content | date | country | verified |
|---|---|---|---|---|---|---|
| Sarah M. | 5.0 | Miglior acquisto dell’anno | La batteria dura tutto il giorno, lo schermo è bellissimo... | 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 ciò che mi serve, solo un po’ di lag 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ù lavoro della fase di scraping, non hai torto. (È uno di quei momenti in cui uno strumento come Thunderbit, che esporta su Google Sheets con un clic, diventa davvero molto attraente.)
Bonus: aggiungi sentiment analysis alle recensioni estratte in 5 righe di Python
La maggior parte dei tutorial sullo scraping si ferma all’esportazione CSV. Ma assegnare un punteggio al sentiment è ciò che trasforma i dati grezzi in decisioni di business.
Il baseline più rapido usa 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. Output di esempio:
| content (troncato) | rating | sentiment |
|---|---|---|
| "Battery lasts all day, screen is gorgeous..." | 5.0 | 0.65 |
| "The charging port stopped working after..." | 2.0 | -0.40 |
| "Does everything I need, minor lag on..." | 4.0 | 0.25 |
| "Absolute garbage. Returned immediately." | 1.0 | -0.75 |
| "It's okay. Nothing special but works." | 3.0 | 0.10 |
Le righe più interessanti sono quelle incongruenti — una recensione da 3 stelle con testo positivo, oppure una da 5 stelle con linguaggio negativo. Queste discrepanze spesso rivelano opinioni sfumate che le sole stelle non mostrano.
Per una precisione di livello produttivo, il consiglio è Hugging Face Transformers. VADER è stato addestrato sui tweet, non sulle recensioni dei prodotti, 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 valutazioni 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 proxy della qualità reale del prodotto. Segmenta il cluster da 1 stella e cerca i temi ricorrenti: di solito è lì che si nasconde il difetto risolvibile.
Il compromesso onesto: Python fai-da-te vs. API di scraping a pagamento vs. Thunderbit
Ho gestito scraper Python per Amazon e, onestamente, si rompono. I selettori cambiano, i cookie scadono, Amazon introduce un nuovo livello di rilevamento bot e all’improvviso il tuo sabato mattina finisce a debuggare uno scraper invece che ad analizzare dati. Gli utenti nei forum riportano la stessa frustrazione — script fai-da-te che “funzionavano il mese scorso” 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 (+ costi proxy) | $50–200+/mese | Piano gratuito disponibile |
| Gestione login wall | Gestione manuale dei cookie | Di solito gestita | Gestita automaticamente |
| Manutenzione | Alta (i selettori si rompono) | Bassa (il provider mantiene) | Zero (l’AI si adatta) |
| Paginazione | Serve codice personalizzato | Integrata | Integrata |
| Supporto multi-paese | Sessioni separate per dominio | Di solito supportato | Basato sul browser = tua locale |
| Sentiment analysis | Devi aggiungere il tuo codice | A volte inclusa | Esporta su Sheets, analizza ovunque |
| Ideale per | Apprendimento, controllo totale | Pipeline di produzione e scalabilità | Estrazioni rapide, team non tecnici |
Python ti dà il controllo totale 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 l’uptime conta più del costo. E per i team che hanno bisogno dei dati delle recensioni senza il sovraccarico di sviluppo — ecommerce ops che monitorano i concorrenti ogni settimana, team marketing che estraggono il linguaggio dei clienti per i copy — esiste una terza strada.
Come estrarre le recensioni Amazon con Thunderbit (senza codice, senza manutenzione)
Abbiamo creato Thunderbit proprio per gestire quei casi in cui mantenere uno scraper Python sembra eccessivo. Il flusso è questo:
- Installa l’estensione Chrome di Thunderbit
- Vai alla pagina delle recensioni del prodotto Amazon nel browser (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 rilegge la struttura della pagina ogni volta. Niente selettori CSS da mantenere, niente gestione cookie, niente codice anti-bot. Quando Amazon modifica l’HTML, l’AI si adatta. Per chi vuole un accesso programmatico senza dover gestire tutto manualmente, Thunderbit offre anche una Extract API — estrazione strutturata via API con rilevamento campi basato su AI, senza manutenzione dei selettori.
Per approfondimenti sui dati Amazon, vedi anche le nostre guide su come estrarre prodotti e recensioni Amazon e come estrarre e analizzare i dati di vendita Amazon.
Consigli per fare scraping delle recensioni Amazon su larga scala con Python
Se estrai recensioni su molti ASIN, alcuni accorgimenti ti eviteranno parecchi problemi:
- Raggruppa gli ASIN con pause tra un prodotto e l’altro, non solo tra una pagina e l’altra. Io uso pause di 10–15 secondi tra ASIN.
- Deduplica in modo aggressivo. Quando combini più filtri stelle e ordinamenti, 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 riscrapare tutto.
- Usa un database per i progetti grandi. Un semplice database SQLite scala molto meglio dei file CSV sempre più grandi:
import sqlite3
conn = sqlite3.connect("reviews.db")
df.to_sql("reviews", conn, if_exists="append", index=False)
- Pianifica scraping ricorrenti. Per un monitoraggio continuo, imposta un cron job oppure usa la funzione Scheduled Scraper di Thunderbit — descrivi l’URL e la frequenza, e lui fa il resto senza bisogno di un server.
Per altri approcci, i nostri articoli su i migliori strumenti di web scraping automatizzato e come estrarre dati da un sito web in Excel coprono ulteriori opzioni.
Una nota rapida su aspetti legali ed etici
I Termini di utilizzo di Amazon vietano esplicitamente “l’uso di robot, spider, scraper o altri mezzi automatizzati per accedere ai servizi Amazon”. Detto questo, la recente giurisprudenza statunitense è stata favorevole agli scraper 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 sfumatura importante: fare scraping dietro login (che è proprio ciò che copre questo tutorial) ti porta nell’ambito del diritto contrattuale, perché hai accettato i ToS di Amazon quando hai creato l’account. Lo scraping delle featured reviews visibili pubblicamente comporta meno rischi legali rispetto allo scraping oltre il login wall.
Linee guida pratiche: non ridistribuire commercialmente i dati estratti, non raccogliere dati personali degli utenti oltre ciò che è già mostrato pubblicamente, rispetta robots.txt e consulta un legale per usi su larga scala o commerciali. Questo non è un parere legale. Per approfondire il quadro normativo, vedi la nostra panoramica sulle implicazioni legali del web scraping.
Conclusione: estrai le recensioni Amazon con Python o salta del tutto il codice
Riassunto rapido di ciò che abbiamo visto in questa guida:
- Il login wall è reale, ma si può superare con l’autenticazione basata su 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 per stelle e ordinamenti per aggirare il limite di 10 pagine e accedere a 500+ recensioni per prodotto
- Aggiungi sentiment analysis con TextBlob per un baseline rapido oppure con Hugging Face Transformers per una precisione adatta alla produzione
- Mantieni difese anti-bot: throttling, rotazione degli User-Agent, exponential backoff e proxy residenziali per scalare
Python ti dà pieno controllo ed è il modo migliore per capire cosa succede sotto il cofano. Ma se il tuo caso d’uso è “mi serve un foglio con le recensioni dei concorrenti entro venerdì” e non “voglio costruire una pipeline dati di produzione”, il costo di manutenzione di uno scraper personalizzato potrebbe non valere la pena.
Thunderbit gestisce autenticazione, selettori, paginazione ed export con pochi clic — prova il piano gratuito e verifica se si adatta al tuo flusso di lavoro. Mentre Amazon continua a rafforzare le difese anti-bot, gli strumenti basati su AI che si adattano in tempo reale diventeranno sempre meno un optional e sempre più una necessità.
Puoi anche visitare il nostro canale YouTube di Thunderbit per tutorial video sui flussi di scraping.
FAQ
1. Si possono estrarre recensioni Amazon senza effettuare il login?
Sì, ma solo le circa 8 “featured reviews” mostrate nella pagina 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, dovrai 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 pubblicamente accessibili. Lo scraping dietro login comporta un rischio legale più alto, 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 di recensioni a 10 per ogni combinazione di ordinamento e filtro stelle. Usando tutti e 5 i filtri stelle × 2 ordinamenti, puoi accedere fino a 100 pagine (circa 1.000 recensioni) per prodotto. Con i filtri per keyword, il limite teorico è molto più alto, anche se con molta duplicazione.
4. Qual è la migliore libreria Python per estrarre recensioni Amazon?
requests + BeautifulSoup per il parsing HTML statico è la combinazione più comune e affidabile. Selenium è utile quando serve il rendering JavaScript. Per un’alternativa no-code che gestisce automaticamente login wall e paginazione, prova Thunderbit.
5. Come faccio a evitare il blocco durante lo scraping di Amazon?
Ruota le stringhe User-Agent 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 per scalare (gli IP dei datacenter vengono spesso bloccati in anticipo) e mantieni cookie di sessione coerenti tra le richieste. Per un approccio senza manutenzione, Thunderbit gestisce automaticamente le difese anti-bot attraverso la tua sessione browser.
Scopri di più
