Come estraggo le recensioni Amazon con Python (superando il login wall)

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 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 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 (e non li ha mai reinseriti), lo scraping web è l’unico modo programmatico per accedere a questi dati.

I numeri confermano quanto sia importante. e . Mostrare solo 5 recensioni su una pagina prodotto può . Le aziende che analizzano sistematicamente il sentiment delle recensioni vedono . 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 , 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:

Un brand di utensili da cucina , ha riformulato il prodotto e ha riconquistato la posizione di Best Seller numero 1 entro 60 giorni. Un’azienda di fitness tracker , 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, . La modifica è stata confermata sia nei sia nei . 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 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:

1pip install requests beautifulsoup4 lxml pandas textblob

Opzionale (per sentiment analysis avanzata):

1pip 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:

Come estrarre i cookie da Chrome DevTools

1. Accedi ad amazon.com in Chrome
2. Apri DevTools (F12 oppure tasto destro → Ispeziona)
3. Vai su Application → Storage → Cookies → https://www.amazon.com
4. Trova ogni cookie nella tabella e copia il valore
5. Formattali come stringa separata da punto e virgola per Python

Imposta la sessione così:

1import requests
2session = requests.Session()
3# Incolla qui i valori dei cookie
4cookies = {
5    "session-id": "YOUR_SESSION_ID",
6    "session-id-time": "YOUR_SESSION_ID_TIME",
7    "session-token": "YOUR_SESSION_TOKEN",
8    "ubid-main": "YOUR_UBID_MAIN",
9    "at-main": "YOUR_AT_MAIN",
10    "sess-at-main": "YOUR_SESS_AT_MAIN",
11    "x-main": "YOUR_X_MAIN",
12}
13headers = {
14    "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",
15    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
16    "Accept-Language": "en-US,en;q=0.5",
17}
18session.cookies.update(cookies)
19session.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:

1https://www.amazon.com/product-reviews/{ASIN}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1

La funzione principale:

1from bs4 import BeautifulSoup
2import time, random
3def get_soup(session, url):
4    time.sleep(random.uniform(2, 5))  # Ritardo prudente
5    response = session.get(url, timeout=15)
6    # Rileva il login wall
7    if "ap_email" in response.text or "Amazon Sign-In" in response.text:
8        raise Exception("Rilevato login wall — aggiorna i cookie")
9    if response.status_code != 200:
10        raise Exception(f"HTTP {response.status_code}")
11    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.

1# Visita prima la pagina prodotto (simula una navigazione reale)
2product_url = f"https://www.amazon.com/dp/{asin}"
3session.get(product_url, timeout=15)
4time.sleep(random.uniform(1, 3))
5# Poi apri la pagina delle recensioni
6reviews_url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1"
7soup = 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.

Il codice di estrazione con i selettori data-hook:

1import re
2def extract_reviews(soup):
3    reviews = []
4    review_divs = soup.select('[data-hook="review"]')
5    for div in review_divs:
6        # Valutazione a stelle
7        rating_el = div.select_one('[data-hook="review-star-rating"]')
8        rating = None
9        if rating_el:
10            rating_text = rating_el.get_text(strip=True)
11            match = re.search(r'(\d\.?\d?)', rating_text)
12            if match:
13                rating = float(match.group(1))
14        # Titolo
15        title_el = div.select_one('[data-hook="review-title"]')
16        title = title_el.get_text(strip=True) if title_el else ""
17        # Corpo
18        body_el = div.select_one('[data-hook="review-body"]')
19        body = body_el.get_text(strip=True) if body_el else ""
20        # Autore
21        author_el = div.select_one('span.a-profile-name')
22        author = author_el.get_text(strip=True) if author_el else ""
23        # Data e Paese
24        date_el = div.select_one('[data-hook="review-date"]')
25        date_text = date_el.get_text(strip=True) if date_el else ""
26        # Formato: "Reviewed in the United States on January 15, 2025"
27        country_match = re.search(r'Reviewed in (.+?) on', date_text)
28        date_match = re.search(r'on (.+)$', date_text)
29        country = country_match.group(1) if country_match else ""
30        date = date_match.group(1) if date_match else ""
31        # Acquisto verificato
32        verified_el = div.select_one('[data-hook="avp-badge"]')
33        verified = bool(verified_el)
34        reviews.append({
35            "author": author,
36            "rating": rating,
37            "title": title,
38            "content": body,
39            "date": date,
40            "country": country,
41            "verified": verified,
42        })
43    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:

1all_reviews = []
2for page in range(1, 11):
3    url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber={page}"
4    soup = get_soup(session, url)
5    page_reviews = extract_reviews(soup)
6    if not page_reviews:
7        break  # Nessuna recensione in questa pagina
8    all_reviews.extend(page_reviews)
9    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.

1star_filters = ["one_star", "two_star", "three_star", "four_star", "five_star"]
2sort_orders = ["recent", "helpful"]
3all_reviews = []
4seen_titles = set()  # Deduplicazione semplice
5for star in star_filters:
6    for sort in sort_orders:
7        for page in range(1, 11):
8            url = (
9                f"https://www.amazon.com/product-reviews/{asin}"
10                f"?filterByStar={star}&sortBy={sort}&pageNumber={page}"
11            )
12            soup = get_soup(session, url)
13            page_reviews = extract_reviews(soup)
14            if not page_reviews:
15                break
16            for review in page_reviews:
17                # Deduplica con la combinazione titolo + autore
18                key = (review["title"], review["author"])
19                if key not in seen_titles:
20                    seen_titles.add(key)
21                    all_reviews.append(review)
22            print(f"[{star}/{sort}] Pagina {page}: {len(page_reviews)} recensioni")
23print(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ù.

Un wrapper di retry pronto per la produzione:

1import time, random
2USER_AGENTS = [
3    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
4    "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",
5    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0",
6    "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",
7    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36",
8]
9def scrape_with_retries(session, url, max_retries=3):
10    for attempt in range(max_retries):
11        try:
12            session.headers["User-Agent"] = random.choice(USER_AGENTS)
13            time.sleep(random.uniform(2, 5))
14            response = session.get(url, timeout=15)
15            # Rileva i blocchi
16            if "validateCaptcha" in response.url or "Robot Check" in response.text:
17                wait = (2 ** attempt) * 5
18                print(f"CAPTCHA rilevato. Attendo {wait}s...")
19                time.sleep(wait)
20                continue
21            if response.status_code in (429, 503):
22                wait = (2 ** attempt) * 2
23                print(f"Limitazione rate ({response.status_code}). Attendo {wait}s...")
24                time.sleep(wait)
25                continue
26            if "ap_email" in response.text:
27                raise Exception("Login wall — cookie scaduti")
28            return BeautifulSoup(response.text, "lxml")
29        except Exception as e:
30            if attempt == max_retries - 1:
31                raise
32            print(f"Tentativo {attempt + 1} fallito: {e}")
33    return None

Una nota sui proxy: Amazon (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 . 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:

1import pandas as pd
2df = pd.DataFrame(all_reviews)
3df.to_csv("amazon_reviews.csv", index=False)
4print(f"Esportate {len(df)} recensioni in amazon_reviews.csv")

Output di esempio:

Per esportare in Excel: df.to_excel("amazon_reviews.xlsx", index=False) (richiede openpyxl).

Per Google Sheets, la libreria gspread funziona ma richiede — 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 , 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:

1from textblob import TextBlob
2df["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:

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. , e rispetto agli strumenti lessicali. Il modello nlptown/bert-base-multilingual-uncased-sentiment può persino prevedere direttamente valutazioni da 1 a 5 stelle:

1from transformers import pipeline
2clf = pipeline("sentiment-analysis",
3               model="nlptown/bert-base-multilingual-uncased-sentiment")
4df["predicted_stars"] = df["content"].apply(
5    lambda x: int(clf(str(x)[:512])[0]["label"][0])
6)

Le recensioni Amazon seguono una — 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:

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 proprio per gestire quei casi in cui mantenere uno scraper Python sembra eccessivo. Il flusso è questo:

1. Installa l’
2. Vai alla pagina delle recensioni del prodotto Amazon nel browser (sei già loggato, quindi il login wall non è un problema)
3. Clicca “AI Suggest Fields” — Thunderbit legge la pagina e propone colonne come Autore, Valutazione, Titolo, Testo recensione, Data, Acquisto verificato
4. Clicca “Scrape” — i dati vengono estratti subito, con paginazione integrata
5. 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 — 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 e .

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:

1import sqlite3
2conn = sqlite3.connect("reviews.db")
3df.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 e coprono ulteriori opzioni.

Una nota rapida su aspetti legali ed etici

I 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 , 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 .

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.

gestisce autenticazione, selettori, paginazione ed export con pochi clic — prova il 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 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 .

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ù