Meu scraper de avaliações da Amazon funcionou direitinho por seis semanas — até que, certa manhã, ele me devolveu 200 OK e uma página totalmente em branco. Sem erro, sem CAPTCHA, só HTML vazio onde antes apareciam centenas de avaliações.
Se isso te soa familiar, você não está sozinho. No fim de 2025, a Amazon passou a bloquear as páginas completas de avaliações por trás de um login, e um monte de scripts de scraping em Python parou de funcionar do dia para a noite. Passei os últimos meses na Thunderbit lidando com esse problema por dois lados — desenvolvendo nosso AI scraper e também mantendo meu próprio pipeline de avaliações em Python — então achei que era hora de escrever o guia que eu mesmo gostaria de ter tido quando meu script caiu. Este post cobre a abordagem que realmente funciona: autenticação baseada em cookies, seletores estáveis que aguentam a obfuscação de CSS da Amazon, alternativas para driblar o limite de 10 páginas de paginação, defesas anti-bot e, de bônus, uma seção de análise de sentimento que transforma texto cru de avaliações em insights de negócio de verdade. E se, no meio do caminho, você pensar: "Prefiro não manter todo esse código", vou te mostrar como a Thunderbit resolve a mesma tarefa em cerca de dois minutos, sem precisar de Python.
O que é o scraping de avaliações da Amazon (e por que isso importa)?
O scraping de avaliações da Amazon é o processo de extrair programaticamente dados de opiniões de clientes — estrelas, texto da avaliação, nome do autor, data, selo de compra verificada — das páginas de produtos da Amazon. Como a Amazon removeu o conteúdo das avaliações da Product Advertising API em 2010 (e nunca trouxe isso de volta), o web scraping é o único caminho programático para acessar esses dados.
Os números mostram isso com clareza. 95% dos compradores leem avaliações antes de comprar, e 94% dizem que a Amazon é sua principal fonte de avaliações de produtos. Exibir só 5 avaliações numa página de produto pode aumentar a conversão em 270%. Empresas que analisam o sentimento das avaliações de forma sistemática chegam a ter até 15% mais retenção de clientes. Isso não é ciência de dados abstrata — é inteligência competitiva, sinal de melhoria de produto e linguagem de marketing, tudo escrito em texto puro nos servidores da Amazon.
Por que fazer scraping de avaliações da Amazon com Python
Python continua sendo a linguagem favorita para esse tipo de trabalho. Ela é a linguagem mais desejada no Stack Overflow Developer Survey 2024, e seu ecossistema — requests, BeautifulSoup, pandas, Scrapy — deixa o web scraping acessível até para quem não é dev em tempo integral.
Times diferentes usam esses dados de jeitos diferentes:
| Equipe | Caso de uso | O que extraem |
|---|---|---|
| Produto / P&D | Identificar reclamações recorrentes e priorizar correções | Texto de avaliações 1–2 estrelas, frequência de palavras-chave |
| Vendas | Monitorar o sentimento sobre produtos concorrentes | Avaliações, tendências de volume de reviews |
| Marketing | Aproveitar a linguagem do cliente para textos de anúncios | Frases positivas de avaliações, menções a recursos |
| Operações de e-commerce | Acompanhar o sentimento do próprio produto ao longo do tempo | Distribuição de estrelas, proporção de compras verificadas |
| Pesquisa de mercado | Comparar líderes de categoria por funcionalidade | Conjuntos de avaliações de múltiplos ASINs |
Uma marca de utensílios de cozinha analisou avaliações negativas, encontrou 22% de menções a "revestimento antiaderente que desgasta", reformulou o produto e recuperou a posição de #1 Best Seller em 60 dias. Uma empresa de rastreadores fitness identificou "irritação na pulseira" no texto das avaliações, descobriu um problema de alergia a látex, lançou uma versão hipoalergênica e reduziu devoluções em 40%. Esse é o tipo de ROI que faz o esforço de engenharia valer a pena.
Login wall: por que seu scraper de avaliações da Amazon parou de funcionar
Em 14 de novembro de 2024, a Amazon passou a exigir login para ver a página completa de avaliações do produto. A mudança foi confirmada em fóruns da comunidade e em blogs de fornecedores de scraping. Se você acessar /product-reviews/{ASIN}/ numa janela anônima, vai ser redirecionado para uma página de login em vez de receber os dados das avaliações.
Os sintomas são discretos: seu script recebe uma resposta 200 OK, mas o corpo do HTML traz um formulário de login (name="email", id="ap_password") em vez das avaliações. Sem código de erro. Sem CAPTCHA. Só... nada útil.
A Amazon fez isso por motivos de anti-bot e conformidade regional. A aplicação é inconsistente — às vezes uma janela nova do navegador carrega algumas avaliações antes do bloqueio entrar em ação, especialmente na primeira página —, mas para qualquer scraper em escala, o ideal é assumir que o bloqueio está sempre ativo.
Os diferentes domínios regionais da Amazon (.de, .co.uk, .co.jp) aplicam o bloqueio de forma independente. Como disse um usuário num fórum: "é necessário um login para cada país". Seus cookies do .com não funcionam no .co.uk.
Avaliações em destaque vs. avaliações completas: o que ainda dá para acessar sem login
As páginas de produto da Amazon (a URL /dp/{ASIN}/) ainda exibem cerca de 8 "avaliações em destaque" sem autenticação. Elas são escolhidas pelo algoritmo da Amazon e servem para uma leitura rápida de sentimento, mas não podem ser ordenadas, filtradas nem paginadas.
As páginas completas de avaliações (/product-reviews/{ASIN}/) — com ordenação por mais recentes, filtro por nota e paginação em centenas de avaliações — exigem login.
Se você só precisa de algumas avaliações para ter uma noção rápida do cenário, raspe a página do produto. Para centenas ou milhares, você vai precisar lidar com autenticação.
O que você precisa antes de começar: configuração em Python e bibliotecas
Antes de escrever qualquer código, veja a configuração:
- Dificuldade: intermediária (confortável com Python e noções básicas de HTML)
- Tempo necessário: ~45 minutos para o pipeline completo; ~10 minutos para um scraping básico
- O que você vai precisar: Python 3.8+, navegador Chrome, uma conta Amazon válida
Instale as bibliotecas principais:
pip install requests beautifulsoup4 lxml pandas textblob
Opcional (para análise de sentimento mais avançada):
pip install transformers torch
O que é ASIN? É o identificador de produto de 10 caracteres da Amazon. Você encontra isso em qualquer URL de produto — por exemplo, em amazon.com/dp/B0BCNKKZ91, o ASIN é B0BCNKKZ91. Esse é o valor que você vai usar na URL das avaliações.
Passo 1: passar pelo login wall com autenticação baseada em cookies
A forma mais confiável é fazer login na Amazon no navegador, copiar os cookies da sua sessão e injetá-los no requests.Session() do Python. Isso evita acionar CAPTCHAs e a autenticação por SMS em duas etapas, que costumam aparecer quando você tenta automatizar o login com Selenium.
Você vai precisar destes sete cookies:
| Nome do cookie | Finalidade |
|---|---|
session-id | Identificador de sessão rotativo |
session-id-time | Carimbo de tempo da sessão |
session-token | Token de sessão rotativo |
ubid-main | Identificador de navegação do usuário |
at-main | Token principal de autenticação |
sess-at-main | Autenticação vinculada à sessão |
x-main | Identificador associado ao e-mail do usuário |
Como extrair cookies do Chrome DevTools
- Faça login em amazon.com no Chrome
- Abra o DevTools (F12 ou clique com o botão direito → Inspecionar)
- Vá em Application → Storage → Cookies →
https://www.amazon.com - Encontre cada nome de cookie da tabela e copie o valor
- Formate tudo como uma string separada por ponto e vírgula para usar no Python
Configure a sessão assim:
import requests
session = requests.Session()
# Cole os valores dos seus cookies aqui
cookies = {
"session-id": "YOUR_SESSION_ID",
"session-id-time": "YOUR_SESSION_ID_TIME",
"session-token": "YOUR_SESSION_TOKEN",
"ubid-main": "YOUR_UBID_MAIN",
"at-main": "YOUR_AT_MAIN",
"sess-at-main": "YOUR_SESS_AT_MAIN",
"x-main": "YOUR_X_MAIN",
}
headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
"Accept-Language": "en-US,en;q=0.5",
}
session.cookies.update(cookies)
session.headers.update(headers)
Importante: reutilize o mesmo objeto session em todas as requisições. Isso mantém os cookies consistentes e simula uma sessão real de navegador. Os cookies normalmente duram de dias a semanas sob carga de scraping, mas, se você voltar a ver redirecionamentos para login, atualize tudo no navegador.
Para marketplaces que não são .com, os nomes dos cookies mudam um pouco — a amazon.de usa at-acbde em vez de at-main, a amazon.co.uk usa at-acbuk e assim por diante. Cada marketplace precisa da sua própria sessão independente.
Passo 2: montar a requisição e analisar o HTML das avaliações com BeautifulSoup
A URL de avaliações da Amazon segue este padrão:
https://www.amazon.com/product-reviews/{ASIN}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1
A função principal:
from bs4 import BeautifulSoup
import time, random
def get_soup(session, url):
time.sleep(random.uniform(2, 5)) # Atraso educado
response = session.get(url, timeout=15)
# Detecta login wall
if "ap_email" in response.text or "Amazon Sign-In" in response.text:
raise Exception("Login wall detectado — atualize seus cookies")
if response.status_code != 200:
raise Exception(f"HTTP {response.status_code}")
return BeautifulSoup(response.text, "lxml")
Um truque simples que ajuda: antes de acessar a página de avaliações, visite primeiro a página do produto. Isso cria um padrão de navegação mais natural na sessão.
# Visite primeiro a página do produto (simula navegação real)
product_url = f"https://www.amazon.com/dp/{asin}"
session.get(product_url, timeout=15)
time.sleep(random.uniform(1, 3))
# Depois acesse a página de avaliações
reviews_url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1"
soup = get_soup(session, reviews_url)
Passo 3: use seletores estáveis para extrair os dados das avaliações (pare de depender de classes CSS)
É aqui que a maior parte dos tutoriais de 2022–2023 desaba. A Amazon embaralha os nomes das classes CSS — eles mudam de tempos em tempos e, como disse um desenvolvedor frustrado num fórum: "nenhum deles tinha um padrão único para os nomes das classes das tags span".
A solução: a Amazon usa atributos data-hook nos elementos de avaliação, e eles são surpreendentemente estáveis. São identificadores semânticos dos quais o próprio frontend da Amazon depende, então não são randomizados.
| Campo da avaliação | Seletor estável (data-hook) | Seletor frágil (classe) |
|---|---|---|
| Texto da avaliação | [data-hook="review-body"] | .review-text-content (muda) |
| Nota em estrelas | [data-hook="review-star-rating"] | .a-icon-alt (ambíguo) |
| Título da avaliação | [data-hook="review-title"] | .review-title (às vezes) |
| Nome do autor | span.a-profile-name | Relativamente estável |
| Data da avaliação | [data-hook="review-date"] | .review-date (depende da região) |
| Compra verificada | [data-hook="avp-badge"] | span.a-size-mini |
O código de extração usando seletores data-hook:
import re
def extract_reviews(soup):
reviews = []
review_divs = soup.select('[data-hook="review"]')
for div in review_divs:
# Nota em estrelas
rating_el = div.select_one('[data-hook="review-star-rating"]')
rating = None
if rating_el:
rating_text = rating_el.get_text(strip=True)
match = re.search(r'(\d\.?\d?)', rating_text)
if match:
rating = float(match.group(1))
# Título
title_el = div.select_one('[data-hook="review-title"]')
title = title_el.get_text(strip=True) if title_el else ""
# Corpo
body_el = div.select_one('[data-hook="review-body"]')
body = body_el.get_text(strip=True) if body_el else ""
# Autor
author_el = div.select_one('span.a-profile-name')
author = author_el.get_text(strip=True) if author_el else ""
# Data e país
date_el = div.select_one('[data-hook="review-date"]')
date_text = date_el.get_text(strip=True) if date_el else ""
# Formato: "Reviewed in the United States on January 15, 2025"
country_match = re.search(r'Reviewed in (.+?) on', date_text)
date_match = re.search(r'on (.+)$', date_text)
country = country_match.group(1) if country_match else ""
date = date_match.group(1) if date_match else ""
# Compra verificada
verified_el = div.select_one('[data-hook="avp-badge"]')
verified = bool(verified_el)
reviews.append({
"author": author,
"rating": rating,
"title": title,
"content": body,
"date": date,
"country": country,
"verified": verified,
})
return reviews
Tenho testado esse conjunto de seletores em vários ASINs há meses, e os atributos data-hook não mudaram uma única vez. Já as classes CSS mudaram pelo menos duas vezes no mesmo período.
Passo 4: lide com a paginação e o limite de 10 páginas da Amazon
A Amazon limita o parâmetro pageNumber a 10 páginas com 10 avaliações cada — um teto rígido de cerca de 100 avaliações por combinação de filtros. O botão "Next page" simplesmente some depois da página 10.
Loop básico de paginação:
all_reviews = []
for page in range(1, 11):
url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber={page}"
soup = get_soup(session, url)
page_reviews = extract_reviews(soup)
if not page_reviews:
break # Não há mais avaliações nesta página
all_reviews.extend(page_reviews)
print(f"Página {page}: {len(page_reviews)} avaliações")
Como obter mais de 10 páginas de avaliações da Amazon
A solução é agrupar por filtros. Cada combinação de filterByStar e sortBy ganha sua própria janela independente de 10 páginas.
Valores de filtro por estrelas: one_star, two_star, three_star, four_star, five_star
Valores de ordenação: recent, helpful (padrão)
Combinando os 5 filtros de estrelas × 2 ordenações, você pode acessar até 100 páginas, ou 1.000 avaliações por produto — e, para produtos com distribuição desigual de estrelas, muitas vezes chega bem perto do conjunto completo.
star_filters = ["one_star", "two_star", "three_star", "four_star", "five_star"]
sort_orders = ["recent", "helpful"]
all_reviews = []
seen_titles = set() # Deduplicação simples
for star in star_filters:
for sort in sort_orders:
for page in range(1, 11):
url = (
f"https://www.amazon.com/product-reviews/{asin}"
f"?filterByStar={star}&sortBy={sort}&pageNumber={page}"
)
soup = get_soup(session, url)
page_reviews = extract_reviews(soup)
if not page_reviews:
break
for review in page_reviews:
# Deduplica pela combinação título + autor
key = (review["title"], review["author"])
if key not in seen_titles:
seen_titles.add(key)
all_reviews.append(review)
print(f"[{star}/{sort}] Página {page}: {len(page_reviews)} avaliações")
print(f"Total de avaliações únicas: {len(all_reviews)}")
Vai haver sobreposição entre os grupos, então a deduplicação é essencial. Eu uso uma combinação de título da avaliação + nome do autor como chave rápida — não é perfeita, mas pega a grande maioria dos duplicados.
Passo 5: fuja das defesas anti-bot (rotacionar, desacelerar, repetir)
A Amazon usa o AWS WAF Bot Control, e ele ficou bem mais agressivo. Contra-medidas de uma só camada (só rotacionar User-Agents, só colocar atrasos) já não dão conta.
| Técnica | Implementação |
|---|---|
| Rotação de User-Agents | Escolha aleatória entre 10+ strings reais de navegador |
| Backoff exponencial | Atrasos de repetição de 2s → 4s → 8s em respostas 503 |
| Limitação de taxa | random.uniform(2, 5) segundos entre páginas |
| Rotação de proxies | Ciclo por proxies residenciais |
| Impressão digital da sessão | Cookies + headers consistentes por sessão |
| Impersonação TLS | Use curl_cffi em vez de requests puro em produção |
Um wrapper de repetição pronto para produção:
import time, random
USER_AGENTS = [
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0",
"Mozilla/5.0 (Macintosh; Intel Mac OS X 15_7_5) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15",
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36",
]
def scrape_with_retries(session, url, max_retries=3):
for attempt in range(max_retries):
try:
session.headers["User-Agent"] = random.choice(USER_AGENTS)
time.sleep(random.uniform(2, 5))
response = session.get(url, timeout=15)
# Detecta bloqueios
if "validateCaptcha" in response.url or "Robot Check" in response.text:
wait = (2 ** attempt) * 5
print(f"CAPTCHA detectado. Aguardando {wait}s...")
time.sleep(wait)
continue
if response.status_code in (429, 503):
wait = (2 ** attempt) * 2
print(f"Limite de requisições atingido ({response.status_code}). Aguardando {wait}s...")
time.sleep(wait)
continue
if "ap_email" in response.text:
raise Exception("Login wall — os cookies expiraram")
return BeautifulSoup(response.text, "lxml")
except Exception as e:
if attempt == max_retries - 1:
raise
print(f"Falha na tentativa {attempt + 1}: {e}")
return None
Uma observação sobre proxies: a Amazon bloqueia faixas conhecidas de IPs de datacenter (AWS, GCP, Azure, DigitalOcean) no nível da rede. Se você for raspar mais de algumas centenas de páginas, proxies residenciais são praticamente obrigatórios — espere gastar de US$ 50 a US$ 200+ por mês, dependendo do volume. Para projetos menores (menos de 100 requisições por dia), um throttling cuidadoso a partir do seu IP residencial costuma funcionar bem.
A Amazon também inspeciona fingerprints TLS. A biblioteca padrão requests do Python tem um JA3 conhecido que muitos WAFs já bloqueiam. Para scrapers de produção, considere curl_cffi, que imita stacks TLS reais de navegadores. Para scraping em escala de tutorial (algumas centenas de páginas), requests com bons headers normalmente resolve.
Passo 6: exporte suas avaliações da Amazon para CSV ou Excel
Depois de coletar as avaliações, transformar isso em um formato utilizável é simples com pandas:
import pandas as pd
df = pd.DataFrame(all_reviews)
df.to_csv("amazon_reviews.csv", index=False)
print(f"Exportadas {len(df)} avaliações para amazon_reviews.csv")
Exemplo de saída:
| author | rating | title | content | date | country | verified |
|---|---|---|---|---|---|---|
| Sarah M. | 5.0 | Melhor compra do ano | A bateria dura o dia todo, a tela é linda... | January 15, 2025 | the United States | True |
| Mike T. | 2.0 | Decepcionado após 2 semanas | A porta de carregamento parou de funcionar... | February 3, 2025 | the United States | True |
| Priya K. | 4.0 | Ótimo custo-benefício | Faz tudo o que preciso, com um pequeno atraso em apps pesados... | March 10, 2025 | the United States | False |
Para exportar para Excel: df.to_excel("amazon_reviews.xlsx", index=False) (requer openpyxl).
Para Google Sheets, a biblioteca gspread funciona, mas exige mais de 8 etapas de configuração no Google Cloud — criar um projeto, ativar duas APIs, gerar credenciais de service account e compartilhar a planilha. Se isso parece dar mais trabalho do que o próprio scraping, você não está errado. (Esse é um daqueles momentos em que uma ferramenta como a Thunderbit, que exporta para Google Sheets com um clique, começa a parecer muito tentadora.)
Bônus: adicione análise de sentimento às suas avaliações em 5 linhas de Python
A maioria dos tutoriais de scraping para no export para CSV. Mas pontuar sentimento é o que transforma dados brutos em decisão de negócio.
O baseline mais rápido usa TextBlob:
from textblob import TextBlob
df["sentiment"] = df["content"].apply(lambda x: TextBlob(str(x)).sentiment.polarity)
Isso gera uma pontuação de polaridade de -1.0 (muito negativa) a +1.0 (muito positiva) para cada avaliação. Exemplo de saída:
| content (resumido) | rating | sentiment |
|---|---|---|
| "A bateria dura o dia todo, a tela é linda..." | 5.0 | 0.65 |
| "A porta de carregamento parou de funcionar depois..." | 2.0 | -0.40 |
| "Faz tudo o que preciso, com leve lentidão em..." | 4.0 | 0.25 |
| "Lixo absoluto. Devolvi imediatamente." | 1.0 | -0.75 |
| "É ok. Nada especial, mas funciona." | 3.0 | 0.10 |
As linhas mais interessantes são as divergentes — uma avaliação de 3 estrelas com texto positivo, ou uma de 5 estrelas com linguagem negativa. Essas discrepâncias costumam revelar opiniões mais nuançadas do que a nota sozinha mostra.
Para precisão de nível profissional, a recomendação é usar Hugging Face Transformers. VADER foi treinado em tweets, não em avaliações de produtos, e modelos transformer alcançam mais de 98% de precisão na classificação de reviews em comparação com ferramentas baseadas em léxico. O modelo nlptown/bert-base-multilingual-uncased-sentiment chega até a prever notas de 1 a 5 estrelas diretamente:
from transformers import pipeline
clf = pipeline("sentiment-analysis",
model="nlptown/bert-base-multilingual-uncased-sentiment")
df["predicted_stars"] = df["content"].apply(
lambda x: int(clf(str(x)[:512])[0]["label"][0])
)
As avaliações da Amazon seguem uma distribuição em forma de J — um pico grande em 5 estrelas, um pico menor em 1 estrela e um vale no meio. Isso significa que a média das estrelas costuma ser um indicador fraco da qualidade real do produto. Segmente o grupo de 1 estrela e procure padrões recorrentes — geralmente é ali que fica escondido um único defeito corrigível.
O trade-off honesto: Python do zero vs. APIs pagas de scraping vs. Thunderbit
Já mantive scrapers em Python para a Amazon, e vou ser sincero: eles quebram. Os seletores mudam, os cookies expiram, a Amazon lança uma nova camada de detecção de bots e, de repente, seu sábado de manhã vira debugging de scraper em vez de análise de dados. Usuários de fóruns relatam a mesma frustração — scripts caseiros que "funcionavam no mês passado" agora precisam de remendos o tempo todo.
Veja como as três abordagens principais se comparam:
| Critério | Python DIY (BS4/Selenium) | API paga de scraping | Thunderbit (no-code) |
|---|---|---|---|
| Tempo de configuração | 1–3 horas | 30 min (chave de API) | 2 minutos |
| Custo | Grátis (+ custos de proxy) | US$ 50–200+/mês | Plano gratuito disponível |
| Tratamento do login wall | Gerenciamento manual de cookies | Normalmente já resolvido | Resolvido automaticamente |
| Manutenção | Alta (seletores quebram) | Baixa (o fornecedor mantém) | Zero (a IA se adapta) |
| Paginação | Código customizado necessário | Integrado | Integrado |
| Suporte multi-país | Sessões separadas por domínio | Normalmente suportado | Baseado no navegador = seu locale |
| Análise de sentimento | Você adiciona o código | Às vezes incluída | Exporta para Sheets, analisa onde quiser |
| Melhor para | Aprendizado, controle total | Escala, pipelines de produção | Extrações rápidas, equipes sem dev |
Python oferece controle total e é realmente a melhor forma de aprender como o web scraping funciona por baixo do capô. APIs pagas (ScrapingBee, Oxylabs, Bright Data) fazem sentido para pipelines de produção em que disponibilidade importa mais do que custo. E, para times que precisam de dados de reviews sem o peso do desenvolvimento — operações de e-commerce monitorando concorrentes semanalmente, equipes de marketing puxando linguagem do cliente para anúncios — existe um terceiro caminho.
Como fazer scraping de avaliações da Amazon com Thunderbit (sem código, sem manutenção)
Criamos a Thunderbit para lidar exatamente com os cenários em que manter um scraper em Python parece exagero. O fluxo é assim:
- Instale a extensão Chrome da Thunderbit
- Acesse a página de avaliações do produto da Amazon no navegador (você já estará logado, então o login wall deixa de ser um problema)
- Clique em "AI Suggest Fields" — a Thunderbit lê a página e sugere colunas como Autor, Nota, Título, Texto da Avaliação, Data, Compra Verificada
- Clique em "Scrape" — os dados são extraídos na hora, com paginação embutida
- Exporte para Excel, Google Sheets, Airtable ou Notion
A grande vantagem é que a IA da Thunderbit lê a estrutura da página do zero toda vez. Sem seletor CSS para manter, sem gerenciamento de cookies, sem código anti-bot. Quando a Amazon muda o HTML, a IA se adapta. Para quem quer acesso programático sem fazer tudo do zero, a Thunderbit também oferece uma Extract API — extração estruturada via API com detecção de campos por IA, sem manutenção de seletores.
Para se aprofundar mais em dados da Amazon, veja nossos guias sobre como fazer scraping de produtos e avaliações da Amazon e extração e análise de dados de vendas da Amazon.
Dicas para fazer scraping de avaliações da Amazon em escala com Python
Se você for raspar avaliações de muitos ASINs, algumas práticas vão te poupar muita dor de cabeça:
- Faça os ASINs em lotes com pausas entre produtos, não só entre páginas. Eu uso pausas de 10 a 15 segundos entre ASINs.
- Deduplicate com rigor. Ao combinar múltiplos filtros de estrelas e ordens de classificação, vai haver avaliações repetidas. Use um conjunto de tuplas
(title, author, date)como chave de deduplicação. - Registre falhas. Acompanhe quais combinações de ASIN + página + filtro falharam para poder tentar de novo sem precisar raspar tudo outra vez.
- Armazene em banco de dados para projetos grandes. Um banco SQLite simples escala muito melhor do que arquivos CSV crescendo sem controle:
import sqlite3
conn = sqlite3.connect("reviews.db")
df.to_sql("reviews", conn, if_exists="append", index=False)
- Agende raspagens recorrentes. Para monitoramento contínuo, configure um cron job ou use o recurso Scheduled Scraper da Thunderbit — descreva a URL e o cronograma, e ela cuida do resto sem servidor.
Para abordagens adicionais, nossos posts sobre melhores ferramentas automatizadas de web scraping e como raspar dados de sites para Excel trazem outras opções.
Uma nota rápida sobre aspectos legais e éticos
Os Termos de Uso da Amazon proíbem explicitamente "o uso de qualquer robô, spider, scraper ou outro meio automatizado para acessar os Serviços Amazon". Dito isso, casos recentes da justiça dos EUA têm sido favoráveis a scrapers de dados públicos. Em Meta Platforms v. Bright Data (janeiro de 2024), um tribunal federal decidiu que raspar dados publicamente acessíveis não viola os termos de serviço quando o scraper não é um "usuário" logado.
A nuance: fazer scraping atrás de login — que é exatamente o que este tutorial cobre — entra no campo do direito contratual, já que você aceitou os Termos de Uso da Amazon ao criar sua conta. Raspar avaliações em destaque visíveis publicamente traz menos risco jurídico do que raspar por trás da login wall.
Diretrizes práticas: não redistribua comercialmente os dados raspados, não colete dados pessoais de usuários além do que já aparece publicamente, respeite o robots.txt e consulte um advogado para uso em larga escala ou comercial. Isto não é aconselhamento jurídico. Para saber mais sobre o cenário legal, veja nossa visão geral sobre implicações legais do web scraping.
Conclusão: raspe avaliações da Amazon com Python ou pule o código por completo
Resumo rápido do que este guia mostrou:
- O login wall é real, mas dá para contornar com autenticação baseada em cookies — copie 7 cookies do navegador e injete-os em uma
requests.Session() - Use seletores
data-hook, não classes CSS, para uma extração que não quebra a cada poucas semanas - Combine filtros de estrelas e ordens de classificação para driblar o limite de 10 páginas e acessar 500+ avaliações por produto
- Adicione análise de sentimento com TextBlob para um baseline rápido ou Hugging Face Transformers para precisão de produção
- Mantenha defesas anti-bot: limitação de taxa, rotação de User-Agent, backoff exponencial e proxies residenciais em escala
Python dá controle total e é a melhor forma de entender o que está acontecendo por baixo do capô. Mas, se o seu caso de uso é "preciso de dados de avaliações dos concorrentes numa planilha até sexta" em vez de "quero construir um pipeline de dados de produção", o custo de manutenção de um scraper personalizado pode não compensar.
A Thunderbit cuida de autenticação, seletores, paginação e exportação com poucos cliques — experimente a versão gratuita e veja se ela encaixa no seu fluxo. Enquanto a Amazon continua apertando as regras anti-bot, ferramentas com IA que se adaptam em tempo real vão deixar de ser diferencial e virar necessidade.
Você também pode explorar nosso canal da Thunderbit no YouTube para ver tutoriais em vídeo sobre fluxos de scraping.
FAQs
1. É possível raspar avaliações da Amazon sem fazer login?
Sim, mas só as cerca de 8 "avaliações em destaque" exibidas na página de detalhes do produto (/dp/{ASIN}/). As páginas completas de avaliações, com ordenação, filtros e paginação, exigem autenticação desde o fim de 2024. Para a maioria dos casos de uso de negócio, você vai precisar lidar com o login wall.
2. É legal raspar avaliações da Amazon?
Os Termos de Uso da Amazon proíbem scraping automatizado. No entanto, decisões recentes da justiça dos EUA (Meta v. Bright Data, 2024; hiQ v. LinkedIn) dão suporte à coleta de dados publicamente acessíveis. Fazer scraping atrás de login envolve risco jurídico maior, já que você concordou com os termos da Amazon. Consulte um advogado para uso comercial.
3. Quantas avaliações da Amazon posso raspar por produto?
A Amazon limita as páginas de avaliações a 10 por combinação de ordenação e filtro por estrelas. Usando os 5 filtros de estrelas × 2 ordens de classificação, você pode acessar até 100 páginas (cerca de 1.000 avaliações) por produto. Com filtros por palavra-chave, o teto teórico é muito maior, embora com sobreposição significativa.
4. Qual é a melhor biblioteca Python para raspar avaliações da Amazon?
requests + BeautifulSoup para análise de HTML estático é a combinação mais comum e confiável. Selenium é útil quando há renderização por JavaScript. Para uma alternativa sem código que lida automaticamente com login wall e paginação, experimente a Thunderbit.
5. Como evitar bloqueio ao raspar a Amazon?
Rotacione strings de User-Agent de um conjunto com 10+ navegadores reais, adicione atrasos aleatórios de 2 a 5 segundos entre requisições, implemente backoff exponencial em erros 503/429, use proxies residenciais em escala (IPs de datacenter já são bloqueados de cara) e mantenha cookies consistentes entre as requisições. Para uma abordagem sem manutenção, a Thunderbit lida automaticamente com as defesas anti-bot através da sua sessão no navegador.
Saiba mais
