Come Scrape Walmart con Python (senza farsi bloccare)

Walmart modifica i prezzi di alcuni articoli . Se hai mai provato a monitorarli in modo automatico, sai bene quanto possa essere snervante: lo script gira tranquillo per 20 minuti e poi, senza alcun avviso, comincia a restituire pagine CAPTCHA camuffate da normali risposte 200 OK.

Negli anni ho lavorato a lungo sulle difese anti-bot di Walmart nell'ambito delle attività di estrazione dati di e voglio condividere tutto ciò che ho imparato: i metodi che funzionano davvero nel 2025, i fallimenti silenziosi che sporcano i dati e le valutazioni sincere tra scrivere un proprio scraper, pagare una scraping API o usare semplicemente uno strumento no-code. Questa guida copre tre tecniche di estrazione (parsing HTML, JSON __NEXT_DATA__ e intercettazione delle API interne), gestione degli errori pronta per la produzione che la maggior parte dei tutorial ignora del tutto e un framework decisionale onesto per scegliere l'approccio giusto. C'è qualcosa di utile sia per chi scrive in Python, sia per chi vuole semplicemente un foglio di calcolo pieno di prezzi entro l'ora di pranzo.

Perché fare scraping di Walmart con Python?

Walmart è il più grande retailer al mondo per fatturato — nell'anno fiscale 2025 — e ha mantenuto il . Il sito ospita circa , e il CFO di Walmart ha parlato di sul marketplace. Circa , il che rende il catalogo molto instabile: i venditori cambiano, le varianti si aggiornano e le scorte oscillano ogni giorno.

È proprio questa volatilità a rendere lo scraping così importante. Un report trimestrale non può catturare ciò che uno scraping notturno può rilevare. Ecco i casi d'uso più comuni che vedo:

Il solo mercato dei software per il monitoraggio prezzi dei competitor ha raggiunto e si prevede che toccherà 5,09 miliardi entro il 2033. Il comportamento dei consumatori alimenta questa spesa: e l'83% confronta offerte su più siti.

Python è il linguaggio predefinito per questo tipo di lavoro. Il report 2026 di Apify sull'infrastruttura indica , e la libreria base (requests) totalizza . Se fai scraping a qualunque scala, molto probabilmente lo stai facendo in Python.

Perché Walmart è uno dei siti più difficili da scrappare

Walmart è particolarmente ostico perché utilizza due prodotti commerciali anti-bot in serie: come livello edge WAF e di fingerprinting TLS, e come livello di challenge JavaScript comportamentale. Scrape.do definisce questa combinazione "rara ed estremamente difficile da bypassare".

, con Akamai da solo valutato 9/10. Per esperienza, è una stima corretta.

Ecco cosa devi davvero affrontare:

Akamai Bot Manager analizza il fingerprint TLS (hash JA3/JA4), l'ordine dei frame HTTP/2, l'ordine e il casing degli header e i cookie di sessione (_abck, ak_bmsc). Una chiamata standard di Python requests genera un fingerprint TLS che nessun browser reale produrrebbe — Akamai lo segnala prima ancora che la richiesta raggiunga i server di Walmart.

PerimeterX/HUMAN entra in azione dopo Akamai ed esegue il fingerprinting JavaScript (px.js) verificando proprietà di navigator, rendering canvas, WebGL, contesto audio e biometria comportamentale (movimento del mouse, velocità di scrolling, dinamica dei tasti). Il fallimento visibile è il famigerato challenge — un pulsante da tenere premuto per circa 10 secondi mentre vengono campionati i segnali comportamentali. Oxylabs è molto chiara: "Walmart usa il modello CAPTCHA 'Press & Hold', offerto da PerimeterX, che è noto per essere quasi impossibile da risolvere via codice."

Il comportamento davvero pericoloso è il blocco silenzioso. Walmart restituisce HTTP 200 con un corpo CAPTCHA invece di un 403. : "Walmart restituisce un codice 200 OK anche quando mostra una pagina CAPTCHA. Non puoi affidarti solo allo status code per sapere se la richiesta è andata a buon fine." Il tuo script interpreta felice l'HTML del CAPTCHA come "prodotto non trovato" e va avanti. Metà dataset diventa spazzatura, e tu non lo sai.

Poi c'è il problema dei dati legati allo store. Prezzi e disponibilità su Walmart dipendono dalla posizione e sono controllati da cookie come locDataV3 e assortmentStoreId. Senza i cookie corretti, ottieni dati "nazionali di default" che possono sembrare completi ma non corrispondono a ciò che vedono i clienti reali. I cookie mancanti non generano una pagina di blocco — generano dati sbagliati senza alcun errore visibile, che è ancora peggio.

Tre modi per estrarre dati da Walmart (e come si confrontano)

Prima della guida passo-passo, ecco i tre approcci principali all'estrazione. La maggior parte dei tutorial dei competitor ne copre solo uno o due. Io li affronto tutti e tre, così puoi scegliere quello più adatto al tuo caso.

Il parsing HTML è l'opzione peggiore per Walmart — il sito usa bundle Next.js con nomi di classi CSS hashati che cambiano a ogni deploy. Il metodo JSON __NEXT_DATA__ è la scelta pragmatica usata da tutti gli scraper Walmart open-source seri del periodo 2024–2026. L'intercettazione delle API interne è l'approccio più potente, ma presenta compromessi che molti tutorial sorvolano. E Thunderbit è la scelta giusta quando non hai bisogno di una pipeline personalizzata.

Configurare l'ambiente Python per fare scraping di Walmart

Ti serve questo:

• Difficoltà: Intermedia
• Tempo richiesto: ~30 minuti per la configurazione, più il tempo di sviluppo
• Cosa ti serve: Python 3.10+, pip, un editor di codice e — per uso in produzione — un servizio proxy o una scraping API

Crea la cartella del progetto e l'ambiente virtuale:

1mkdir walmart-scraper && cd walmart-scraper
2python -m venv venv
3source venv/bin/activate  # Su Windows: venv\Scripts\activate

Installa le librerie necessarie:

1pip install curl_cffi parsel beautifulsoup4 lxml

curl_cffi è lo standard del 2025 per lo scraping di target difficili. È un binding di libcurl che può imitare con precisione i fingerprint TLS dei browser reali. : "Walmart usa il fingerprinting TLS come parte del suo sistema di rilevamento bot, e anche impostare lo User-Agent per simulare un browser reale non basta a superarlo." Il semplice requests o httpx non può superare Akamai, indipendentemente dagli header impostati. curl_cffi con impersonate="chrome124" fa la differenza.

Ti saranno utili anche json (integrato), csv (integrato), time, random e logging per gli schemi di produzione che vedremo più avanti.

Passo dopo passo: fare scraping delle pagine prodotto Walmart con Python

Passo 1: recuperare la pagina prodotto Walmart

Il primo obiettivo è inviare una richiesta HTTP che non venga bloccata subito. Ecco il set di header canonico usato da Scrapfly, Scrapingdog, Oxylabs e ScrapeOps nel periodo 2024–2026:

1from curl_cffi import requests
2HEADERS = {
3    "User-Agent": (
4        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
5        "AppleWebKit/537.36 (KHTML, like Gecko) "
6        "Chrome/124.0.0.0 Safari/537.36"
7    ),
8    "Accept": (
9        "text/html,application/xhtml+xml,application/xml;q=0.9,"
10        "image/avif,image/webp,*/*;q=0.8"
11    ),
12    "Accept-Language": "en-US,en;q=0.9",
13    "Accept-Encoding": "gzip, deflate, br",
14    "Upgrade-Insecure-Requests": "1",
15    "Sec-Fetch-Dest": "document",
16    "Sec-Fetch-Mode": "navigate",
17    "Sec-Fetch-Site": "none",
18    "Sec-Fetch-User": "?1",
19    "Referer": "https://www.google.com/",
20}
21session = requests.Session(impersonate="chrome124")
22url = "https://www.walmart.com/ip/Apple-AirPods-Pro-2nd-Generation/1752657021"
23response = session.get(url, headers=HEADERS)

Il parametro impersonate="chrome124" è qui che fa il lavoro pesante. Dice a curl_cffi di imitare il TLS ClientHello esatto di Chrome 124, l'ordine dei frame HTTP/2 e la sequenza dei pseudo-header. Senza questo, Akamai vede un fingerprint specifico di Python e blocca la richiesta prima ancora che raggiunga il livello applicativo di Walmart.

Come appare una risposta bloccata: se nel titolo dell'HTML vedi "Robot or human?", oppure se la risposta reindirizza a walmart.com/blocked, sei stato intercettato. La parte insidiosa è che Walmart spesso restituisce un codice 200 con il corpo CAPTCHA — quindi controllare solo response.ok non basta.

Per un uso ripetuto o in produzione, ti serviranno proxy residenziali. Gli IP datacenter vengono bruciati subito dal sistema di reputazione IP di Akamai. Nella sezione sulla produzione vedrò nel dettaglio gestione degli errori e strategia proxy.

Passo 2: estrarre i dati prodotto dal JSON __NEXT_DATA__

Walmart.com è un'applicazione Next.js e l'HTML renderizzato dal server incorpora il payload completo di hydration all'interno di un unico tag script: <script id="__NEXT_DATA__" type="application/json">. Questa è la miniera d'oro.

: "Nel 2026 Walmart usa Next.js con JSON strutturato nei tag script __NEXT_DATA__, rendendo l'estrazione dei dati nascosti più affidabile del parsing tradizionale dei selettori CSS." Tutti gli scraper open-source Walmart più noti — , , — usano questo metodo.

Ecco come estrarlo:

1import json
2from parsel import Selector
3sel = Selector(text=response.text)
4raw = sel.xpath('//script[@id="__NEXT_DATA__"]/text()').get()
5data = json.loads(raw)
6product = data["props"]["pageProps"]["initialData"]["data"]["product"]
7idml = data["props"]["pageProps"]["initialData"]["data"].get("idml", {})

La maggior parte dei tutorial si ferma qui. Qui sotto trovi una mappa completa dei percorsi JSON per i campi che contano davvero — verificata su pagine Walmart live nel periodo 2024–2026:

Il percorso longDescription è la trappola che fa inciampare molti. Un post di ScrapeHero del 2023 lo collocava in product.longDescription, ma le fonti dal 2024 in poi lo indicano in modo coerente sulla chiave sorella idml. Leggi sempre prima idml.longDescription e usa product.longDescription come fallback per le pagine più vecchie.

Ecco il pattern di estrazione sicuro con catene .get():

1def extract_product(data):
2    product = data["props"]["pageProps"]["initialData"]["data"]["product"]
3    idml = data["props"]["pageProps"]["initialData"]["data"].get("idml", {})
4    price_info = product.get("priceInfo", {})
5    current_price = price_info.get("currentPrice", {})
6    image_info = product.get("imageInfo", {})
7    return {
8        "name": product.get("name"),
9        "brand": product.get("brand"),
10        "price": current_price.get("price"),
11        "price_string": current_price.get("priceString"),
12        "short_desc": product.get("shortDescription"),
13        "long_desc": idml.get("longDescription", product.get("longDescription")),
14        "images": [img.get("url") for img in image_info.get("allImages", [])],
15        "rating": product.get("averageRating"),
16        "review_count": product.get("numberOfReviews"),
17        "variants": product.get("variantCriteria"),
18        "availability": product.get("availabilityStatus"),
19        "seller": product.get("sellerDisplayName"),
20        "manufacturer": product.get("manufacturerName"),
21    }

Per chi non vuole gestire manualmente la navigazione nei percorsi JSON, identifica e struttura automaticamente questi campi — senza dover mappare nulla a mano. Fai clic su "AI Suggest Fields", il sistema legge la pagina e ti restituisce una tabella. Ma se stai costruendo una pipeline personalizzata, la mappa qui sopra è il tuo riferimento.

Passo 3: intercettare gli endpoint API interni di Walmart per dati più ricchi

Nessun articolo dei competitor copre bene questo metodo. È il percorso di estrazione più potente — e anche il più complesso.

Il frontend di Walmart chiama un . Gli endpoint si trovano sotto www.walmart.com/orchestra/*:

• /orchestra/pdp/graphql/... — hydration della scheda prodotto e cambio variante
• /orchestra/snb/graphql/... — paginazione search-n-browse
• /orchestra/reviews/graphql/... — recensioni paginated

Questi endpoint restituiscono JSON pulito e strutturato con dati che __NEXT_DATA__ a volte tronca — prezzi a livello di variante, conteggi stock in tempo reale, paginazione completa delle recensioni.

La trappola che molti articoli aggirano: Walmart usa . Il body della richiesta invia solo un hash SHA-256 (persistedQuery.sha256Hash), non il testo della query. Se l'hash non è noto al server, ricevi PersistedQueryNotFound. Walmart ruota questi hash a ogni deploy. Ecco perché nessuno degli scraper open-source Walmart più noti pubblica codice copiabile e incollabile per /orchestra/.

La versione pratica e onesta di questo metodo è un esercizio con DevTools:

1. Apri una pagina prodotto Walmart in Chrome
2. Apri DevTools → scheda Network, filtra per "Fetch/XHR"
3. Naviga normalmente nella pagina — clicca sulle varianti, scorri fino alle recensioni, cambia la località dello store
4. Osserva le richieste agli endpoint /orchestra/* che restituiscono JSON con i dati del prodotto
5. Fai clic destro sulla richiesta → "Copy as cURL"
6. Converti il comando cURL in Python con curl_cffi

Ecco come appare una chiamata API riprodotta:

1import json
2from curl_cffi import requests
3session = requests.Session(impersonate="chrome124")
4# Prima, riscalda la sessione visitando la pagina prodotto
5session.get("https://www.walmart.com/ip/some-product/1234567", headers=HEADERS)
6# Poi riproduci la chiamata API interna (copiata da DevTools)
7api_url = "https://www.walmart.com/orchestra/pdp/graphql"
8api_headers = {
9    **HEADERS,
10    "accept": "application/json",
11    "content-type": "application/json",
12    "referer": "https://www.walmart.com/ip/some-product/1234567",
13    "wm_qos.correlation_id": "your-copied-correlation-id",
14}
15payload = {
16    # Incolla qui il body esatto della richiesta copiato da DevTools
17    "variables": {"productId": "1234567"},
18    "extensions": {
19        "persistedQuery": {
20            "version": 1,
21            "sha256Hash": "the-hash-you-copied"
22        }
23    }
24}
25api_response = session.post(api_url, headers=api_headers, json=payload)
26api_data = api_response.json()

Il passaggio di riscaldamento della sessione è fondamentale. I cookie PerimeterX di Walmart (_px3, _pxhd, ACID) devono essere impostati dal primo fetch HTML prima che la chiamata API possa funzionare. Senza di essi, otterrai un 412 o un 403.

Quando usare questo metodo: quando ti servono dati che __NEXT_DATA__ non include — prezzi profondi delle varianti, recensioni paginate oltre il primo batch o conteggi stock in tempo reale. Per la maggior parte dei casi, __NEXT_DATA__ è sufficiente ed è molto più semplice.

Scraping dei risultati di ricerca Walmart e di più pagine

Anche i risultati di ricerca seguono un pattern simile a __NEXT_DATA__, ma con un percorso JSON diverso:

1search_url = "https://www.walmart.com/search?q=laptops&page=1"
2response = session.get(search_url, headers=HEADERS)
3sel = Selector(text=response.text)
4raw = sel.xpath('//script[@id="__NEXT_DATA__"]/text()').get()
5data = json.loads(raw)
6search_result = data["props"]["pageProps"]["initialData"]["searchResult"]
7items = search_result["itemStacks"][0]["items"]
8# Filtra i prodotti sponsorizzati
9organic_items = [i for i in items if i.get("__typename") == "Product"]
10for item in organic_items:
11    print(item.get("name"), item.get("priceInfo", {}).get("currentPrice", {}).get("price"))

La paginazione funziona incrementando il parametro page: &page=1, &page=2, ecc. Ma c'è un limite non documentato: Walmart limita i risultati di ricerca a 25 pagine, indipendentemente dal numero totale reale. : "Walmart imposta a 25 il numero massimo di pagine dei risultati accessibili, indipendentemente dal totale disponibile."

Per andare più in profondità, puoi usare questi workaround:

• Cambio dell'ordine di ordinamento: esegui la stessa query con &sort=price_low e poi con &sort=price_high per ottenere circa 50 pagine di copertura
• Suddivisione per fascia prezzo: aggiungi &min_price=X&max_price=Y per dividere il catalogo in finestre più piccole
• Suddivisione per categoria: cerca all'interno di categorie specifiche invece che sull'intero sito

Nota che itemStacks è un array. Scrapfly nel suo repo usa in modo fisso [0], ma le pagine di categoria e browsing a volte contengono più stack ("Top picks", "More results"). Il pattern robusto è iterare su tutti gli stack:

1for stack in search_result.get("itemStacks", []):
2    for item in stack.get("items", []):
3        if item.get("__typename") == "Product":
4            # processa item
5            pass

Vale anche la pena notare che il robots.txt di Walmart . Le pagine di dettaglio prodotto (/ip/...) e la maggior parte delle pagine di categoria (/cp/...) non sono vietate. Se ti preoccupa la compliance, parti dalle pagine prodotto e dagli alberi di categoria invece che dalla ricerca.

Non lasciare che i blocchi silenziosi rovinino i dati: gestione degli errori pronta per la produzione

Qui è dove molti tutorial crollano. Ti mostrano come recuperare una pagina, estrarre un prodotto e considerare chiuso il lavoro. In produzione, però, stai recuperando migliaia di pagine, e Walmart sta attivamente cercando di fermarti. La differenza tra uno scraper dimostrativo e uno che funziona davvero sta in come gestisce i fallimenti.

Rileva i blocchi silenziosi prima che contaminino i dati

La singola funzione più importante in uno scraper Walmart è il rilevatore di blocchi. In base al consenso dei vendor tra , , e , servono quattro controlli indipendenti:

1BLOCK_MARKERS = (
2    "Robot or human",
3    "Press & Hold",
4    "Press & Hold",
5    "px-captcha",
6    "perimeterx",
7)
8def is_walmart_blocked(response) -> bool:
9    # 1. Redirect verso l'endpoint di blocco dedicato
10    if "/blocked" in str(response.url):
11        return True
12    # 2. Status code evidenti
13    if response.status_code in (403, 412, 428, 429, 503):
14        return True
15    # 3. 200 OK con corpo CAPTCHA (il caso di blocco silenzioso)
16    body = response.text or ""
17    if any(m.lower() in body.lower() for m in BLOCK_MARKERS):
18        return True
19    # 4. Controllo di lunghezza della risposta — le PDP reali sono 300-900 KB
20    if len(response.content) < 50_000 and "/ip/" in str(response.url):
21        return True
22    return False

Quel quarto controllo — la lunghezza della risposta — intercetta i casi in cui Walmart restituisce una pagina ridotta che non contiene marker CAPTCHA evidenti ma nemmeno i dati del prodotto di cui hai bisogno.

Logica di retry con exponential backoff e jitter

Quando una richiesta fallisce, non vuoi martellare Walmart immediatamente. Il pattern standard usa exponential backoff con jitter per desincronizzare i retry:

1import time
2import random
3import logging
4from curl_cffi import requests as cffi_requests
5log = logging.getLogger("walmart")
6def fetch_with_retry(session, url, max_retries=5, base_delay=2, max_delay=60):
7    for attempt in range(max_retries):
8        try:
9            response = session.get(url, headers=HEADERS, timeout=15)
10            if response.status_code in (429, 503):
11                raise Exception(f"Throttled: {response.status_code}")
12            if is_walmart_blocked(response):
13                raise Exception("Blocco silenzioso rilevato")
14            return response
15        except Exception as e:
16            if attempt == max_retries - 1:
17                raise
18            wait = min(max_delay, base_delay * (2 ** attempt)) + random.uniform(0, 3)
19            log.warning(f"Tentativo {attempt + 1} fallito: {e}. Nuovo tentativo tra {wait:.1f}s")
20            time.sleep(wait)
21    return None

Il jitter (random.uniform(0, 3)) non è solo cosmetico — desincronizza i worker, così una flotta di scraper non ritenta tutta nello stesso secondo e non attiva i detector di velocità di Akamai.

Rate limiting

Sia sia convergono su un ritardo randomizzato di 3–6 secondi per richiesta per Walmart: "limita le richieste aspettando 3–6 secondi tra il caricamento di una pagina e l'altra e randomizza i ritardi."

1import time
2import random
3def rate_limited_fetch(session, url):
4    response = fetch_with_retry(session, url)
5    time.sleep(random.uniform(3.0, 6.0))
6    return response

Su larga scala, valuta aiolimiter per il rate limiting asincrono:

1from aiolimiter import AsyncLimiter
2limiter = AsyncLimiter(max_rate=10, time_period=60)  # 10 richieste al minuto

Validazione dei dati

Anche quando la risposta non è bloccata, i dati parsati potrebbero essere sbagliati (store errato, payload degradato). Verifica tutto prima di scrivere l'output:

1def validate_product(product):
2    """Restituisce True se i dati del prodotto sembrano validi."""
3    if not product.get("name"):
4        return False
5    price = (product.get("priceInfo") or {}).get("currentPrice", {}).get("price")
6    if not isinstance(price, (int, float)) or price <= 0:
7        return False
8    if product.get("availabilityStatus") not in ("IN_STOCK", "OUT_OF_STOCK", "LIMITED_STOCK"):
9        return False
10    return True

Logging della sessione

Tieni traccia del tasso di successo per sessione. Quando scende sotto l'80% per 10 minuti, qualcosa è cambiato — o l'IP è stato bruciato, o i cookie sono scaduti, oppure Walmart ha distribuito una nuova regola anti-bot.

1class ScrapeMetrics:
2    def __init__(self):
3        self.total = 0
4        self.success = 0
5        self.blocks = 0
6        self.errors = 0
7    def record(self, result):
8        self.total += 1
9        if result == "success":
10            self.success += 1
11        elif result == "blocked":
12            self.blocks += 1
13        else:
14            self.errors += 1
15    @property
16    def success_rate(self):
17        return (self.success / self.total * 100) if self.total > 0 else 0
18    def check_health(self):
19        if self.total > 20 and self.success_rate < 80:
20            log.critical(f"Il tasso di successo è sceso al {self.success_rate:.1f}% — valuta la rotazione dei proxy o una pausa")

Niente di spettacolare. Ma è ciò che mantiene puliti i dati.

Python fai-da-te vs Scraping API vs no-code: scegliere il modo giusto per fare scraping di Walmart

Molti sviluppatori si buttano subito a scrivere uno scraper personalizzato senza chiedersi se sia davvero la scelta migliore. . Gli utenti dei forum lo descrivono come "praticamente 9/10" e si chiedono se "una scraping API dedicata sarebbe eccessiva". La risposta dipende da volume, budget e capacità tecnica.

Quando ha senso il Python fai-da-te

Il fai-da-te vince quando hai già un contratto proxy, ti serve un controllo rigoroso su header, targeting per CAP o gruppi di seller, stai indicizzando milioni di pagine al mese e i costi per record delle API si sommano, oppure hai bisogno di garanzie on-prem o di compliance. Il compromesso è il tempo ingegneristico reale: uno spider Scrapy pronto per la produzione con paginazione, retry, rotazione proxy, impersonificazione TLS e più schemi di pagina richiede , più 4–8 ore al mese di manutenzione mentre Walmart ruota i fingerprint.

Quando una scraping API ti fa risparmiare tempo

Le scraping API gestiscono il livello anti-bot al posto tuo. I mostrano tassi di successo del e del 98% per Scrape.do su Walmart. I prezzi entry-level si collocano tra 40 e 49 dollari al mese per strumenti come , e . Se lavori in un team di 2–5 ingegneri e il volume di scraping è tra 10K e 1M di pagine al mese, un'API è quasi sempre la scelta giusta. Scambi il costo per richiesta con manutenzione praticamente nulla.

Quando il no-code è la scelta giusta

si adatta a un profilo completamente diverso. Se sei un PM, un analista o un operatore e-commerce e ti servono i dati prodotto di Walmart in un foglio di calcolo questo pomeriggio — non nel prossimo sprint — uno strumento no-code è la risposta più onesta.

Il flusso è semplice: installa la , vai su una pagina prodotto o di ricerca Walmart, clicca "AI Suggest Fields" e l'AI di Thunderbit legge la pagina e suggerisce le colonne (nome prodotto, prezzo, valutazione, ecc.). Clicca "Scrape" e i dati vengono popolati in una tabella. Esporta in Excel, Google Sheets, Airtable o Notion — tutto gratis, senza paywall.

Thunderbit gestisce l'anti-bot nel cloud, quindi non hai a che fare con CAPTCHA, proxy o fingerprinting TLS. L'AI si adatta automaticamente ai cambiamenti di layout, quindi non c'è manutenzione. Per chi non vuole navigare manualmente nei percorsi JSON, questa è la via più semplice.

Limiti onesti: Thunderbit non è pensato per oltre 100K pagine al giorno. I budget in crediti e i limiti cloud rendono l'ingest ad alto volume poco conveniente rispetto alle API pure. Inoltre, non puoi fissare un CAP o un ASN specifico, a meno che lo strumento non lo supporti. Per pipeline continuative e ad alto volume, resta meglio il fai-da-te o una scraping API.

Prezzo indicativo: 1.000 righe prodotto Walmart su Thunderbit costano circa 2.000 crediti (~0,60–1,10 dollari sui piani Starter/Pro). È comparabile all'API Walmart di Oxylabs e più economico della maggior parte delle scraping API hobby-tier a basso volume. per i dettagli aggiornati.

Esportare i dati Walmart estratti

Una volta ottenuti i dati, devi portarli in un formato utile. Tre formati coprono la maggior parte delle esigenze:

CSV — il formato più universale, quello che gli analisti aprono davvero:

1import csv
2def export_csv(products, filename="walmart_products.csv"):
3    fieldnames = ["name", "price", "availability", "rating", "review_count", "seller", "url"]
4    with open(filename, "w", newline="", encoding="utf-8-sig") as f:
5        writer = csv.DictWriter(f, fieldnames=fieldnames, quoting=csv.QUOTE_MINIMAL)
6        writer.writeheader()
7        for p in products:
8            writer.writerow({k: p.get(k) for k in fieldnames})

Usa la codifica utf-8-sig per la compatibilità con Excel. Il marker BOM evita che Excel rovini i caratteri speciali.

JSONL — il formato di produzione per le pipeline di scraping:

1import json
2import gzip
3def export_jsonl(products, filename="walmart_products.jsonl.gz"):
4    with gzip.open(filename, "at", encoding="utf-8") as f:
5        for p in products:
6            f.write(json.dumps(p, ensure_ascii=False) + "\n")

(una scrittura interrotta perde solo l'ultima riga), è streamable con memoria costante e mantiene intatti i dati annidati come varianti e recensioni.

Excel — per consegne una tantum agli analisti:

1from openpyxl import Workbook
2def export_excel(products, filename="walmart_products.xlsx"):
3    wb = Workbook(write_only=True)
4    ws = wb.create_sheet("Products")
5    ws.append(["Name", "Price", "Availability", "Rating", "Reviews", "Seller"])
6    for p in products:
7        ws.append([p.get("name"), p.get("price"), p.get("availability"),
8                    p.get("rating"), p.get("review_count"), p.get("seller")])
9    wb.save(filename)

Thunderbit copre anche l'esportazione per chi non usa Python: export con un clic su Google Sheets, Airtable, Notion, Excel, CSV e JSON — tutto gratis nel piano base. Per il monitoraggio ricorrente, la funzione di scheduled scraper di Thunderbit può eseguire estrazioni automatiche a intervalli.

Una nota sulla pianificazione: . I runner di GitHub Actions usano intervalli IP Azure che l'anti-bot di Walmart blocca all'istante. Usa APScheduler su un VPS oppure instrada tutto il traffico attraverso proxy residenziali.

Linee guida legali ed etiche per lo scraping di Walmart

Gli utenti dei forum esprimono chiaramente questa preoccupazione: "Non ho problemi a giocare al gatto e al topo con gli sviluppatori, ma sono meno tranquillo quando in gioco c'è il loro team legale."

I Termini di utilizzo di Walmart l'uso di "robot, spider... o qualsiasi altro dispositivo manuale o automatico per recuperare, indicizzare, 'scrapare', 'data mining' o in altro modo raccogliere materiali" senza "previo consenso scritto esplicito".

Il robots.txt di Walmart /search, /account, /api/ e decine di endpoint interni. Le pagine di dettaglio prodotto (/ip/...) e le recensioni (/reviews/product/) non sono vietate.

Il precedente hiQ v. LinkedIn (9° Circuito, ) ha stabilito che fare scraping di dati pubblicamente accessibili difficilmente viola il CFAA federale. Tuttavia, lo stesso tribunale ha poi stabilito che e ha emesso un contro di essa. Decisioni più recenti del 2024 (, ) hanno ulteriormente ristretto il CFAA e introdotto difese basate sulla preemption del copyright, ma quelle sentenze dipendevano da specifiche clausole dei ToU che non si applicano in modo lineare a Walmart.

Linee guida pratiche: non sovraccaricare i server. Rispetta i rate limit. Non estrarre dati personali o degli utenti. Usa i dati in modo responsabile. Fare scraping di pagine pubbliche di Walmart a una frequenza moderata per ricerca personale è un profilo di rischio molto diverso dallo scraping su scala commerciale in violazione dei Termini di Walmart. Se stai costruendo un prodotto basato sui dati di Walmart, parla con un avvocato e valuta le .

Disclaimer: queste informazioni hanno scopo educativo e non costituiscono consulenza legale.

Conclusione e punti chiave

Fare scraping di Walmart con Python è una sfida da a causa del doppio stack anti-bot Akamai + PerimeterX. Non è impossibile — ma servono gli strumenti e i pattern giusti.

Punti chiave:

• L'estrazione JSON __NEXT_DATA__ è la scelta pragmatica per la maggior parte dei casi. È ciò che usano tutti gli scraper Walmart open-source seri del periodo 2024–2026. Il path base è props.pageProps.initialData.data.product per le PDP e searchResult.itemStacks per search/browse.
• curl_cffi con impersonate="chrome124" è obbligatorio. Il semplice requests o httpx non può superare il fingerprinting TLS di Akamai, indipendentemente dagli header.
• I blocchi silenziosi sono il vero pericolo. Walmart restituisce 200 OK con corpi CAPTCHA. Controlla il contenuto della risposta, non solo gli status code.
• Gli scraper di produzione hanno bisogno di più del codice felice. Exponential backoff con jitter, rilevamento blocchi su quattro segnali, rate limiting a 3–6 secondi per richiesta, validazione dati e monitoraggio dello stato della sessione sono tutti essenziali.
• L'intercettazione delle API interne tramite /orchestra/* è potente ma fragile. Usala come esercizio con DevTools per esigenze specifiche di dati, non come metodo principale.
• Walmart limita i risultati di ricerca a 25 pagine. Puoi aggirare la limitazione con il cambio dell'ordine di ordinamento e la suddivisione per fascia di prezzo.
• Scegli con onestà l'approccio: Python fai-da-te per developer con esigenze personalizzate e volumi alti. Scraping API per team di media scala senza un ingegnere dello scraping. per utenti business che vogliono i dati in Google Sheets già nel pomeriggio.

Se vuoi provare la strada no-code, la ha un piano gratuito — puoi estrarre alcune pagine Walmart e vedere subito i risultati. Se invece vai con Python, i pattern di codice in questo articolo sono stati testati in produzione. In ogni caso, ora hai una mappa delle difese di Walmart e tre strade per attraversarle.

Per approfondire le tecniche di web scraping, consulta le nostre guide su , e . Puoi anche guardare i tutorial sul .

FAQ

È legale fare scraping dei dati prodotto Walmart?

I Termini di utilizzo di Walmart vietano lo scraping automatizzato senza consenso scritto. La sentenza del 9° Circuito hiQ v. LinkedIn (2022) ha stabilito che il CFAA federale difficilmente si applica allo scraping di pagine pubbliche, ma lo stesso caso si è concluso con una contro lo scraper. Fare scraping di pagine prodotto pubbliche a ritmi moderati per ricerca personale comporta un profilo di rischio molto diverso rispetto all'estrazione su scala commerciale. Consulta un avvocato se stai costruendo un business sui dati di Walmart.

Perché il mio scraper Walmart continua a essere bloccato?

Le cause più comuni sono: uso di requests o httpx standard (che generano un fingerprint TLS specifico di Python che Akamai segnala subito), header mancanti o errati, nessuna rotazione proxy, velocità di richiesta più rapide di 3–6 secondi per pagina e cookie di sessione mancanti (_px3, _abck, locDataV3). Passa a curl_cffi con impersonate="chrome124", usa proxy residenziali e implementa i pattern di rilevamento blocco e retry descritti in questo articolo.

Quali dati posso estrarre da Walmart con Python?

Nomi prodotto, prezzi (correnti e rollback), immagini, descrizioni brevi e lunghe, valutazioni, numero di recensioni, disponibilità stock, nomi dei seller, info sul produttore, opzioni di variante (taglia, colore) e posizionamento nelle categorie. Usando il metodo __NEXT_DATA__, tutti questi dati sono disponibili come JSON strutturato. L'intercettazione delle API interne può inoltre restituire prezzi a livello di variante, conteggi stock in tempo reale e dati delle recensioni paginati.

Ho bisogno di proxy per fare scraping di Walmart?

Sì, per qualsiasi uso in produzione o ripetuto. — anche con header perfetti, un IP non residenziale verrà segnalato dal sistema di reputazione IP di Akamai. Sono necessari proxy residenziali o mobili. Gli IP datacenter vengono bruciati quasi subito. Metti a budget circa 3–17 dollari per 1.000 pagine, a seconda del provider proxy e del piano.

Posso fare scraping di Walmart senza scrivere codice?

Sì. è un'estensione Chrome basata su AI che estrae Walmart in due clic: "AI Suggest Fields" per rilevare automaticamente le colonne dei dati prodotto, poi "Scrape" per estrarre i dati. Gestisce le sfide anti-bot nel cloud ed esporta direttamente in Excel, Google Sheets, Airtable o Notion — tutto gratis. È ideale per analisti, PM e utenti business che hanno bisogno di dati rapidamente senza costruire una pipeline personalizzata. Per scraping ad alto volume o altamente personalizzato, Python o una scraping API restano la scelta migliore.

Scopri di più