Scopri come estrarre prodotti Amazon con Python

Se hai seguito un tutorial sullo scraping di Amazon e ti sei ritrovato davanti a CAPTCHA, errori 503 o risultati completamente vuoti, benvenuto nel club. La maggior parte delle guide Python per estrarre prodotti amazon con python che circolano online è stata scritta nel 2022 o nel 2023 e usa selettori e tecniche che Amazon ha ormai corretto da tempo.

Da anni sviluppo strumenti di estrazione dati in Thunderbit e una cosa posso dirtela per esperienza diretta: Amazon è uno dei siti più difficili da scrappare in modo affidabile. La piattaforma cambia continuamente la struttura HTML, usa una difesa anti-bot a più livelli e mostra persino layout diversi a utenti diversi tramite test A/B. In questa guida ti accompagnerò nella realizzazione di uno scraper Python per Amazon che funziona davvero nel 2025 — con selettori CSS verificati, una strategia anti-blocco stratificata e indicazioni su pianificazione ed esportazione che la maggior parte dei tutorial ignora del tutto. E per chi ha bisogno solo dei dati senza impazzire con Python, ti mostrerò anche come può fare lo stesso lavoro in un paio di clic.

Che cos'è lo scraping dei prodotti Amazon?

Lo scraping dei prodotti Amazon è il processo di estrazione programmatica di dati pubblicamente disponibili — nome del prodotto, prezzo, valutazioni, numero di recensioni, immagini, disponibilità e altro — dalle pagine prodotto e dalle pagine dei risultati di ricerca di Amazon. Invece di copiare manualmente le informazioni da centinaia di inserzioni, uno scraper visita ogni pagina, legge l'HTML e raccoglie i dati che hai definito in un formato strutturato come CSV, Excel o un database.

Immaginalo come assumere uno stagista instancabile che riesce a visitare mille pagine prodotto nel tempo che tu impieghi per finire il caffè del mattino. Solo che questo stagista non sbaglia mai a scrivere e non ha bisogno della pausa pranzo.

Perché scrappare i prodotti Amazon con Python?

Amazon ospita circa in oltre 30 categorie, alimentate da circa . I venditori terzi rappresentano oggi il 69% del GMV totale. Monitorare manualmente anche solo una piccola parte di questo catalogo è impossibile. Ecco perché i team scrappano Amazon:

La sola scala dei prezzi di Amazon rende l'automazione indispensabile: Amazon modifica i prezzi , con un aggiornamento medio del prezzo di ogni prodotto circa ogni 10 minuti. Al contrario, concorrenti come Best Buy e Walmart cambiano i prezzi solo circa 50.000 volte al mese. Nessun team umano può stare al passo.

Python ti offre il pieno controllo del processo di scraping: decidi cosa estrarre, come gestire gli errori e dove salvare i dati. Ma significa anche che sei tu a dover gestire manutenzione, anti-blocco e aggiornamenti continui quando Amazon cambia l'HTML.

Cosa puoi estrarre da Amazon e cosa no

Dalle pagine prodotto pubblicamente accessibili, in genere puoi estrarre:

• Titolo del prodotto (nome, brand)
• Prezzo (attuale, originale, prezzo scontato)
• Valutazione (media stelle)
• Numero di recensioni
• Immagini del prodotto (URL dell'immagine principale)
• Disponibilità / stato stock
• ASIN (Amazon Standard Identification Number)
• Descrizione del prodotto e punti elenco
• Informazioni sul venditore
• Varianti del prodotto (taglia, colore, ecc.)

Quello che dovresti evitare:

• Dati dietro login: pagine recensioni estese, dati dell'account personale, storico ordini
• Informazioni personali: nomi degli acquirenti, indirizzi, dati di pagamento
• Contenuti protetti da copyright da ripubblicare: descrizioni e immagini vanno bene per l'analisi, ma non ripubblicarli come se fossero tuoi

Il di Amazon blocca oltre 50 bot nominati (tra cui GPTBot, Scrapy e ClaudeBot) e vieta percorsi come account utente, carrelli e wishlist. Le pagine dettaglio prodotto non sono esplicitamente vietate, ma i Termini di servizio di Amazon proibiscono l'accesso automatizzato. I tribunali, in generale, distinguono tra violazioni dei ToS (questione civile) e violazioni penali sotto il CFAA — ne parleremo meglio alla fine della guida.

Strumenti e librerie necessari

Ecco lo stack Python per questo tutorial:

Opzionale (per contenuti renderizzati via JavaScript):

• selenium o playwright — automazione di browser headless

Configurare l'ambiente Python

Apri il terminale ed esegui:

1mkdir amazon-scraper && cd amazon-scraper
2python -m venv venv
3source venv/bin/activate  # Su Windows: venv\Scripts\activate
4pip install requests beautifulsoup4 lxml curl_cffi pandas

Verifica che tutto sia installato:

1import requests, bs4, curl_cffi, pandas
2print("Tutto ok!")

Se vedi "Tutto ok!" senza errori, sei pronto.

Perché la maggior parte dei tutorial di scraping Amazon smette di funzionare (e perché questo è diverso)

Questa è la parte che la maggior parte delle guide salta, ed è anche il motivo per cui probabilmente stai leggendo questo articolo.

Amazon aggiorna spesso la struttura HTML, i nomi delle classi e gli ID degli elementi. La community dello scraping segnala che dei crawler richiede correzioni settimanali a causa di modifiche al DOM e al fingerprinting. La vittima più famosa? Il selettore #priceblock_ourprice, comparso in centinaia di tutorial dal 2018 al 2023. Quel ID non esiste più nelle pagine prodotto di Amazon.

Ecco un confronto rapido tra ciò che non funziona più e ciò che funziona oggi:

Ogni snippet di codice di questa guida è stato testato su pagine Amazon reali nel 2025. Ti mostrerò i selettori CSS effettivi insieme all'output atteso — niente copia-incolla dal 2022.

Prima di iniziare

• Difficoltà: Intermedio (si presume una conoscenza base di Python)
• Tempo richiesto: ~30–45 minuti per il tutorial completo; ~10 minuti per lo scraper base
• Cosa ti serve: Python 3.9+, browser Chrome (per ispezionare le pagine Amazon), un terminale e, facoltativamente, la se vuoi confrontare l'approccio no-code

Passo 1: invia la tua prima richiesta ad Amazon

Apri qualsiasi pagina prodotto Amazon nel browser e copia l'URL. Partiamo da una semplice requests.get():

1import requests
2url = "https://www.amazon.com/dp/B0DGNFM9YJ"
3response = requests.get(url)
4print(response.status_code)
5print(response.text[:500])

Eseguendo questo codice, molto probabilmente otterrai un codice di stato 503 oppure una pagina che dice "To discuss automated access to Amazon data please contact…". È il WAF di Amazon (Web Application Firewall) che rileva il tuo script Python. Una semplice requests.get() senza header adeguati raggiunge circa un contro Amazon.

Dovresti vedere qualcosa come: 503 e una pagina di blocco nell'HTML. È normale: lo sistemiamo nel prossimo passo.

Passo 2: imposta header personalizzati e impersonificazione TLS

Aggiungere solo un header User-Agent non basta più. Amazon confronta gli header HTTP con il fingerprint TLS. Se dichiari di essere Chrome 120 ma l'handshake TLS rivela la libreria Python requests, vieni .

L'approccio più affidabile nel 2025 è usare curl_cffi con impersonificazione del browser:

1from curl_cffi import requests as cfreq
2headers = {
3    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
4    "Accept-Language": "en-US,en;q=0.9",
5    "Accept-Encoding": "gzip, deflate, br",
6    "Referer": "https://www.google.com/",
7    "DNT": "1",
8    "Connection": "keep-alive",
9    "Upgrade-Insecure-Requests": "1",
10}
11url = "https://www.amazon.com/dp/B0DGNFM9YJ"
12response = cfreq.get(url, headers=headers, impersonate="chrome124")
13print(response.status_code)
14print(len(response.text))

Con curl_cffi che impersona Chrome 124, il tasso di successo sale a circa — un miglioramento di 47 volte rispetto a requests puro. A questo punto dovresti vedere un codice 200 e una risposta HTML molto più lunga (oltre 100.000 caratteri).

Se continui a ricevere un 503, prova un valore diverso per impersonate (ad esempio "chrome131") oppure aggiungi una breve pausa prima di riprovare.

Passo 3: analizza l'HTML ed estrai i dati prodotto

Ora che abbiamo l'HTML completo, estraiamo i dati usando BeautifulSoup con selettori verificati del 2025:

1from bs4 import BeautifulSoup
2soup = BeautifulSoup(response.text, "lxml")
3# Titolo prodotto
4title_el = soup.select_one("span#productTitle")
5title = title_el.get_text(strip=True) if title_el else None
6# Prezzo
7price_el = soup.select_one(
8    "div#corePriceDisplay_desktop_feature_div span.a-price .a-offscreen"
9)
10if not price_el:
11    price_el = soup.select_one("span.priceToPay .a-offscreen")
12if not price_el:
13    price_el = soup.select_one(".apexPriceToPay .a-offscreen")
14price = price_el.get_text(strip=True) if price_el else None
15# Valutazione
16rating_el = soup.select_one("#acrPopover span.a-icon-alt")
17rating = rating_el.get_text(strip=True) if rating_el else None
18# Numero recensioni
19reviews_el = soup.select_one("span#acrCustomerReviewText")
20reviews = reviews_el.get_text(strip=True) if reviews_el else None
21# Disponibilità
22avail_el = soup.select_one("div#availability span")
23availability = avail_el.get_text(strip=True) if avail_el else None
24# URL immagine principale
25img_el = soup.select_one("#landingImage")
26image_url = img_el.get("src") if img_el else None
27print(f"Titolo: {title}")
28print(f"Prezzo: {price}")
29print(f"Valutazione: {rating}")
30print(f"Recensioni: {reviews}")
31print(f"Disponibilità: {availability}")
32print(f"Immagine: {image_url}")

Output atteso (esempio):

1Titolo: Apple AirPods Pro (2nd Generation) with USB-C
2Prezzo: $189.99
3Valutazione: 4.7 out of 5 stars
4Recensioni: 98,432 ratings
5Disponibilità: In Stock
6Immagine: https://m.media-amazon.com/images/I/61SUj2...

Nota i selettori di fallback multipli per il prezzo: Amazon usa contenitori diversi in base al tipo di prodotto, allo stato dell'offerta e alla variante del test A/B. Racchiudere ogni estrazione in un controllo condizionale evita che lo scraper si blocchi quando un selettore non trova corrispondenza.

Passo 4: estrai più prodotti dai risultati di ricerca

Per costruire un dataset reale, conviene partire da una pagina dei risultati di ricerca Amazon, raccogliere gli ASIN e poi scrappare ogni pagina prodotto.

1import time
2import random
3def get_search_asins(keyword, max_pages=1):
4    """Raccoglie gli ASIN dai risultati di ricerca Amazon."""
5    asins = []
6    for page in range(1, max_pages + 1):
7        search_url = f"https://www.amazon.com/s?k={keyword}&page={page}"
8        resp = cfreq.get(search_url, headers=headers, impersonate="chrome124")
9        if resp.status_code != 200:
10            print(f"La pagina di ricerca {page} ha restituito {resp.status_code}")
11            break
12        search_soup = BeautifulSoup(resp.text, "lxml")
13        results = search_soup.select('div[data-component-type="s-search-result"]')
14        for r in results:
15            asin = r.get("data-asin")
16            if asin:
17                asins.append(asin)
18        print(f"Pagina {page}: trovati {len(results)} prodotti")
19        time.sleep(random.uniform(2, 5))  # Pausa gentile
20    return asins
21asins = get_search_asins("wireless+earbuds", max_pages=2)
22print(f"ASIN raccolti: {len(asins)}")

Ogni ASIN corrisponde a un URL prodotto pulito: https://www.amazon.com/dp/{ASIN}. È più affidabile dei link completi dei risultati di ricerca, che possono contenere parametri specifici della sessione.

Passo 5: gestisci la paginazione ed estrai su larga scala

Ora combiniamo la raccolta dai risultati di ricerca e lo scraping delle pagine dettaglio in una pipeline completa:

1import pandas as pd
2def scrape_product(asin):
3    """Scrapa una singola pagina dettaglio prodotto Amazon."""
4    url = f"https://www.amazon.com/dp/{asin}"
5    try:
6        resp = cfreq.get(url, headers=headers, impersonate="chrome124")
7        if resp.status_code != 200:
8            return None
9        soup = BeautifulSoup(resp.text, "lxml")
10        title_el = soup.select_one("span#productTitle")
11        price_el = (
12            soup.select_one("div#corePriceDisplay_desktop_feature_div span.a-price .a-offscreen")
13            or soup.select_one("span.priceToPay .a-offscreen")
14            or soup.select_one(".apexPriceToPay .a-offscreen")
15        )
16        rating_el = soup.select_one("#acrPopover span.a-icon-alt")
17        reviews_el = soup.select_one("span#acrCustomerReviewText")
18        avail_el = soup.select_one("div#availability span")
19        img_el = soup.select_one("#landingImage")
20        return {
21            "asin": asin,
22            "title": title_el.get_text(strip=True) if title_el else None,
23            "price": price_el.get_text(strip=True) if price_el else None,
24            "rating": rating_el.get_text(strip=True) if rating_el else None,
25            "reviews": reviews_el.get_text(strip=True) if reviews_el else None,
26            "availability": avail_el.get_text(strip=True) if avail_el else None,
27            "image_url": img_el.get("src") if img_el else None,
28            "url": url,
29        }
30    except Exception as e:
31        print(f"Errore nello scraping di {asin}: {e}")
32        return None
33# Scrapa tutti gli ASIN raccolti
34products = []
35for i, asin in enumerate(asins):
36    print(f"Scraping {i+1}/{len(asins)}: {asin}")
37    product = scrape_product(asin)
38    if product:
39        products.append(product)
40    time.sleep(random.uniform(2, 5))  # Ritardo casuale tra le richieste
41df = pd.DataFrame(products)
42print(f"\nProdotti estratti con successo: {len(df)}")
43print(df.head())

Il ritardo casuale tra 2 e 5 secondi è fondamentale. Una tempistica perfettamente regolare (ad esempio esattamente 3 secondi ogni volta) appare sospetta ai sistemi di analisi comportamentale di Amazon. Intervalli casuali imitano il comportamento di navigazione umano.

Passo 6: salva i dati Amazon estratti in CSV

1df.to_csv("amazon_products.csv", index=False, encoding="utf-8-sig")
2print("Salvato in amazon_products.csv")

Ora dovresti avere un CSV pulito con colonne per ASIN, titolo, prezzo, valutazione, recensioni, disponibilità, URL immagine e URL prodotto. È qui che la maggior parte dei tutorial si ferma — ma se stai costruendo un flusso di lavoro reale, il CSV è solo l'inizio.

Approfondimento anti-blocco: come mantenere operativo lo scraper

Essere bloccati è il per chi prova a scrappare prodotti Amazon con Python. La difesa a sei livelli di Amazon include analisi della reputazione IP, fingerprinting TLS, controlli sull'ambiente browser, biometria comportamentale, CAPTCHA e rilevamento anomalie basato su ML. Qui sotto trovi una strategia stratificata per affrontarli uno per uno.

Ruota User-Agent e header completi

Un singolo User-Agent statico viene individuato rapidamente. Ruota tra una lista di stringhe browser aggiornate:

1import random
2USER_AGENTS = [
3    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.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/143.0.0.0 Safari/537.36",
5    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0",
6    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15",
7]
8def get_headers():
9    return {
10        "User-Agent": random.choice(USER_AGENTS),
11        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
12        "Accept-Language": "en-US,en;q=0.9",
13        "Accept-Encoding": "gzip, deflate, br",
14        "Referer": "https://www.google.com/",
15        "DNT": "1",
16        "Connection": "keep-alive",
17    }

Un dettaglio che spesso crea problemi: il tuo Accept-Language deve corrispondere alla posizione geografica suggerita dal tuo IP. Inviare Accept-Language: en-US da un IP tedesco è un campanello d'allarme.

Impersonificazione del fingerprint TLS con curl_cffi

Ne abbiamo parlato nel Passo 2, ma vale la pena ribadirlo: questa singola tecnica offre il miglior aumento del tasso di successo. Il classico requests di Python ottiene circa il 2% di successo contro Amazon. Con l'impersonificazione tramite curl_cffi, arrivi a circa il 94%. È la differenza tra uno scraper funzionante e uno rotto.

1from curl_cffi import requests as cfreq
2# Ruota anche i target di impersonificazione
3BROWSERS = ["chrome120", "chrome124", "chrome131"]
4response = cfreq.get(
5    url,
6    headers=get_headers(),
7    impersonate=random.choice(BROWSERS),
8)

Rotazione dei proxy

Per scrappare più di poche pagine, ti servirà la rotazione dei proxy. Amazon traccia gli indirizzi IP e bloccherà qualsiasi IP che invii troppe richieste.

1PROXIES = [
2    "http://user:pass@proxy1.example.com:8080",
3    "http://user:pass@proxy2.example.com:8080",
4    "http://user:pass@proxy3.example.com:8080",
5]
6proxy = random.choice(PROXIES)
7response = cfreq.get(
8    url,
9    headers=get_headers(),
10    impersonate="chrome124",
11    proxies={"http": proxy, "https": proxy},
12)

I proxy residenziali sono più efficaci dei proxy datacenter (Amazon blocca in modo proattivo gli intervalli IP dei datacenter), ma sono anche più costosi. Per un progetto piccolo, puoi iniziare con un e scalare in seguito secondo necessità.

Rate limiting e exponential backoff

Nessun articolo concorrente che ho trovato copre questo punto, ma è essenziale. Quando ricevi un 503 o una risposta CAPTCHA, non riprovare subito: è la strada più veloce verso un ban permanente.

1import time
2import random
3def fetch_with_backoff(url, max_retries=3):
4    """Recupera un URL con exponential backoff in caso di errore."""
5    for attempt in range(max_retries):
6        response = cfreq.get(
7            url,
8            headers=get_headers(),
9            impersonate=random.choice(BROWSERS),
10        )
11        if response.status_code == 200:
12            return response
13        # Exponential backoff con jitter
14        wait = min(2 ** attempt + random.uniform(0, 1), 30)
15        print(f"Tentativo {attempt+1} fallito ({response.status_code}). Attendo {wait:.1f}s...")
16        time.sleep(wait)
17    return None  # Tutti i tentativi esauriti

La formula wait = min(2^attempt + jitter, max_delay) fa crescere i ritardi (2s, 4s, 8s...) senza superare un limite ragionevole. Il jitter casuale impedisce che il tuo schema di retry venga riconosciuto come firma automatica.

Fallback con Selenium o Playwright per contenuti renderizzati via JS

Alcune pagine Amazon (specialmente quelle con widget di prezzo dinamici o selettori di varianti) richiedono JavaScript per essere renderizzate completamente. Quando curl_cffi restituisce HTML incompleto, un browser headless è il tuo piano B:

1from playwright.sync_api import sync_playwright
2def scrape_with_browser(url):
3    with sync_playwright() as p:
4        browser = p.chromium.launch(headless=True)
5        page = browser.new_page()
6        page.goto(url, wait_until="domcontentloaded")
7        page.wait_for_timeout(3000)  # Lascia tempo al JS di renderizzare
8        html = page.content()
9        browser.close()
10        return html

È più lento — 3–5 secondi per pagina invece di meno di 1 secondo con curl_cffi. Usalo solo quando serve.

Per esperienza, curl_cffi gestisce oltre il 90% delle pagine prodotto Amazon senza bisogno di un browser.

Riassunto anti-blocco

Oltre il CSV: esporta i dati Amazon in Google Sheets, Airtable e altro

Ogni tutorial che ho esaminato si ferma all'esportazione in CSV. Ma i flussi di lavoro aziendali reali richiedono dati in Google Sheets, database o strumenti come Airtable e Notion.

Esporta in Google Sheets con gspread

Per prima cosa, configura un service account Google (configurazione una tantum):

1. Vai su → APIs & Services → Credentials
2. Crea un service account e scarica il file chiave JSON
3. Salvalo in ~/.config/gspread/service_account.json
4. Condividi il foglio di calcolo di destinazione con il client_email presente nel file JSON

Poi:

1import gspread
2from gspread_dataframe import set_with_dataframe
3gc = gspread.service_account()
4sh = gc.open("Amazon Scrape Data")
5worksheet = sh.sheet1
6set_with_dataframe(worksheet, df)
7print("Dati esportati in Google Sheets!")

Questo scrive l'intero DataFrame direttamente in un foglio Google — live, condivisibile e pronto per dashboard.

Archivia in SQLite per analisi locali

Per dataset più grandi o per il monitoraggio storico, SQLite è perfetto: niente server da configurare, solo un file.

1import sqlite3
2conn = sqlite3.connect("amazon_products.db")
3df.to_sql("products", conn, if_exists="append", index=False)
4print(f"Salvati {len(df)} prodotti in SQLite")
5# Query successive:
6historical = pd.read_sql_query(
7    "SELECT * FROM products WHERE price IS NOT NULL ORDER BY rowid DESC LIMIT 100",
8    conn,
9)

L'alternativa no-code

Se non vuoi mantenere script Python per l'esportazione, offre export gratuito verso Google Sheets, Airtable, Notion, Excel, CSV e JSON — inclusi i campi immagine che si visualizzano direttamente in Airtable e Notion. Niente setup di gspread, nessuna credenziale API, nessun codice. Per i team che devono far fluire i dati nei loro strumenti già in uso, è un enorme risparmio di tempo.

Pianificare scraping automatici di Amazon — il capitolo che manca

Il monitoraggio dei prezzi e dell'inventario richiede scraping ricorrenti, non esecuzioni isolate. Eppure non sono riuscito a trovare un solo articolo concorrente che parli di scheduling. Ecco come automatizzare il tuo scraper Python.

Cron job (Linux/macOS)

Apri il crontab:

1crontab -e

Aggiungi una riga per eseguire lo scraper ogni giorno alle 6:00:

10 6 * * * cd /path/to/amazon-scraper && /path/to/venv/bin/python scraper.py >> ~/scraper.log 2>&1

Oppure ogni 6 ore:

10 */6 * * * cd /path/to/amazon-scraper && /path/to/venv/bin/python scraper.py >> ~/scraper.log 2>&1

Windows Task Scheduler

Crea un file batch run_scraper.bat:

1@echo off
2cd /d "C:\path\to\amazon-scraper"
3call venv\Scripts\activate
4python scraper.py
5deactivate

Poi apri Task Scheduler → Create Basic Task → imposta il trigger (Daily, Hourly) → Action: "Start a program" → seleziona run_scraper.bat.

GitHub Actions (free tier)

Per una pianificazione cloud senza infrastruttura:

1name: Amazon Scraper
2on:
3  schedule:
4    - cron: "0 6 * * *"  # Ogni giorno alle 6:00 UTC
5  workflow_dispatch:       # Avvio manuale
6jobs:
7  scrape:
8    runs-on: ubuntu-latest
9    steps:
10      - uses: actions/checkout@v3
11      - name: Set up Python
12        uses: actions/setup-python@v4
13        with:
14          python-version: "3.11"
15      - name: Install dependencies
16        run: pip install -r requirements.txt
17      - name: Run scraper
18        run: python scraper.py
19      - name: Commit results
20        run: |
21          git config user.name 'GitHub Actions'
22          git config user.email 'actions@github.com'
23          git add data/
24          git diff --staged --quiet || git commit -m "Aggiorna i dati estratti"
25          git push

Conserva le credenziali dei proxy nei GitHub Secrets e avrai una pipeline di scraping automatizzata e gratuita.

Alternativa no-code: Scheduled Scraper di Thunderbit

Per i team che non vogliono gestire la sintassi cron o l'infrastruttura cloud, Thunderbit offre un integrato. Descrivi la pianificazione in linguaggio naturale (ad esempio, "ogni giorno alle 8" o "ogni lunedì"), aggiungi gli URL Amazon e fai clic su "Pianifica". Nessun terminale, nessun file YAML, nessuna pipeline di deployment. È particolarmente utile per i team ecommerce che fanno monitoraggio continuo di prezzi o inventario.

Python fai-da-te vs Scraper API vs No-code: quale approccio scegliere?

Questa è una domanda che vedo continuamente nei forum e nessun articolo ben posizionato offre una risposta strutturata. Quindi ecco la mia opinione sincera:

Python è la scelta giusta se vuoi imparare, personalizzare ogni dettaglio e non ti spaventa la manutenzione continua. Le Scraper API gestiscono per te l'anti-blocco, ma richiedono comunque codice. Thunderbit è la strada più veloce per sales, ecommerce ops o chiunque abbia solo bisogno dei dati — senza selettori, senza codice, senza manutenzione quando Amazon cambia l'HTML.

Come Thunderbit estrae prodotti Amazon in 2 clic

Sono di parte, ovviamente — il mio team l'ha costruito. Ma il flusso di lavoro è davvero così semplice:

1. Installa la
2. Apri una pagina dei risultati di ricerca Amazon o una pagina prodotto
3. Fai clic su "AI Suggest Fields" (oppure usa il template istantaneo per Amazon)
4. Fai clic su "Scrape"

L'IA di Thunderbit legge la pagina, identifica la struttura dei dati ed estrae tutto in una tabella pulita. Puoi esportare gratuitamente in Excel, Google Sheets, Airtable o Notion. Il vero vantaggio: quando Amazon cambierà di nuovo l'HTML la prossima settimana (e lo farà), l'IA di Thunderbit si adatterà automaticamente. Niente script rotti, niente aggiornamenti dei selettori.

Per arricchire liste prodotto con dati delle pagine dettaglio, la funzione Subpage Scraping di Thunderbit segue automaticamente i link alle pagine prodotto e aggiunge campi extra come immagini, descrizioni e varianti — qualcosa che in Python richiede molto più codice.

Consigli per far funzionare a lungo termine il tuo scraper Amazon in Python

Se scegli la strada Python, ecco come ridurre al minimo i problemi di manutenzione:

• Controlla regolarmente i selettori. Amazon li cambia spesso. Salva questa guida nei preferiti — aggiornerò la tabella dei selettori quando le cose cambieranno.
• Monitora il tasso di successo. Tieni traccia del rapporto tra risposte 200 e 503/CAPTCHA. Imposta un alert (anche una semplice email) quando il tasso scende sotto l'80%.
• Salva l'HTML grezzo. Conserva la risposta HTML completa insieme ai dati parsati. Se i selettori cambiano, potrai riprocessare i dati storici senza riscrappare tutto.
• Ruota spesso proxy e User-Agent. I fingerprint statici vengono individuati in poche ore su larga scala.
• Usa exponential backoff. Non ritentare mai subito dopo un blocco.
• Containerizza con Docker. Avvolgi lo scraper in un container Docker per facilitarne deployment e portabilità.
• Aggiungi validazione dei dati. Verifica che i prezzi siano numerici, che le valutazioni siano tra 1 e 5 e che i titoli non siano vuoti. Un team ha riportato una dopo aver aggiunto livelli di validazione.

Oppure, se tutto questo ti sembra più lavoro di quanto avessi previsto, valuta se uno strumento no-code come Thunderbit possa essere più adatto al tuo caso. Non c'è nulla di sbagliato nello scegliere la strada più rapida — ho passato abbastanza anni a debuggare scraper per sapere che, a volte, il miglior codice è quello che non devi scrivere.

Considerazioni legali ed etiche quando si scrappa Amazon

Dato che questo tema emerge in ogni conversazione sullo scraping di Amazon, ecco una nota rapida sul quadro legale:

• Lo scraping di dati pubblicamente disponibili è generalmente legale negli Stati Uniti. La storica sentenza (2022) ha stabilito che l'accesso a dati pubblici non viola il CFAA. Più recentemente, (2024) e (2024) hanno rafforzato questo principio.
• I ToS di Amazon vietano l'accesso automatizzato. Si tratta di una questione civile (violazione contrattuale), non penale. I tribunali, in genere, distinguono tra le due.
• Amazon v. Perplexity (2025) è una causa ancora aperta che riguarda lo scraping con IA delle pagine Amazon. Nel marzo 2026 è stata emessa un'ingiunzione preliminare. Vale la pena seguirla.
• Limita l'attività alle pagine pubbliche. Non scrappare contenuti protetti da login, dati personali o qualsiasi cosa richieda autenticazione.
• Rispetta i rate limit. Non martellare i server di Amazon. Un ritardo di 2–5 secondi tra una richiesta e l'altra è ragionevole.
• Usa i dati in modo responsabile. Scrappa per analisi, non per ripubblicare contenuti protetti da copyright.
• Consulta un legale per usi commerciali su larga scala, soprattutto se operi nell'UE (il GDPR si applica ai dati personali).

Per un approfondimento, vedi la nostra guida su .

Conclusione

Ora hai uno scraper Python funzionante per Amazon con selettori verificati del 2025, una strategia anti-blocco stratificata che va ben oltre il semplice "aggiungi un User-Agent", opzioni pratiche di scheduling per il monitoraggio continuo e metodi di esportazione che portano i tuoi dati in Google Sheets, database o qualsiasi altro strumento usi il tuo team.

Riepilogo rapido:

• Python + curl_cffi + BeautifulSoup ti dà pieno controllo e un tasso di successo di circa il 94% quando viene combinato con l'impersonificazione TLS
• L'anti-blocco richiede più livelli: rotazione degli header, impersonificazione TLS, rotazione proxy, rate limiting ed exponential backoff
• La pianificazione trasforma uno script una tantum in una pipeline di monitoraggio continua (cron, GitHub Actions o scheduler integrato di Thunderbit)
• Esportare oltre il CSV — Google Sheets, SQLite, Airtable, Notion — è dove si crea il vero valore di business
• Thunderbit offre un'alternativa in 2 clic per i non sviluppatori o per chi preferisce spendere il tempo ad analizzare i dati invece che a debuggare i selettori

Se vuoi provare il codice, tutto ciò che trovi in questa guida è pronto da copiare ed eseguire. E se preferisci saltare del tutto la parte di programmazione, il ti permette di testare subito l'approccio no-code su Amazon.

Per approfondire, consulta anche le nostre guide su , e . Puoi anche guardare tutorial passo passo sul .

Buono scraping — e che i tuoi selettori resistano fino al prossimo aggiornamento di Amazon.

FAQ

1. Perché il mio scraper Python per Amazon viene bloccato dopo poche richieste?

Amazon utilizza un sistema di difesa a sei livelli: analisi della reputazione IP, fingerprinting TLS (JA3/JA4), rilevamento dell'ambiente browser, biometria comportamentale, challenge CAPTCHA e rilevamento anomalie basato su ML. Uno script base requests con solo un header User-Agent raggiunge circa il di successo. Ti servono impersonificazione TLS (curl_cffi), rotazione completa degli header, rotazione proxy e rate limiting con jitter casuale per mantenere un accesso affidabile.

2. Quali librerie Python sono migliori per scrappare prodotti Amazon nel 2025?

curl_cffi per richieste HTTP con impersonificazione TLS (il singolo miglioramento più importante), BeautifulSoup4 con lxml per il parsing HTML, pandas per strutturare ed esportare i dati, e Selenium o Playwright come fallback per contenuti renderizzati via JavaScript. Python è usato dal degli sviluppatori di scraping.

3. È legale scrappare i dati prodotto Amazon?

In generale, negli Stati Uniti è legale scrappare dati pubblicamente disponibili, come dimostrano casi come hiQ v. LinkedIn e Meta v. Bright Data. I Termini di servizio di Amazon vietano l'accesso automatizzato, ma i tribunali distinguono tra violazioni dei ToS (civili) e violazioni penali. Evita sempre contenuti protetti da login, rispetta i rate limit e consulta un legale per usi commerciali su larga scala.

4. Posso scrappare Amazon senza scrivere codice?

Sì. Strumenti come ti permettono di scrappare prodotti Amazon in 2 clic con un'estensione Chrome. Il rilevamento campi basato su IA struttura automaticamente i dati e puoi esportarli gratuitamente in Excel, Google Sheets, Airtable o Notion. Quando Amazon cambia l'HTML, l'IA di Thunderbit si adatta senza alcun aggiornamento manuale.

5. Quanto spesso Amazon cambia i selettori HTML e come posso mantenere aggiornato lo scraper?

Spesso e senza preavviso. La community dello scraping segnala che dei crawler richiede correzioni settimanali a causa di modifiche al DOM. Per restare al passo, monitora il tasso di successo dello scraper, conserva l'HTML grezzo per poterlo riesaminare e controlla regolarmente i selettori sulle pagine live. In alternativa, strumenti basati su IA come Thunderbit si adattano automaticamente, eliminando questo carico di manutenzione.

Scopri di più