Cómo extraer datos de Walmart con Python (sin que te bloqueen)

Walmart cambia los precios de algunos productos . Si alguna vez intentaste seguir esos cambios de forma programática, ya sabes lo desesperante que puede ser: tu script aguanta 20 minutos y, de golpe, empieza a devolver páginas CAPTCHA que parecen respuestas normales 200 OK.

Le he dedicado bastante tiempo a trabajar con las defensas antibots de Walmart como parte de nuestras tareas de extracción de datos en , y quiero compartir todo lo que aprendí: qué métodos sí funcionan en 2025, cuáles son los errores silenciosos que contaminan los datos y las diferencias reales entre montar tu propio scraper, pagar una API de scraping o simplemente usar una herramienta sin código. Esta guía cubre tres métodos de extracción (parsing de HTML, JSON de __NEXT_DATA__ e interceptación de API internas), manejo de errores listo para producción que la mayoría de los tutoriales omiten por completo y un marco honesto para decidir qué enfoque te conviene. Aquí hay algo útil tanto si programas en Python como si solo quieres una hoja de cálculo con precios antes de comer.

¿Por qué extraer datos de Walmart con Python?

Walmart es el mayor minorista del mundo por ingresos: en el ejercicio fiscal 2025, y ha ocupado el . El sitio alberga aproximadamente , y el CFO de Walmart ha mencionado en su marketplace. Cerca de , lo que hace que el catálogo sea súper dinámico: los vendedores entran y salen, las variantes cambian y el inventario se mueve todos los días.

Esa volatilidad es precisamente por lo que el scraping importa. Un informe trimestral no puede captar lo que sí detecta una extracción nocturna. Estos son los casos de uso más comunes que veo:

Solo el y se prevé que llegue a 5.09 mil millones para 2033. El comportamiento del consumidor empuja este gasto: , y 83% compara en varios sitios.

Python es el lenguaje por defecto para este tipo de trabajo. El Informe de Infraestructura 2026 de Apify sitúa a , y la librería principal (requests) suma . Si vas a hacer scraping a cierta escala, casi seguro lo harás en Python.

Por qué Walmart es uno de los sitios más difíciles de extraer

Walmart es especialmente difícil porque usa dos productos comerciales antibot en serie: como capa perimetral WAF y de fingerprinting TLS, y como capa de desafío JavaScript basada en comportamiento. Scrape.do describe esta combinación como "rara y extremadamente difícil de sortear".

, y solo Akamai ya obtiene un 9/10. Por experiencia, esa valoración es bastante acertada.

Esto es lo que realmente tienes enfrente:

Akamai Bot Manager inspecciona tu fingerprint TLS (hash JA3/JA4), el orden de los frames HTTP/2, el orden y la capitalización de los headers, y las cookies de sesión (_abck, ak_bmsc). Una llamada estándar de Python con requests genera un fingerprint TLS que ningún navegador real produce, así que Akamai la marca antes de que la petición llegue siquiera a los servidores de Walmart.

PerimeterX/HUMAN entra después de Akamai y ejecuta fingerprinting con JavaScript (px.js), revisando propiedades de navigator, renderizado de canvas, WebGL, audio context y biometría de comportamiento (movimiento del ratón, velocidad de scroll, dinámica de teclado). El fallo visible es el famoso desafío : un botón que debes mantener pulsado durante unos 10 segundos mientras se recopilan señales de comportamiento. Oxylabs lo dice sin rodeos: "Walmart utiliza el modelo CAPTCHA 'Press & Hold', ofrecido por PerimeterX, que es casi imposible de resolver desde tu código".

El problema realmente peligroso es el bloqueo silencioso. Walmart devuelve HTTP 200 con un cuerpo CAPTCHA en lugar de un 403. : "Walmart devuelve un código de estado 200 OK incluso cuando sirve una página CAPTCHA. No puedes confiar solo en el código de estado para saber si tu solicitud tuvo éxito." Tu script analiza felizmente el HTML del CAPTCHA como si fuera "producto no encontrado" y sigue adelante. La mitad del dataset queda corrupta, y ni siquiera te enteras.

Luego está el problema de los datos con ámbito de tienda. Los precios y el inventario en Walmart dependen de la ubicación, y están controlados por cookies como locDataV3 y assortmentStoreId. Sin las cookies correctas, obtienes datos "nacionales por defecto" que pueden parecer completos pero no coinciden con lo que ve un comprador real. Las cookies faltantes no generan una página de bloqueo: generan datos incorrectos sin error visible, que es peor.

Tres métodos para extraer datos de Walmart (y cómo se comparan)

Antes de entrar al paso a paso, aquí tienes los tres enfoques principales de extracción. La mayoría de los tutoriales de la competencia solo cubren uno o dos. Yo voy a recorrer los tres para que puedas elegir el que encaje con tu caso.

El parsing de HTML es la peor opción para Walmart: el sitio usa bundles de Next.js con nombres de clases CSS con hash que cambian en cada despliegue. El método basado en JSON de __NEXT_DATA__ es la elección práctica que usan todos los scrapers serios de Walmart entre 2024 y 2026. La interceptación de API internas es la más potente, pero tiene matices que la mayoría de los tutoriales pasan por alto. Y Thunderbit es la opción correcta cuando no necesitas un pipeline personalizado.

Preparar tu entorno Python para extraer datos de Walmart

Esto es lo que necesitas:

• Dificultad: Intermedia
• Tiempo necesario: ~30 minutos para la configuración, más el tiempo de programación
• Lo que necesitas: Python 3.10+, pip, un editor de código y, para uso en producción, un servicio de proxies o una API de scraping

Crea la carpeta del proyecto y el entorno virtual:

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

Instala las librerías necesarias:

1pip install curl_cffi parsel beautifulsoup4 lxml

curl_cffi es el estándar de 2025 para extraer datos de sitios difíciles. Es un binding de libcurl que puede imitar con precisión los fingerprints TLS de un navegador real. : "Walmart usa fingerprinting TLS como parte de su detección de bots, y ni siquiera cambiar el User-Agent para simular un navegador real lo evitará". requests o httpx sin más no pueden superar Akamai, por muchos headers que uses. curl_cffi con impersonate="chrome124" es lo que marca la diferencia.

También te conviene tener json (incluido en la biblioteca estándar), csv (incluido), time, random y logging para los patrones de producción que veremos más adelante.

Paso a paso: extraer páginas de producto de Walmart con Python

Paso 1: obtener la página de producto de Walmart

Tu primera tarea es hacer una solicitud HTTP que no sea bloqueada de inmediato. Este es el conjunto de headers canónico usado por Scrapfly, Scrapingdog, Oxylabs y ScrapeOps entre 2024 y 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)

El parámetro impersonate="chrome124" es el que hace el trabajo pesado. Le dice a curl_cffi que reproduzca con exactitud el ClientHello TLS, el orden de los frames HTTP/2 y la secuencia de pseudo-headers de Chrome 124. Sin eso, Akamai ve un hash JA3 específico de Python y te bloquea antes de que la solicitud llegue a la capa de aplicación de Walmart.

Cómo se ve una respuesta bloqueada: si ves "Robot or human?" en el título HTML de la respuesta, o si esta redirige a walmart.com/blocked, te han detectado. Lo complicado es que Walmart a menudo devuelve un estado 200 con el cuerpo CAPTCHA, así que comprobar solo response.ok no basta.

Para cualquier uso repetido o en producción, necesitarás proxies residenciales. Las IP de datacenter se queman enseguida por el sistema de reputación IP de Akamai. Más abajo cubro la estrategia completa de errores y proxies en la sección de producción.

Paso 2: extraer los datos del producto desde el JSON de __NEXT_DATA__

Walmart.com es una aplicación Next.js, y el HTML renderizado en servidor incrusta todo el payload de hidratación dentro de una sola etiqueta script: <script id="__NEXT_DATA__" type="application/json">. Ese es el tesoro.

: "En 2026, Walmart usa Next.js con JSON estructurado en las etiquetas script de __NEXT_DATA__, lo que hace que la extracción de datos ocultos sea más fiable que el parsing tradicional con selectores CSS". Todos los scrapers de Walmart open source de alto perfil — , , — usan este método.

Así se extrae:

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 mayoría de los tutoriales se detienen aquí. Abajo tienes un mapa completo de rutas JSON para los campos que realmente importan, verificado en páginas activas de Walmart entre 2024 y 2026:

La ruta longDescription es la trampa más común. Un artículo de ScrapeHero de 2023 la ubicaba en product.longDescription, pero las fuentes de 2024 en adelante la sitúan de forma consistente en la clave hermana idml. Lee siempre primero idml.longDescription y deja product.longDescription como respaldo para páginas antiguas.

Aquí tienes un patrón de extracción seguro usando cadenas de .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    }

Para quienes no quieren lidiar con rutas JSON manualmente, la identifica y estructura estos campos automáticamente, sin necesidad de mapear rutas. Haces clic en "AI Suggest Fields", lee la página y obtienes una tabla. Pero si estás construyendo un pipeline personalizado, el mapa anterior será tu referencia.

Paso 3: interceptar los endpoints de la API interna de Walmart para obtener más datos

Ningún artículo de la competencia cubre bien este método. Es la vía de extracción más potente y también la más compleja.

El frontend de Walmart llama a un . Los endpoints viven bajo www.walmart.com/orchestra/*:

• /orchestra/pdp/graphql/... — hidratación de detalles del producto + cambios de variantes
• /orchestra/snb/graphql/... — paginación de búsqueda y exploración
• /orchestra/reviews/graphql/... — reseñas paginadas

Estos devuelven JSON limpio y estructurado con datos que __NEXT_DATA__ a veces recorta: precios por variante, stock en tiempo real, paginación completa de reseñas.

El detalle que muchos blogs esquivan: Walmart usa . El cuerpo de la solicitud envía solo un hash SHA-256 (persistedQuery.sha256Hash), no el texto de la consulta. Si el hash no existe en el servidor, obtienes PersistedQueryNotFound. Walmart rota estos hashes en cada despliegue. Por eso ninguno de los scrapers open source más conocidos de Walmart publica código listo para copiar y pegar para /orchestra/.

La forma práctica y honesta de usar este método es como ejercicio en DevTools:

1. Abre una página de producto de Walmart en Chrome
2. Abre DevTools → pestaña Network, filtra por "Fetch/XHR"
3. Navega por la página de forma normal — haz clic en variantes, desplázate hasta las reseñas, cambia la ubicación de la tienda
4. Busca solicitudes a endpoints /orchestra/* que devuelvan JSON con datos del producto
5. Haz clic derecho en la solicitud → "Copy as cURL"
6. Convierte el comando cURL a Python usando curl_cffi

Así se ve una llamada de API reproducida:

1import json
2from curl_cffi import requests
3session = requests.Session(impersonate="chrome124")
4# Primero, calienta la sesión visitando la página del producto
5session.get("https://www.walmart.com/ip/some-product/1234567", headers=HEADERS)
6# Luego reproduce la llamada a la API interna (copiada desde 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    # Pega aquí el cuerpo exacto de la solicitud desde 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()

El paso de calentar la sesión es fundamental. Las cookies PerimeterX de Walmart (_px3, _pxhd, ACID) deben establecerse con la primera descarga HTML antes de que la llamada a la API funcione. Sin ellas, obtendrás un 412 o un 403.

Cuándo usar este método: cuando necesitas datos que __NEXT_DATA__ no incluye — precios de variantes profundas, recuentos de stock en tiempo real o reseñas paginadas más allá del primer lote. Para la mayoría de los casos de uso, __NEXT_DATA__ es suficiente y mucho más sencillo.

Extraer resultados de búsqueda de Walmart y varias páginas

Los resultados de búsqueda siguen un patrón parecido de __NEXT_DATA__, pero con una ruta JSON diferente:

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# Filtrar productos patrocinados
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 paginación funciona incrementando el parámetro page: &page=1, &page=2, etc. Pero hay un límite no documentado: Walmart restringe los resultados de búsqueda a 25 páginas, sin importar el total real. : "Walmart establece en 25 el número máximo de páginas de resultados accesibles, independientemente del total de páginas disponibles".

Formas de ampliar la cobertura:

• Cambiar el orden de ordenación: ejecutar la misma consulta con &sort=price_low y luego con &sort=price_high para cubrir unas 50 páginas
• Dividir por rangos de precio: añadir &min_price=X&max_price=Y para fragmentar el catálogo en ventanas más pequeñas
• Dividir por categoría: buscar dentro de categorías concretas en lugar de todo el sitio

Ten en cuenta que itemStacks es un array. Scrapfly fija [0] en su repositorio, pero las páginas de categoría y exploración a veces contienen varios stacks ("Top picks", "More results"). El patrón robusto recorre todos los stacks:

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

También conviene saber esto: el robots.txt de Walmart . Las páginas de detalle de producto (/ip/...) y la mayoría de las páginas de categoría (/cp/...) no están desautorizadas. Si te preocupa el cumplimiento, empieza por las páginas de producto y los árboles de categorías antes que por la búsqueda.

No dejes que los bloqueos silenciosos arruinen tus datos: manejo de errores listo para producción

Aquí es donde la mayoría de los tutoriales se vienen abajo. Te muestran cómo obtener una página, parsear un producto y darlo por cerrado. En producción, estás extrayendo miles de páginas, y Walmart está intentando frenarte activamente. La diferencia entre un scraper demo y uno que de verdad funciona está en cómo maneja los fallos.

Detecta los bloqueos silenciosos antes de que corrompan tus datos

La función más importante de un scraper de Walmart es el detector de bloqueo. Basándome en el consenso de proveedores como , , y , necesitas cuatro comprobaciones independientes:

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. Redirección al endpoint de bloqueo dedicado
10    if "/blocked" in str(response.url):
11        return True
12    # 2. Códigos de estado duros
13    if response.status_code in (403, 412, 428, 429, 503):
14        return True
15    # 3. 200 OK con cuerpo CAPTCHA (el caso de bloqueo silencioso)
16    body = response.text or ""
17    if any(m.lower() in body.lower() for m in BLOCK_MARKERS):
18        return True
19    # 4. Comprobación de longitud de respuesta — los PDP reales pesan entre 300 y 900 KB
20    if len(response.content) < 50_000 and "/ip/" in str(response.url):
21        return True
22    return False

Esa cuarta comprobación —la longitud de la respuesta— detecta los casos en que Walmart devuelve una página reducida que no contiene marcadores CAPTCHA evidentes, pero tampoco contiene los datos del producto que necesitas.

Lógica de reintento con backoff exponencial y jitter

Cuando una solicitud falla, no conviene bombardear Walmart de nuevo enseguida. El patrón estándar usa backoff exponencial con jitter para desincronizar los reintentos:

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("Silent block detected")
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"Intento {attempt + 1} fallido: {e}. Reintentando en {wait:.1f}s")
20            time.sleep(wait)
21    return None

El jitter (random.uniform(0, 3)) no es decoración: desincroniza los workers para que una flota de scrapers no vuelva a intentar todos al mismo segundo y active los detectores de velocidad de Akamai.

Limitación de velocidad

Tanto como convergen en un retraso aleatorio de 3 a 6 segundos por solicitud para Walmart: "limita la frecuencia de tus peticiones esperando entre 3 y 6 segundos entre cargas de página y aleatoriza tus demoras".

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

A escala, considera usar aiolimiter para limitar la tasa en asincrónico:

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

Validación de datos

Incluso cuando la respuesta no está bloqueada, los datos parseados pueden estar mal (tienda equivocada, payload degradado). Valida antes de guardar el resultado:

1def validate_product(product):
2    """Devuelve True si los datos del producto parecen legítimos."""
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

Registro de sesión

Lleva un seguimiento de tu tasa de éxito por sesión. Cuando baje del 80% durante 10 minutos, algo cambió: la IP quedó marcada, las cookies expiraron o Walmart lanzó una nueva regla antibot.

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"La tasa de éxito cayó a {self.success_rate:.1f}% — considera rotar proxies o pausar")

No es glamuroso, pero es lo que mantiene limpios tus datos.

Python DIY vs. API de scraping vs. no-code: cómo elegir el enfoque correcto para extraer Walmart

Muchos desarrolladores se lanzan a construir un scraper a medida sin preguntarse si esa es la mejor opción. . En los foros lo describen como "básicamente 9/10" y se preguntan si "una API dedicada de web scraping sería demasiado". La respuesta depende del volumen, el presupuesto y la capacidad de ingeniería.

Cuándo tiene sentido hacer tu propio scraper en Python

La opción DIY gana cuando ya tienes un contrato de proxies, necesitas control estricto sobre headers, geotargeting por código postal o cohortes de vendedores, estás indexando millones de páginas al mes y las tarifas por registro de una API se disparan, o necesitas garantías de cumplimiento o despliegue on-premise. La contrapartida es el tiempo real de ingeniería: un spider Scrapy listo para producción con paginación, reintentos, rotación de proxies, impersonación TLS y esquemas para varios tipos de página puede requerir , además de 4–8 horas de mantenimiento al mes cuando Walmart rote los fingerprints.

Cuándo una API de scraping te ahorra tiempo

Las APIs de scraping gestionan la capa antibot para que tú no tengas que hacerlo. muestran tasas de éxito de y 98% para Scrape.do en Walmart. Los planes de entrada rondan los 40–49 dólares al mes para herramientas como , y . Si eres un equipo de 2 a 5 ingenieros y tu volumen está entre 10K y 1M de páginas al mes, una API casi siempre es la mejor decisión. Cambias coste por solicitud a cambio de cero mantenimiento.

Cuándo el no-code es la mejor opción

encaja en otro perfil por completo. Si eres PM, analista o responsable de e-commerce y necesitas los datos de productos de Walmart en una hoja de cálculo esta misma tarde —no en el próximo sprint—, una herramienta sin código es la respuesta más honesta.

El flujo es simple: instala la , entra en una página de producto o búsqueda de Walmart, haz clic en "AI Suggest Fields" y la IA de Thunderbit leerá la página y propondrá columnas (nombre del producto, precio, valoración, etc.). Haz clic en "Scrape" y los datos se vuelcan en una tabla. Exporta a Excel, Google Sheets, Airtable o Notion, todo gratis, sin muro de pago.

Thunderbit gestiona el antibot en la nube, así que no tienes que lidiar con CAPTCHAs, proxies ni fingerprinting TLS. La IA se adapta automáticamente a los cambios de diseño, así que no hay mantenimiento. Para usuarios que no quieren trabajar con rutas JSON manuales, esta es la vía de menor fricción.

Limitaciones honestas: Thunderbit no está pensado para 100K+ páginas al día. Los créditos y los límites de la nube hacen que la ingesta de alto volumen sea menos rentable que una API pura. Tampoco puedes fijar un código postal o una ASN específicos salvo que la herramienta lo permita. Para pipelines continuos y de alto volumen, sigue siendo mejor usar Python o una API de scraping.

Precio aproximado: 1,000 filas de productos de Walmart en Thunderbit cuestan alrededor de 2,000 créditos (~$0.60–$1.10 en los planes Starter/Pro). Eso es comparable a la API de Walmart de Oxylabs y más barato que muchas APIs de scraping para hobby a bajo volumen. para ver los detalles actuales.

Exportar los datos de Walmart que has extraído

Una vez que tienes los datos, necesitas llevarlos a un formato útil. Tres formatos cubren la mayoría de las necesidades:

CSV — el formato universal que los analistas realmente abren:

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 codificación utf-8-sig para que Excel sea compatible. El marcador BOM evita que Excel rompa caracteres especiales.

JSONL — el formato de producción para pipelines de 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 escritura interrumpida solo pierde la última línea), se puede transmitir con memoria constante y conserva intactos los datos anidados como variantes y reseñas.

Excel — para entregas puntuales a analistas:

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 cubre toda la parte de exportación para quienes no programan: exportación con un clic a Google Sheets, Airtable, Notion, Excel, CSV y JSON, todo gratis en el plan base. Para monitoreo recurrente, la función de scraper programado de Thunderbit puede ejecutar extracciones automáticas de forma periódica.

Una advertencia sobre la programación: . Los runners de GitHub Actions están en rangos IP de Azure que el antibot de Walmart bloquea al instante. Usa APScheduler en un VPS o redirige todo el tráfico a través de proxies residenciales.

Recomendaciones legales y éticas para extraer datos de Walmart

En los foros, esta preocupación aparece claramente: "No me importa jugar al gato y al ratón con los desarrolladores, pero me preocupa hacerlo con su equipo legal".

Los Términos de Uso de Walmart usar "cualquier robot, spider… u otro dispositivo manual o automático para recuperar, indexar, 'scrape', 'data mine' o de otro modo recopilar cualquier Material" sin "consentimiento previo expreso por escrito".

El robots.txt de Walmart /search, /account, /api/ y decenas de endpoints internos. Las páginas de detalle de producto (/ip/...) y las reseñas (/reviews/product/) no están desautorizadas.

El precedente hiQ v. LinkedIn (9th Circuit, ) estableció que extraer datos públicos probablemente no viola la CFAA federal. Pero ese mismo tribunal después determinó que y dictó una contra la empresa. Decisiones más recientes de 2024 (, ) limitaron aún más la CFAA y abrieron defensas de preempción por copyright, pero esos fallos dependieron de un lenguaje de ToU muy específico que no se traslada de forma limpia a Walmart.

Pautas prácticas: no sobrecargues los servidores. Respeta los límites de velocidad. No extraigas datos personales ni de usuarios. Usa los datos con responsabilidad. Extraer páginas públicas de productos de Walmart a una tasa moderada para investigación personal tiene un perfil de riesgo muy distinto al scraping a escala comercial en contra de los Términos de Walmart. Si vas a construir un producto basado en datos de Walmart, habla con un abogado y revisa las APIs oficiales de .

Aviso: esta información es educativa, no asesoría legal.

Conclusión y puntos clave

Extraer datos de Walmart con Python es un reto de por su doble capa antibot de Akamai + PerimeterX. No es imposible, pero necesitas las herramientas y patrones adecuados.

Puntos clave:

• La extracción vía JSON de __NEXT_DATA__ es la opción más práctica para la mayoría de los casos. Es la que usan todos los scrapers open source serios de Walmart entre 2024 y 2026. La ruta base es props.pageProps.initialData.data.product para PDPs y searchResult.itemStacks para búsqueda/exploración.
• curl_cffi con impersonate="chrome124" es obligatorio. requests o httpx sin más no pueden superar el fingerprinting TLS de Akamai, por muchos headers que uses.
• Los bloqueos silenciosos son el verdadero peligro. Walmart devuelve 200 OK con cuerpos CAPTCHA. Comprueba el contenido de la respuesta, no solo el código de estado.
• Los scrapers de producción necesitan más que código de happy path. Backoff exponencial con jitter, detección de bloqueo con cuatro señales, limitación de velocidad de 3 a 6 segundos por solicitud, validación de datos y monitoreo de salud de sesión son imprescindibles.
• La interceptación de API internas vía /orchestra/* es potente, pero frágil. Úsala como ejercicio con DevTools para necesidades concretas, no como método principal.
• Walmart limita los resultados de búsqueda a 25 páginas. Amplía la cobertura con cambios de ordenación y segmentación por rangos de precio.
• Elige con honestidad: Python DIY para desarrolladores con necesidades personalizadas y alto volumen. APIs de scraping para equipos medianos sin un ingeniero de scraping. para usuarios de negocio que quieren datos en Google Sheets esta misma tarde.

Si quieres probar la ruta sin código, la tiene una versión gratuita: puedes extraer unas cuantas páginas de Walmart y ver los resultados por ti mismo. Si prefieres Python, los patrones de código de este artículo están probados en producción. En cualquier caso, ahora tienes un mapa de las defensas de Walmart y tres caminos para sortearlas.

Para más información sobre técnicas de scraping web, consulta nuestras guías sobre , y . También puedes ver tutoriales en el .

Preguntas frecuentes

¿Es legal extraer datos de productos de Walmart?

Los Términos de Uso de Walmart prohíben el scraping automatizado sin consentimiento por escrito. La sentencia hiQ v. LinkedIn del 9th Circuit (2022) estableció que la CFAA federal probablemente no se aplica al scraping de páginas públicas, pero ese mismo caso terminó con una contra el scraper. Extraer páginas públicas de productos a una tasa moderada para investigación personal tiene un perfil de riesgo muy distinto al scraping a escala comercial. Consulta con un abogado si vas a montar un negocio sobre datos de Walmart.

¿Por qué mi scraper de Walmart sigue siendo bloqueado?

Las causas más comunes son: usar requests o httpx sin más (generan un fingerprint TLS específico de Python que Akamai detecta al instante), headers incorrectos o incompletos, no usar rotación de proxies, peticiones más rápidas de 3 a 6 segundos por página y cookies de sesión ausentes (_px3, _abck, locDataV3). Cambia a curl_cffi con impersonate="chrome124", usa proxies residenciales e implementa la detección de bloqueo y los reintentos descritos en este artículo.

¿Qué datos puedo extraer de Walmart con Python?

Nombres de productos, precios (actuales y rollback), imágenes, descripciones cortas y largas, valoraciones, cantidad de reseñas, estado de inventario, nombres de vendedores, información del fabricante, variantes (talla, color) y posicionamiento en categorías. Usando el método __NEXT_DATA__, todo eso está disponible como JSON estructurado. La interceptación de API internas puede devolver además precios por variante, inventario en tiempo real y datos de reseñas paginadas.

¿Necesito proxies para extraer datos de Walmart?

Sí, para cualquier uso en producción o repetido. : incluso con headers perfectos, una IP no residencial será marcada por el sistema de reputación de Akamai. Se requieren proxies residenciales o móviles. Las IP de datacenter se queman casi de inmediato. Calcula un coste aproximado de 3 a 17 dólares por cada 1,000 páginas, según el proveedor y el plan.

¿Puedo extraer datos de Walmart sin escribir código?

Sí. es una extensión de Chrome con IA que extrae Walmart en dos clics: "AI Suggest Fields" para detectar automáticamente las columnas de datos del producto y luego "Scrape" para extraer la información. Gestiona los desafíos antibot en la nube y exporta directamente a Excel, Google Sheets, Airtable o Notion, todo gratis. Es ideal para analistas, PMs y usuarios de negocio que necesitan datos rápido sin construir un pipeline a medida. Para scraping de alto volumen o muy personalizado, Python o una API de scraping siguen siendo la mejor opción.

Más información