Como Fazer Scraping do Walmart com Python (Sem Ser Bloqueado)

O Walmart muda o preço de alguns itens . Se você já tentou acompanhar isso por código, sabe como é irritante: o script roda por uns 20 minutos e, de repente, começa a devolver páginas de CAPTCHA disfarçadas de respostas normais 200 OK.

Passei bastante tempo lidando com as proteções anti-bot do Walmart no nosso trabalho de extração de dados na , e quero compartilhar tudo o que aprendi — os métodos que realmente funcionam em 2025, as falhas silenciosas que contaminam seus dados e os trade-offs honestos entre montar seu próprio scraper, pagar por uma API de scraping ou simplesmente usar uma ferramenta no-code. Este guia cobre três métodos de extração (análise de HTML, JSON do __NEXT_DATA__ e interceptação de APIs internas), tratamento de erros pronto para produção que a maioria dos tutoriais ignora por completo e uma estrutura clara para escolher a abordagem certa. Tem algo aqui tanto para quem programa em Python quanto para quem só quer uma planilha cheia de preços até a hora do almoço.

Por Que Fazer Scraping do Walmart com Python?

O Walmart é o maior varejista do mundo em receita — no exercício fiscal de 2025, mantendo o . O site hospeda cerca de , e o CFO do Walmart mencionou no marketplace. Cerca de , o que deixa o catálogo bem volátil — vendedores entram e saem, variantes mudam e o estoque oscila todo dia.

Essa volatilidade é justamente o motivo de o scraping importar. Um relatório trimestral não consegue enxergar o que um scraping noturno revela. Estes são os casos de uso mais comuns que eu vejo:

Só o e deve bater US$ 5,09 bilhões até 2033. O comportamento do consumidor empurra esse investimento: , e 83% pesquisam preços em vários sites.

Python é a linguagem padrão para esse tipo de trabalho. O relatório de infraestrutura da Apify para 2026 aponta , e a biblioteca principal (requests) tem . Se você está fazendo scraping em qualquer escala, é bem provável que esteja usando Python.

Por Que o Walmart É Um dos Sites Mais Difíceis de Fazer Scraping

O Walmart é particularmente difícil porque usa dois produtos comerciais anti-bot em série: , como camada de WAF na borda e de fingerprinting TLS, e , como camada de desafio JavaScript comportamental. A Scrape.do chama essa combinação de "rara e extremamente difícil de contornar".

, e só o Akamai já recebe 9/10. Na minha experiência, isso faz sentido.

Veja o que você realmente enfrenta:

Akamai Bot Manager inspeciona o fingerprint TLS (hash JA3/JA4), a ordem dos frames HTTP/2, a ordem e a capitalização dos headers e os cookies de sessão (_abck, ak_bmsc). Uma chamada padrão do Python requests gera um fingerprint TLS que nenhum navegador real produz — o Akamai identifica isso antes mesmo de a requisição chegar aos servidores do Walmart.

PerimeterX/HUMAN entra em ação depois do Akamai, executando fingerprinting em JavaScript (px.js) que verifica propriedades do navigator, renderização de canvas, WebGL, contexto de áudio e biometria comportamental (movimento do mouse, velocidade de rolagem, dinâmica de teclado). A falha visível é o famigerado desafio — um botão que você precisa segurar por cerca de 10 segundos enquanto os sinais comportamentais são coletados. A Oxylabs é direta: "O Walmart usa o modelo CAPTCHA 'Press & Hold', oferecido pelo PerimeterX, que é conhecido por ser quase impossível de resolver via código."

O comportamento realmente perigoso é o bloqueio silencioso. O Walmart retorna HTTP 200 com um corpo de CAPTCHA em vez de um 403. : "O Walmart retorna o status 200 OK mesmo quando serve uma página de CAPTCHA. Você não pode confiar apenas no status code para saber se a requisição funcionou." Seu script interpreta tranquilamente o HTML do CAPTCHA como "produto não encontrado" e segue em frente. Metade do seu dataset vira lixo — e você nem percebe.

Depois existe o problema de dados ligados à loja. Preços e estoque do Walmart variam conforme a localização e são controlados por cookies como locDataV3 e assortmentStoreId. Sem os cookies certos, você recebe dados "nacionais padrão" que podem parecer completos, mas não batem com o que um cliente real vê. Cookies ausentes não geram uma página de bloqueio — geram dados errados sem falha visível, o que é pior.

Três Métodos Para Extrair Dados do Walmart (e Como Eles Se Comparam)

Antes do passo a passo, aqui estão as três abordagens principais de extração. A maioria dos tutoriais da concorrência cobre só uma ou duas. Vou passar pelas três para você escolher a que faz mais sentido no seu caso.

Analisar HTML é a pior opção para o Walmart — o site usa bundles Next.js com nomes de classes CSS hashados que mudam a cada deploy. O método com JSON do __NEXT_DATA__ é a escolha pragmática usada por praticamente todo scraper sério de Walmart entre 2024 e 2026. A interceptação de APIs internas é a mais poderosa, mas tem pegadinhas que a maioria dos tutoriais ignora. E a Thunderbit é a melhor escolha quando você nem precisa de um pipeline personalizado.

Preparando Seu Ambiente Python Para Fazer Scraping do Walmart

Você vai precisar de:

• Nível de dificuldade: Intermediário
• Tempo necessário: ~30 minutos de configuração, mais o tempo de desenvolvimento
• O que você precisa: Python 3.10+, pip, um editor de código e, para uso em produção, um serviço de proxy ou uma API de scraping

Crie a pasta do projeto e o ambiente virtual:

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

Instale as bibliotecas necessárias:

1pip install curl_cffi parsel beautifulsoup4 lxml

curl_cffi é o padrão de 2025 para scrapers em alvos difíceis. É uma biblioteca que integra o libcurl e consegue imitar fingerprints TLS exatos de navegadores. : "O Walmart usa fingerprinting TLS como parte da detecção de bots, e nem mesmo definir o User-Agent para simular um navegador real é suficiente para passar." O requests puro ou httpx não conseguem passar pelo Akamai, independentemente dos headers que você definir. É o curl_cffi com impersonate="chrome124" que faz a diferença.

Você também vai querer json (nativo), csv (nativo), time, random e logging para os padrões de produção que veremos adiante.

Passo a Passo: Como Fazer Scraping das Páginas de Produto do Walmart com Python

Passo 1: Buscar a Página de Produto do Walmart

Sua primeira tarefa é fazer uma requisição HTTP que não seja bloqueada imediatamente. Este é o conjunto de headers canônico usado por Scrapfly, Scrapingdog, Oxylabs e ScrapeOps entre 2024 e 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)

O parâmetro impersonate="chrome124" está fazendo o trabalho pesado aqui. Ele diz ao curl_cffi para reproduzir com precisão o ClientHello TLS do Chrome 124, a ordem dos frames HTTP/2 e a sequência de pseudo-headers. Sem isso, o Akamai vê um hash JA3 específico de Python e bloqueia sua requisição antes que ela chegue à camada de aplicação do Walmart.

Como fica uma resposta bloqueada: Se você vir "Robot or human?" no título do HTML da resposta, ou se a resposta redirecionar para walmart.com/blocked, você foi pego. O ponto complicado é que o Walmart frequentemente retorna o status 200 com o corpo do CAPTCHA — então verificar só response.ok não basta.

Para qualquer uso recorrente ou de produção, você vai precisar de proxies residenciais. IPs de datacenter são queimados rapidamente pelo sistema de reputação de IP do Akamai. Vou detalhar a estratégia completa de tratamento de erro e proxy na seção de produção abaixo.

Passo 2: Extrair os Dados do Produto do JSON __NEXT_DATA__

O Walmart.com é uma aplicação Next.js, e o HTML renderizado pelo servidor embute o payload completo de hidratação dentro de uma única tag de script: <script id="__NEXT_DATA__" type="application/json">. Esse é o verdadeiro tesouro.

: "Em 2026, o Walmart usa Next.js com JSON estruturado em tags de script __NEXT_DATA__, tornando a extração de dados ocultos mais confiável do que a análise tradicional por seletores CSS." Todo scraper open-source de Walmart de alto nível — , , — usa esse método.

Veja como extrair:

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", {})

A maioria dos tutoriais para por aqui. Abaixo está um mapa completo de caminhos JSON para os campos que realmente importam — validado em páginas reais do Walmart entre 2024 e 2026:

O caminho longDescription é a armadilha que pega muita gente. Um post da ScrapeHero de 2023 colocava isso em product.longDescription, mas fontes de 2024 em diante consistentemente apontam para a chave irmã idml. Sempre leia primeiro idml.longDescription e use product.longDescription só como fallback para páginas antigas.

Aqui está o padrão seguro de extração usando encadeamento 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 quem não quer lidar com navegação de caminhos JSON, a identifica e estrutura esses campos automaticamente — sem precisar mapear caminhos manualmente. Você clica em "AI Suggest Fields", a ferramenta lê a página e devolve uma tabela. Mas, se você está montando um pipeline personalizado, o mapa acima é sua referência.

Passo 3: Intercepte os Endpoints de API Interna do Walmart para Dados Mais Ricos

Nenhum artigo concorrente cobre esse método direito. É o caminho de extração mais poderoso — e o mais complicado.

O front-end do Walmart chama um . Os endpoints ficam em www.walmart.com/orchestra/*:

• /orchestra/pdp/graphql/... — hidratação da página de produto + troca de variantes
• /orchestra/snb/graphql/... — paginação de busca e navegação
• /orchestra/reviews/graphql/... — reviews paginados

Eles retornam JSON limpo e estruturado com dados que o __NEXT_DATA__ às vezes omite ou resume — preços por variante, estoque em tempo real, paginação completa de reviews.

O detalhe que os posts costumam contornar: o Walmart usa . O corpo da requisição envia só um hash SHA-256 (persistedQuery.sha256Hash), e não o texto da query. Se o hash não for reconhecido pelo servidor, você recebe PersistedQueryNotFound. O Walmart troca esses hashes a cada deploy. É por isso que nenhum scraper open-source famoso de Walmart publica código copiável de /orchestra/.

A forma prática e honesta de usar esse método é via DevTools:

1. Abra uma página de produto do Walmart no Chrome
2. Abra DevTools → aba Network, filtre por "Fetch/XHR"
3. Navegue normalmente — clique em variantes, role até os reviews, mude a localização da loja
4. Observe requisições para endpoints /orchestra/* que retornam JSON com dados do produto
5. Clique com o botão direito na requisição → "Copy as cURL"
6. Converta o comando cURL para Python usando curl_cffi

Veja como fica uma chamada de API reproduzida:

1import json
2from curl_cffi import requests
3session = requests.Session(impersonate="chrome124")
4# Primeiro, aqueça a sessão visitando a página do produto
5session.get("https://www.walmart.com/ip/some-product/1234567", headers=HEADERS)
6# Depois reproduza a chamada da API interna (copiada do 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    # Cole o corpo exato da requisição a partir do 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()

A etapa de aquecer a sessão é crítica. Os cookies PerimeterX do Walmart (_px3, _pxhd, ACID) precisam ser definidos pela primeira requisição HTML antes que a chamada à API funcione. Sem eles, você recebe um 412 ou 403.

Quando usar este método: quando você precisa de dados que o __NEXT_DATA__ não traz — preços detalhados por variante, contagem de estoque em tempo real ou reviews paginados além do primeiro lote. Para a maioria dos casos, o __NEXT_DATA__ já é suficiente e muito mais simples.

Fazendo Scraping dos Resultados de Busca e de Várias Páginas do Walmart

Os resultados de busca seguem um padrão semelhante ao do __NEXT_DATA__, mas com um caminho 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 produtos 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"))

A paginação funciona incrementando o parâmetro page: &page=1, &page=2 etc. Mas aqui está o limite não documentado: o Walmart limita os resultados de busca a 25 páginas, independentemente do total real. : "O Walmart define o número máximo de páginas de resultados acessíveis em 25, independentemente do total de páginas disponíveis."

Estratégias para ampliar a cobertura:

• Inverter a ordem de classificação: rode a mesma consulta com &sort=price_low e depois com &sort=price_high para obter cerca de 50 páginas de cobertura
• Fatiar por faixa de preço: adicione &min_price=X&max_price=Y para dividir o catálogo em janelas menores
• Fatiar por categoria: pesquise dentro de categorias específicas em vez de usar o site inteiro

Observe que itemStacks é um array. A Scrapfly usa [0] fixo no repositório, mas páginas de categorias e navegação às vezes contêm múltiplos stacks ("Top picks", "More results"). O padrão robusto percorre todos os stacks:

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

Outro ponto importante: o robots.txt do Walmart . Páginas de detalhe de produto (/ip/...) e a maioria das páginas de categoria (/cp/...) não são desautorizadas. Se sua preocupação for conformidade, comece por páginas de produto e árvores de categoria, em vez de busca.

Não Deixe Bloqueios Silenciosos Estragarem Seus Dados: Tratamento de Erros Pronto Para Produção

A maioria dos tutoriais desmorona aqui. Eles mostram como buscar uma página, analisar um produto e encerrar. Em produção, você está buscando milhares de páginas, e o Walmart está ativamente tentando te impedir. A diferença entre um scraper de demonstração e um scraper que realmente funciona está em como ele lida com falhas.

Detecte Bloqueios Silenciosos Antes Que Eles Corrompam Seus Dados

A função mais importante de um scraper do Walmart é o detector de bloqueio. Com base no consenso dos fornecedores entre , , e , você precisa de quatro verificações independentes:

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. Redirecionamento para o endpoint de bloqueio dedicado
10    if "/blocked" in str(response.url):
11        return True
12    # 2. Códigos de status duros
13    if response.status_code in (403, 412, 428, 429, 503):
14        return True
15    # 3. HTTP 200 com corpo de CAPTCHA (o caso de bloqueio silencioso)
16    body = response.text or ""
17    if any(m.lower() in body.lower() for m in BLOCK_MARKERS):
18        return True
19    # 4. Sanidade pelo tamanho da resposta — PDPs reais têm 300 a 900 KB
20    if len(response.content) < 50_000 and "/ip/" in str(response.url):
21        return True
22    return False

Essa quarta checagem — tamanho da resposta — pega os casos em que o Walmart devolve uma página reduzida que não contém marcadores óbvios de CAPTCHA, mas também não contém os dados do produto que você precisa.

Lógica de Tentativa com Backoff Exponencial e Jitter

Quando uma requisição falha, você não quer martelar o Walmart imediatamente. O padrão correto usa backoff exponencial com jitter para desalinhar as tentativas:

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"Attempt {attempt + 1} failed: {e}. Retrying in {wait:.1f}s")
20            time.sleep(wait)
21    return None

O jitter (random.uniform(0, 3)) não é enfeite — ele desincroniza os workers para que uma frota de scrapers não tente tudo no mesmo segundo e acione os detectores de velocidade do Akamai.

Limitação de Taxa

Tanto a quanto a convergem para um atraso aleatório de 3 a 6 segundos por requisição no Walmart: "limite suas requisições esperando de 3 a 6 segundos entre os carregamentos de página e randomize os atrasos."

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

Em escala, considere usar aiolimiter para rate limiting assíncrono:

1from aiolimiter import AsyncLimiter
2limiter = AsyncLimiter(max_rate=10, time_period=60)  # 10 requisições por minuto

Validação de Dados

Mesmo quando a resposta não está bloqueada, os dados parseados podem estar errados (loja errada, payload degradado). Valide antes de gravar a saída:

1def validate_product(product):
2    """Retorna True se os dados do produto parecem 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 Sessão

Acompanhe sua taxa de sucesso por sessão. Quando ela cair abaixo de 80% por 10 minutos, algo mudou — seu IP foi queimado, seus cookies expiraram ou o Walmart implantou uma nova regra 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"Success rate dropped to {self.success_rate:.1f}% — consider rotating proxies or pausing")

Não é glamouroso. Mas é isso que mantém seus dados limpos.

Python Feito na Mão vs. API de Scraping vs. No-Code: Como Escolher a Forma Certa de Fazer Scraping do Walmart

Muitos desenvolvedores já saem montando um scraper personalizado sem se perguntar se essa é mesmo a melhor escolha. . Usuários em fóruns descrevem como "basicamente 9/10" e se perguntam "se uma API dedicada de scraping não seria exagero". A resposta depende de volume, orçamento e capacidade de engenharia.

Quando Faz Sentido Usar Python DIY

A abordagem DIY vence quando você já tem contrato de proxy, precisa de controle rígido sobre headers, targeting por CEP ou cohort de vendedores, está indexando milhões de páginas por mês em que taxas por registro de API começam a pesar, ou precisa de garantias on-prem ou de compliance. O trade-off é tempo real de engenharia: um spider Scrapy pronto para produção com paginação, retries, rotação de proxy, impersonação TLS e schemas para múltiplos tipos de página leva , mais 4–8 horas por mês de manutenção conforme o Walmart muda os fingerprints.

Quando Uma API de Scraping Economiza Seu Tempo

APIs de scraping cuidam da camada anti-bot para você. mostram taxas de sucesso de e 98% para a Scrape.do no Walmart. Os planos iniciais ficam em US$ 40–US$ 49/mês para ferramentas como , e . Se você tem uma equipe de 2 a 5 engenheiros e o volume de scraping fica entre 10 mil e 1 milhão de páginas por mês, uma API quase sempre é a escolha certa. Você troca custo por requisição por manutenção praticamente zero.

Quando No-Code é a Melhor Escolha

A atende a um perfil diferente. Se você é PM, analista ou operador de e-commerce e precisa dos dados de produtos do Walmart em uma planilha ainda hoje — não no próximo sprint — a resposta honesta é usar uma ferramenta no-code.

O fluxo é simples: instale a , navegue até uma página de produto ou busca do Walmart, clique em "AI Suggest Fields" e a IA da Thunderbit lê a página e sugere colunas (nome do produto, preço, avaliação etc.). Clique em "Scrape" e os dados vão para uma tabela. Exporte para Excel, Google Sheets, Airtable ou Notion — tudo grátis, sem paywall.

A Thunderbit trata o anti-bot na nuvem, então você não lida com CAPTCHAs, proxies ou fingerprinting TLS. A IA se adapta automaticamente a mudanças de layout, então não há manutenção. Para quem não quer mexer com navegação de caminhos JSON, esse é o caminho de menor atrito.

Limitações honestas: a Thunderbit não foi feita para 100 mil+ páginas por dia. Orçamentos de créditos e limites da nuvem tornam ingestão em altíssimo volume menos econômica do que APIs brutas. Também não dá para fixar um CEP ou ASN específico, a menos que a ferramenta suporte isso. Para pipelines contínuos e de alto volume, DIY ou API de scraping ainda é o melhor caminho.

Estimativa rápida de preço: 1.000 linhas de produto do Walmart na Thunderbit custam cerca de 2.000 créditos (~US$ 0,60–US$ 1,10 nos planos Starter/Pro). Isso é comparável à API do Walmart da Oxylabs e mais barato do que a maioria das APIs de scraping para hobby em baixo volume. para ver os valores atualizados.

Exportando os Dados do Walmart Após o Scraping

Depois de coletar os dados, você precisa colocá-los em um formato útil. Três formatos cobrem a maioria das necessidades:

CSV — o formato universal que analistas realmente abrem:

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})

Use a codificação utf-8-sig para compatibilidade com o Excel. O marcador BOM evita que o Excel deturpe caracteres especiais.

JSONL — o formato de produção 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")

(uma escrita interrompida perde só a última linha), pode ser transmitido em fluxo com memória constante e preserva intactos dados aninhados como variantes e reviews.

Excel — para entregas únicas 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)

A Thunderbit cobre a parte de exportação para quem não programa em Python: exportação com um clique para Google Sheets, Airtable, Notion, Excel, CSV e JSON — tudo grátis no plano base. Para monitoramento recorrente, o recurso de scraper agendado da Thunderbit pode executar extrações automaticamente.

Uma observação sobre agendamento: . Os runners do GitHub Actions usam faixas de IP da Azure que o anti-bot do Walmart bloqueia imediatamente. Use APScheduler em um VPS ou encaminhe todo o tráfego por proxies residenciais.

Diretrizes Legais e Éticas Para Fazer Scraping do Walmart

Usuários em fóruns deixam essa preocupação explícita: "Não me importo de brincar de gato e rato com desenvolvedores, mas fico receoso de brincar com a equipe jurídica deles."

Os Termos de Uso do Walmart usar "qualquer robô, spider... ou outro dispositivo manual ou automático para recuperar, indexar, 'raspar', 'minerar dados' ou de qualquer outra forma coletar quaisquer Materiais" sem "consentimento prévio por escrito".

O robots.txt do Walmart /search, /account, /api/ e dezenas de endpoints internos. Páginas de detalhe de produto (/ip/...) e reviews (/reviews/product/) não estão desautorizadas.

O precedente hiQ v. LinkedIn (9ª Vara, ) estabeleceu que fazer scraping de dados públicos provavelmente não viola o CFAA federal. Mas o mesmo tribunal depois decidiu que a e impôs um contra ela. Decisões mais recentes de 2024 (, ) restringiram ainda mais o CFAA e criaram defesas de preempção por copyright, mas esses julgamentos dependem de linguagem específica dos ToU que não se aplica diretamente ao Walmart.

Diretrizes práticas: não sobrecarregue servidores. Respeite limites de taxa. Não faça scraping de dados pessoais ou de usuários. Use os dados com responsabilidade. Fazer scraping de páginas públicas de produtos do Walmart em ritmo moderado para pesquisa pessoal é um perfil de risco bem diferente de fazer scraping em escala comercial contra os Termos do Walmart. Se você vai construir um produto com dados do Walmart, fale com um advogado e avalie as .

Aviso: este conteúdo é informativo e não constitui aconselhamento jurídico.

Conclusão e Principais Aprendizados

Fazer scraping do Walmart com Python é um desafio de por causa da combinação de anti-bot Akamai + PerimeterX. Não é impossível — mas você precisa das ferramentas e dos padrões certos.

Principais aprendizados:

• A extração via JSON do __NEXT_DATA__ é a escolha pragmática para a maioria dos casos. É o que todo scraper sério de Walmart open-source entre 2024 e 2026 usa. O caminho base é props.pageProps.initialData.data.product para PDPs e searchResult.itemStacks para busca/navegação.
• curl_cffi com impersonate="chrome124" é obrigatório. requests ou httpx puros não conseguem passar pelo fingerprinting TLS do Akamai, independentemente dos headers.
• Bloqueios silenciosos são o verdadeiro perigo. O Walmart retorna 200 OK com corpos de CAPTCHA. Verifique o conteúdo da resposta, não só o status code.
• Scrapers de produção precisam de mais do que código do caminho feliz. Backoff exponencial com jitter, detecção de bloqueio em quatro sinais, rate limiting de 3–6 segundos por requisição, validação de dados e monitoramento de saúde da sessão são essenciais.
• Interceptar APIs internas via /orchestra/* é poderoso, mas frágil. Use isso como exercício de DevTools para necessidades específicas, e não como método principal de extração.
• O Walmart limita os resultados de busca a 25 páginas. Amplie a cobertura com inversão da ordem de classificação e fatiamento por faixa de preço.
• Escolha sua abordagem com honestidade: Python DIY para desenvolvedores com necessidades personalizadas e alto volume. APIs de scraping para equipes de médio porte sem engenheiro de scraping. para usuários de negócio que querem os dados no Google Sheets ainda hoje.

Se você quiser testar a abordagem no-code, a tem um plano gratuito — você pode extrair algumas páginas do Walmart e ver os resultados por conta própria. Se for seguir pelo caminho do Python, os padrões de código deste artigo foram testados em produção. De qualquer forma, agora você tem um mapa das defesas do Walmart e três caminhos para atravessá-las.

Para mais conteúdos sobre técnicas de web scraping, confira nossos guias sobre , e . Você também pode assistir aos tutoriais no .

FAQs

É legal fazer scraping dos dados de produtos do Walmart?

Os Termos de Uso do Walmart proíbem scraping automatizado sem consentimento por escrito. A decisão hiQ v. LinkedIn da 9ª Vara (2022) estabeleceu que o CFAA federal provavelmente não se aplica ao scraping de páginas públicas, mas o mesmo caso terminou com uma contra a parte que fazia o scraping. Fazer scraping de páginas públicas de produtos em ritmo moderado para pesquisa pessoal tem um perfil de risco bem diferente de extração em escala comercial. Consulte um advogado se estiver construindo um negócio em cima de dados do Walmart.

Por que meu scraper do Walmart continua sendo bloqueado?

As causas mais comuns são: usar requests ou httpx puros (que geram um fingerprint TLS específico de Python e o Akamai identifica imediatamente), headers incorretos ou incompletos, ausência de rotação de proxy, requisições em intervalos menores que 3 a 6 segundos por página e cookies de sessão ausentes (_px3, _abck, locDataV3). Mude para curl_cffi com impersonate="chrome124", use proxies residenciais e implemente os padrões de detecção de bloqueio e retry descritos neste artigo.

Quais dados posso extrair do Walmart com Python?

Nomes de produtos, preços (atuais e de rollback), imagens, descrições curtas e longas, avaliações, quantidade de reviews, status de estoque, nomes de vendedores, informações do fabricante, opções de variantes (tamanho, cor) e posicionamento por categoria. Usando o método __NEXT_DATA__, tudo isso fica disponível em JSON estruturado. A interceptação de API interna também pode retornar preços por variante, contagem de estoque em tempo real e dados paginados de reviews.

Preciso de proxies para fazer scraping do Walmart?

Sim, para qualquer uso recorrente ou de produção. — mesmo com headers perfeitos, um IP não residencial será sinalizado pelo sistema de reputação de IP do Akamai. Proxies residenciais ou móveis são necessários. IPs de datacenter são queimados quase imediatamente. Faça uma estimativa de US$ 3 a US$ 17 por 1.000 páginas, dependendo do provedor e do plano.

Posso fazer scraping do Walmart sem escrever código?

Sim. é uma extensão Chrome com IA que faz scraping do Walmart em dois cliques: "AI Suggest Fields" para detectar automaticamente as colunas de dados do produto e depois "Scrape" para extrair os dados. Ela trata os desafios anti-bot na nuvem e exporta diretamente para Excel, Google Sheets, Airtable ou Notion — tudo grátis. É ideal para analistas, PMs e usuários de negócio que precisam de dados rapidamente, sem montar um pipeline personalizado. Para scraping de alto volume ou altamente customizado, Python ou uma API de scraping ainda são a melhor opção.

Saiba mais