Por seis semanas seguidas, meu scraper de avaliações da Amazon rodou redondo. Aí, numa manhã sem nada de especial, ele me devolveu um 200 OK acompanhado de uma página basicamente vazia. Nada de erro, nada de CAPTCHA — só um HTML em branco no lugar onde antes apareciam centenas de avaliações.
Se você já passou por isso, saiba que não é caso isolado. No fim de 2025, a Amazon começou a exigir login para abrir as páginas completas de avaliações, e um monte de script de scraping em Python parou de funcionar de uma hora para outra. Nos últimos meses, aqui na Thunderbit, encarei esse problema dos dois lados — ajudando a construir nosso scraper com IA e, ao mesmo tempo, mantendo meu próprio pipeline de avaliações em Python. Então resolvi escrever o guia que eu queria ter encontrado quando meu script quebrou. Aqui você vai ver a abordagem que de fato funciona hoje: autenticação por cookies, seletores estáveis que sobrevivem à ofuscação de CSS da Amazon, jeitos de furar o limite de 10 páginas da paginação, defesas contra detecção de bot e, de brinde, uma parte sobre análise de sentimento que transforma texto solto de avaliação em insight de negócio. E se em algum momento você pensar "olha, prefiro não viver mantendo esse código todo", vou mostrar também como a Thunderbit resolve o mesmo serviço em uns dois minutos, sem nenhuma linha de Python.
O que é scraping de avaliações da Amazon (e por que vale a pena)?
Fazer scraping de avaliações da Amazon é extrair, de forma programática, os dados das avaliações de clientes — nota em estrelas, texto da avaliação, nome de quem escreveu, data, selo de compra verificada — das páginas de produto da Amazon. Como a Amazon tirou o conteúdo das avaliações da sua Product Advertising API em 2010 (e nunca recolocou), o web scraping virou o único caminho programático para chegar nesses dados.
E os números explicam o interesse. 95% dos consumidores leem avaliações antes de comprar, e 94% afirmam que a Amazon é a fonte número um de avaliações de produtos. Mostrar só 5 avaliações numa página de produto já pode elevar a conversão em 270%. Empresas que analisam o sentimento das avaliações de forma sistemática chegam a registrar até 15% a mais de retenção de clientes. Não estamos falando de ciência de dados no abstrato — é inteligência competitiva, sinal para melhorar o produto e munição para o marketing, tudo em texto puro nos servidores da Amazon.
Por que usar Python para fazer scraping de avaliações da Amazon
Python segue sendo a linguagem favorita para esse tipo de tarefa. Ela é a linguagem mais desejada no Stack Overflow Developer Survey 2024, e o ecossistema dela — requests, BeautifulSoup, pandas, Scrapy — deixa o web scraping ao alcance até de quem não é dev de carteirinha.
Cada time aproveita esses dados de um jeito:
| Equipe | Caso de uso | O que extraem |
|---|---|---|
| Produto / P&D | Achar reclamações recorrentes, priorizar correções | Texto de avaliações de 1–2 estrelas, frequência de palavras-chave |
| Vendas | Acompanhar o sentimento sobre produtos concorrentes | Notas, tendências de volume de avaliações |
| Marketing | Capturar a linguagem do cliente para os textos de anúncio | Frases positivas, menções a recursos |
| Operações de e-commerce | Monitorar o sentimento dos próprios produtos ao longo do tempo | Distribuição de estrelas, proporção de compras verificadas |
| Pesquisa de mercado | Comparar líderes de categoria por atributo | Conjuntos de avaliações de vários ASINs |
Uma marca de utensílios de cozinha analisou as avaliações negativas e descobriu que 22% citavam que "o revestimento antiaderente solta com o tempo", refez o produto e voltou ao posto de #1 em Best Seller em 60 dias. Uma empresa de pulseiras fitness identificou "irritação na pulseira" no texto das avaliações, percebeu um problema de alergia ao látex, lançou uma versão hipoalergênica e cortou as devoluções em 40%. É esse tipo de ROI que justifica o trabalho de engenharia.
Tela de login: por que seu scraper de avaliações da Amazon parou de funcionar
Em 14 de novembro de 2024, a Amazon passou a pedir login para ver a página completa de avaliações de um produto. A mudança foi confirmada em fóruns da comunidade e em blogs de fornecedores de scraping. Abra /product-reviews/{ASIN}/ numa janela anônima e, em vez das avaliações, você cai direto na página de login.
O sintoma engana: seu script recebe um 200 OK, mas o corpo do HTML traz um formulário de login (name="email", id="ap_password") no lugar das avaliações. Nenhum código de erro. Nenhum CAPTCHA. Só... nada de útil.
A Amazon fez isso por motivos de anti-bot e de conformidade regional. A aplicação é meio irregular — às vezes uma janela nova de navegador carrega algumas avaliações antes de a barreira aparecer, principalmente na primeira página —, mas, para qualquer scraper rodando em escala, o melhor é partir do princípio de que a barreira está sempre de pé.
Cada domínio regional da Amazon (.de, .co.uk, .co.jp) aplica essa barreira por conta própria. Como resumiu um usuário de fórum: "precisa de um login para cada país". Os cookies do seu .com não valem no .co.uk.
Avaliações em destaque vs. avaliações completas: o que dá para pegar sem login
As páginas de produto da Amazon (a URL /dp/{ASIN}/) ainda mostram cerca de 8 "avaliações em destaque" sem precisar de autenticação. Elas são escolhidas pelo algoritmo da Amazon e servem para um diagnóstico rápido de sentimento, mas não dá para ordenar, filtrar nem paginar.
Já as páginas completas de avaliações (/product-reviews/{ASIN}/) — com ordenação por mais recentes, filtro por nota e navegação por centenas de avaliações — pedem login.
Se você só quer algumas avaliações para sentir o clima, raspe a página do produto. Para chegar às centenas ou aos milhares, vai ter que encarar a autenticação.
O que você precisa antes de começar: ambiente Python e bibliotecas
Antes de escrever qualquer linha, confira a preparação:
- Nível de dificuldade: intermediário (à vontade com Python e com 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 válida na Amazon
Instale as bibliotecas principais:
pip install requests beautifulsoup4 lxml pandas textblob
Opcional (para uma análise de sentimento mais robusta):
pip install transformers torch
O que é um ASIN? É o identificador de produto de 10 caracteres da Amazon. Ele aparece em qualquer URL de produto — em amazon.com/dp/B0BCNKKZ91, por exemplo, o ASIN é B0BCNKKZ91. É essa a chave que entra na URL das avaliações.
Passo 1: passe pela tela de login com autenticação por cookies
O jeito mais confiável é logar na Amazon pelo navegador, copiar os cookies da sessão e injetá-los no requests.Session() do Python. Assim você foge dos CAPTCHAs e da autenticação em dois fatores por SMS, que costumam travar a automação de 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 data e hora 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 ligada à sessão |
x-main | Identificador associado ao e-mail do usuário |
Como extrair os cookies no Chrome DevTools
- Faça login em amazon.com no Chrome
- Abra o DevTools (F12 ou botão direito → Inspecionar)
- Vá em Application → Storage → Cookies →
https://www.amazon.com - Encontre cada cookie da tabela e copie o valor
- Junte tudo numa string separada por ponto e vírgula para usar no Python
Monte a sessão assim:
import requests
session = requests.Session()
# Cole aqui os valores dos seus cookies
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: reaproveite o mesmo objeto session em todas as requisições. Isso mantém os cookies coerentes e imita uma sessão real de navegador. Em geral, os cookies aguentam de dias a semanas sob carga de scraping, mas, se você voltar a ser redirecionado para o login, é só renová-los pelo navegador.
Em marketplaces que não são o .com, os nomes dos cookies mudam um pouco — a amazon.de usa at-acbde no lugar de at-main, a amazon.co.uk usa at-acbuk, e por aí vai. Cada marketplace precisa da própria sessão, separada das demais.
Passo 2: monte a requisição e faça o parse do 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 a tela de login
if "ap_email" in response.text or "Amazon Sign-In" in response.text:
raise Exception("Tela de login detectada — atualize seus cookies")
if response.status_code != 200:
raise Exception(f"HTTP {response.status_code}")
return BeautifulSoup(response.text, "lxml")
Um truque que ajuda bastante: antes de abrir a página de avaliações, dê uma passada na página do produto. Isso cria um padrão de navegação mais natural dentro da sessão.
# Visite a página do produto primeiro (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 (pare de depender de classes CSS)
É aqui que boa parte dos tutoriais de 2022–2023 desmorona. A Amazon ofusca os nomes das classes CSS — eles mudam de tempos em tempos e, como desabafou um dev num fórum: "nenhum deles tinha um padrão único nos nomes de classe das tags span".
A solução: a Amazon usa atributos data-hook nos elementos das avaliações, 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 passam pela aleatorização.
| 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 de quem escreveu | 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 por 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
Venho rodando esse conjunto de seletores com vários ASINs há meses, e os atributos data-hook não mudaram nenhuma vez. As classes CSS, em contrapartida, 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 trava o parâmetro pageNumber em 10 páginas, com 10 avaliações cada — um teto rígido de cerca de 100 avaliações por combinação de filtro. Passou da página 10, o botão "Próxima página" some.
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 passar das 10 páginas de avaliações da Amazon
A saída é trabalhar com buckets por filtro. Cada combinação de filterByStar e sortBy ganha sua própria janela independente de 10 páginas.
Filtros por estrelas: one_star, two_star, three_star, four_star, five_star
Ordenações: recent, helpful (padrão)
Cruzando os 5 filtros por estrelas × 2 ordenações, dá para alcançar até 100 páginas, ou 1.000 avaliações por produto — e, em produtos com distribuição de notas bem desigual, costuma dar para chegar perto do conjunto inteiro.
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 buckets, então a deduplicação é indispensável. Eu uso a dupla título da avaliação + nome de quem escreveu como chave rápida — não é à prova de falhas, mas pega a esmagadora maioria das duplicatas.
Passo 5: contorne as defesas anti-bot (rotacione, vá com calma, tente de novo)
A Amazon usa o AWS WAF Bot Control, e ele ficou bem mais agressivo. Contramedidas de uma camada só — rotacionar User-Agents ou só colocar atrasos — já não seguram a barra.
| Técnica | Implementação |
|---|---|
| Rotação de User-Agents | Escolha aleatória entre 10+ strings reais de navegador |
| Backoff exponencial | Atrasos de nova tentativa de 2s → 4s → 8s em erros 503 |
| Controle de ritmo | random.uniform(2, 5) segundos entre páginas |
| Rotação de proxies | Alternar proxies residenciais |
| Impressão digital da sessão | Cookies + headers coerentes por sessão |
| Imitação de TLS | Use curl_cffi no lugar do requests padrão em produção |
Um wrapper de retry 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 ({response.status_code}). Aguardando {wait}s...")
time.sleep(wait)
continue
if "ap_email" in response.text:
raise Exception("Tela de login — cookies expiraram")
return BeautifulSoup(response.text, "lxml")
except Exception as e:
if attempt == max_retries - 1:
raise
print(f"Tentativa {attempt + 1} falhou: {e}")
return None
Uma palavra sobre proxies: a Amazon bloqueia faixas de IP conhecidas de datacenter (AWS, GCP, Azure, DigitalOcean) já no nível de rede. Se a ideia é raspar mais do que algumas centenas de páginas, proxies residenciais viram praticamente obrigatórios — conte gastar US$ 50–200+/mês, conforme o volume. Para projetos pequenos (menos de 100 requisições/dia), um throttling caprichado com o seu IP de casa costuma resolver.
A Amazon também olha o fingerprint de TLS. O requests padrão do Python tem um hash JA3 bem conhecido que os WAFs barram cedo. Em scrapers de produção, vale considerar o curl_cffi, que imita as stacks de TLS de navegadores reais. Para o volume de um tutorial (algumas centenas de páginas), o requests com bons headers normalmente dá conta.
Passo 6: exporte suas avaliações da Amazon para CSV ou Excel
Depois de juntar as avaliações, colocá-las num formato utilizável é moleza com o 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 inteiro, a tela é linda... | January 15, 2025 | the United States | True |
| Mike T. | 2.0 | Decepcionado depois de 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 eu preciso, com uma pequena lentidão em apps pesados... | March 10, 2025 | the United States | False |
Para exportar em Excel: df.to_excel("amazon_reviews.xlsx", index=False) (precisa do openpyxl).
Para o Google Sheets, a biblioteca gspread funciona, mas pede mais de 8 etapas de configuração no Google Cloud — criar um projeto, habilitar duas APIs, gerar credenciais de service account, compartilhar a planilha. Se isso parece dar mais trabalho que o próprio scraping, você não está errado. (É aí que uma ferramenta como a Thunderbit, que exporta para o Google Sheets com um clique, começa a ficar tentadora.)
Bônus: adicione análise de sentimento às avaliações em 5 linhas de Python
A maioria dos tutoriais de scraping encerra no export para CSV. Mas é justamente pontuar o sentimento que transforma dado bruto 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 (bem negativa) a +1.0 (bem positiva) para cada avaliação. Exemplo de saída:
| content (truncado) | rating | sentiment |
|---|---|---|
| "A bateria dura o dia inteiro, a tela é linda..." | 5.0 | 0.65 |
| "A porta de carregamento parou de funcionar depois de..." | 2.0 | -0.40 |
| "Faz tudo o que eu preciso, com uma pequena lentidão em..." | 4.0 | 0.25 |
| "Lixo absoluto. Devolvi na hora." | 1.0 | -0.75 |
| "É ok. Nada de mais, mas funciona." | 3.0 | 0.10 |
As linhas mais interessantes são as descompassadas — uma avaliação de 3 estrelas com texto positivo, ou uma de 5 estrelas com linguagem negativa. Esses desencontros costumam revelar opiniões mais matizadas do cliente, que a nota em estrelas sozinha esconde.
Para precisão em nível de produção, a indicação é Hugging Face Transformers. O VADER foi treinado em tweets, não em avaliações de produto, e modelos transformer chegam a mais de 98% de precisão na classificação de avaliações ante as ferramentas baseadas em léxico. O modelo nlptown/bert-base-multilingual-uncased-sentiment ainda prevê direto a nota de 1 a 5 estrelas:
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. Ou seja, a nota média muitas vezes é um péssimo proxy da qualidade real do produto. Recorte o grupo de 1 estrela e procure os temas que mais se repetem — em geral é ali que mora um defeito único e que dá para corrigir.
A escolha honesta: Python na unha 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 solta mais uma camada de detecção de bot e, do nada, seu sábado de manhã vira sessão de debugging em vez de análise de dados. Gente em fórum relata a mesma dor de cabeça — scripts caseiros que "funcionavam mês passado" e agora vivem pedindo conserto.
Veja como as três principais abordagens se comparam:
| Critério | Python na unha (BS4/Selenium) | API paga de scraping | Thunderbit (sem código) |
|---|---|---|---|
| Tempo de configuração | 1–3 horas | 30 min (chave de API) | 2 minutos |
| Custo | Grátis (+ custo de proxy) | US$ 50–200+/mês | Plano gratuito disponível |
| Tratamento da tela de login | Gestão manual de cookies | Normalmente já incluído | Resolvido automaticamente |
| Manutenção | Alta (seletores quebram) | Baixa (o provedor mantém) | Zero (a IA se adapta) |
| Paginação | Precisa de código próprio | Integrada | Integrada |
| Suporte multipaís | Sessões separadas por domínio | Normalmente suportado | Baseado no navegador = seu idioma/localidade |
| Análise de sentimento | Você escreve seu próprio código | Às vezes incluída | Exporte para o Sheets e analise onde quiser |
| Melhor para | Aprender, controle total | Pipelines de escala/produção | Capturas rápidas, equipes sem dev |
Python entrega controle total e é, de fato, o melhor jeito de aprender como o web scraping funciona por baixo do capô. As APIs pagas (ScrapingBee, Oxylabs, Bright Data) fazem sentido em pipelines de produção em que disponibilidade pesa mais que custo. E, para times que precisam dos dados de avaliação sem carregar a parte de desenvolvimento — operações de e-commerce que olham produtos concorrentes toda semana, marketing colhendo a linguagem do cliente para anúncios —, existe um terceiro caminho.
Como fazer scraping de avaliações da Amazon com a Thunderbit (sem código, sem manutenção)
Criamos a Thunderbit justamente para os cenários em que manter um scraper em Python soa como exagero. O fluxo é este:
- Instale a extensão Chrome da Thunderbit
- Abra a página de avaliações do produto na Amazon no seu navegador (você já está logado, então a tela de login deixa de ser problema)
- Clique em "AI Suggest Fields" — a Thunderbit lê a página e sugere colunas como Autor, Avaliação, Título, Texto da avaliação, Data, Compra verificada
- Clique em "Scrape" — os dados saem na hora, com paginação já embutida
- Exporte para Excel, Google Sheets, Airtable ou Notion
A grande sacada é que a IA da Thunderbit relê a estrutura da página do zero a cada execução. Nada de seletores CSS para manter, nada de gestão de cookies, nada de código anti-bot. Quando a Amazon mexe no HTML, a IA se ajusta. E, para quem quer acesso programático sem montar tudo na mão, a Thunderbit oferece ainda uma Extract API — extração estruturada via API com detecção de campos por IA, sem ter que manter seletores.
Para se aprofundar nos dados da Amazon, dá uma olhada nos nossos guias sobre como raspar produtos e avaliações da Amazon e extrair e analisar dados de vendas da Amazon.
Dicas para raspar 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:
- Agrupe seus ASINs com pausas entre os produtos, não só entre as páginas. Uso intervalos de 10–15 segundos entre ASINs.
- Deduplique com firmeza. Ao cruzar várias combinações de filtro por estrelas e ordenação, vão pintar avaliações sobrepostas. Use um conjunto de tuplas
(title, author, date)como chave de deduplicação. - Registre as falhas. Anote quais combinações de ASIN + página + filtro deram errado para poder repetir sem ter que raspar tudo de novo.
- Guarde num banco de dados em projetos grandes. Um SQLite simples escala muito melhor do que arquivos CSV que só engordam:
import sqlite3
conn = sqlite3.connect("reviews.db")
df.to_sql("reviews", conn, if_exists="append", index=False)
- Agende raspagens recorrentes. Para monitoramento contínuo, monte um cron job ou use o recurso Scheduled Scraper da Thunderbit — você descreve a URL e a agenda, e o sistema cuida do resto sem precisar de servidor.
Para outros caminhos, nossos posts sobre as melhores ferramentas automatizadas de web scraping e como extrair dados de sites para o Excel trazem mais opções.
Uma nota rápida sobre questões legais e éticas
Os Termos de Uso da Amazon proíbem expressamente "o uso de qualquer robô, spider, scraper ou outro meio automatizado para acessar os serviços da Amazon". Dito isso, decisões recentes da Justiça americana têm sido favoráveis a quem raspa dados públicos. Em Meta Platforms v. Bright Data (janeiro de 2024), um tribunal federal entendeu que raspar dados de acesso público não viola os termos de serviço quando o scraper não é um "usuário" logado.
O ponto-chave: raspar atrás de login (que é o foco deste tutorial) entra em terreno contratual, já que você aceitou os Termos de Uso da Amazon ao criar a conta. Raspar as avaliações em destaque, que são visíveis a todos, traz menos risco jurídico do que raspar além da tela de login.
Na prática: não redistribua comercialmente os dados raspados, não colete dados pessoais de usuários além do que já está exibido publicamente, respeite o robots.txt e consulte um advogado para usos comerciais ou em grande escala. Isto não é aconselhamento jurídico. Para mais contexto, 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 de vez
Recapitulando rápido o que este guia cobriu:
- A tela de login é real, mas dá para driblar com autenticação por cookies — copie 7 cookies do navegador e injete num
requests.Session() - Use seletores
data-hook, e não classes CSS, para uma extração que não quebra a cada poucas semanas - Cruze filtros por estrelas e ordenações para furar o limite de 10 páginas e chegar a 500+ avaliações por produto
- Adicione análise de sentimento com TextBlob para um baseline rápido, ou com Hugging Face Transformers para precisão de produção
- Mantenha as defesas anti-bot: controle de ritmo, rotação de User-Agent, backoff exponencial e proxies residenciais para escalar
Python dá controle total e é o melhor jeito de entender o que rola por baixo do capô. Mas, se o seu caso é "preciso de avaliações de concorrentes numa planilha até sexta" em vez de "quero montar um pipeline de dados de produção", o custo de manter um scraper sob medida pode não compensar.
A Thunderbit cuida de autenticação, seletores, paginação e exportação em poucos cliques — teste o plano gratuito e veja se encaixa no seu fluxo. À medida que a Amazon aperta cada vez mais as medidas anti-bot, ferramentas com IA que se adaptam em tempo real vão deixar de ser um luxo e virar necessidade.
Você também pode explorar o canal da Thunderbit no YouTube para ver tutoriais em vídeo sobre fluxos de scraping.
FAQs
1. Dá para raspar avaliações da Amazon sem fazer login?
Dá, mas só as cerca de 8 "avaliações em destaque" mostradas 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 negócio, vai ser preciso encarar a tela de login.
2. É legal fazer scraping de avaliações da Amazon?
Os Termos de Serviço da Amazon proíbem scraping automatizado. Por outro lado, decisões recentes da Justiça americana (Meta v. Bright Data, 2024; hiQ v. LinkedIn) dão respaldo ao scraping de dados de acesso público. Raspar atrás de login traz 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 dá para 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 por estrelas × 2 ordenações, dá para alcançar até 100 páginas (cerca de 1.000 avaliações) por produto. Com filtros por palavra-chave, o teto teórico é bem maior, embora com bastante duplicação.
4. Qual é a melhor biblioteca Python para raspar avaliações da Amazon?
requests + BeautifulSoup para HTML estático é a dupla mais comum e confiável. Selenium ajuda quando há renderização em JavaScript. Para uma alternativa sem código que cuida da tela de login e da paginação sozinha, experimente a Thunderbit.
5. Como evitar bloqueios ao raspar a Amazon?
Rotacione os User-Agents a partir de um conjunto de 10+ strings reais de navegador, coloque atrasos aleatórios de 2–5 segundos entre as requisições, implemente backoff exponencial em erros 503/429, use proxies residenciais para escalar (IPs de datacenter já costumam ser bloqueados) e mantenha os cookies de sessão coerentes entre as requisições. Para um caminho sem manutenção, a Thunderbit lida com as defesas anti-bot sozinha, por meio da sua sessão de navegador.
Saiba mais
