Como eu faço scraping de avaliações da Amazon com Python (ultrapassando a tela de login)

Meu scraper de avaliações da Amazon funcionou certinho por seis semanas — até que, numa manhã qualquer, devolveu 200 OK e uma página praticamente vazia. Sem erro, sem CAPTCHA, só HTML em branco onde antes havia centenas de avaliações.

Se isso soa familiar, você não está sozinho. No fim de 2025, a Amazon passou a exigir login para acessar suas páginas completas de avaliações, e uma porção enorme de scripts de scraping em Python parou de funcionar do nada. Nos últimos meses, na , eu trabalhei nesse problema por dois lados — desenvolvendo nosso scraper com IA e também mantendo meu próprio pipeline de avaliações em Python — então achei que já era hora de escrever o guia que eu gostaria de ter lido 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 contornar o limite de 10 páginas de paginação, defesas contra bots e, como bônus, uma seção de análise de sentimento que transforma texto bruto de avaliações em insights de negócio de verdade. E, se no meio do caminho você pensar: "prefiro não ficar mantendo todo esse código", eu também vou mostrar como a resolve o mesmo trabalho 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 avaliações de clientes — nota por estrelas, texto da avaliação, nome do autor, data, selo de compra verificada — das páginas de produtos da Amazon. Como a Amazon (e nunca trouxe de volta), o web scraping é o único caminho programático para acessar esses dados.

Os números deixam isso bem claro. , e . Exibir só 5 avaliações numa página de produto pode . Empresas que analisam sentimento de avaliações de forma sistemática chegam a ver . Isso não é ciência de dados abstrata — é inteligência competitiva, sinais para melhoria de produto e linguagem de marketing, tudo escrito em texto simples nos servidores da Amazon.

Por que fazer scraping de avaliações da Amazon com Python

Python continua sendo a linguagem preferida para esse tipo de trabalho. Ela é a , e seu ecossistema — requests, BeautifulSoup, pandas, Scrapy — torna o web scraping acessível até para quem não é desenvolvedor em tempo integral.

Equipes diferentes usam esses dados de formas diferentes:

Uma marca de utensílios de cozinha , reformulou o produto e recuperou a posição de #1 em Best Seller em 60 dias. Uma empresa de pulseiras fitness , detectou uma questão de alergia ao látex, lançou uma versão hipoalergênica e reduziu devoluções em 40%. É esse tipo de ROI que faz o esforço de engenharia valer a pena.

Tela de login: por que seu scraper de avaliações da Amazon parou de funcionar

Em 14 de novembro de 2024, . A mudança foi confirmada em e . Se você abrir /product-reviews/{ASIN}/ numa janela anônima, vai ser redirecionado para a página de login em vez de receber os dados das avaliações.

Os sintomas são traiçoeiros: seu script recebe uma resposta 200 OK, mas o corpo HTML traz um formulário de login (name="email", id="ap_password") em vez das avaliações. Nenhum código de erro. Nenhum CAPTCHA. Só... nada útil.

A Amazon fez isso por motivos de anti-bot e conformidade regional. A aplicação é inconsistente — às vezes uma nova janela do navegador carrega algumas avaliações antes de a barreira entrar em ação, especialmente na primeira página — mas, para qualquer scraper em escala, você deve assumir que a barreira está sempre ativa.

Os diferentes domínios regionais da Amazon (.de, .co.uk, .co.jp) aplicam essa barreira de forma independente. Como um usuário de fórum resumiu: "é preciso 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 sem autenticação. Elas são escolhidas pelo algoritmo da Amazon e servem para um check rápido de sentimento, mas não permitem ordenação, filtros nem paginação.

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 — exigem login.

Se você só precisa de algumas avaliações para ter uma leitura rápida do cenário, basta raspar a página do produto. Para centenas ou milhares, vai ser preciso lidar com autenticação.

O que você precisa antes de começar: configuração em Python e bibliotecas

Antes de escrever qualquer código, confira a preparação:

• Nível de dificuldade: intermediário (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 válida na Amazon

Instale as bibliotecas principais:

1pip install requests beautifulsoup4 lxml pandas textblob

Opcional (para análise de sentimento mais avançada):

1pip install transformers torch

O que é um 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. Essa é a chave que você vai usar na URL das avaliações.

Passo 1: ultrapasse a tela de login com autenticação baseada em cookies

A forma mais confiável é entrar na Amazon pelo navegador, copiar os cookies da sessão e injetá-los no requests.Session() do Python. Isso evita os CAPTCHAs e a autenticação por SMS em dois fatores que atrapalham a automação de login com Selenium.

Você vai precisar destes sete cookies:

Como extrair os cookies no Chrome DevTools

1. Faça login em amazon.com no Chrome
2. Abra o DevTools (F12 ou clique com o botão direito → Inspecionar)
3. Vá em Application → Storage → Cookies → https://www.amazon.com
4. Localize cada nome de cookie da tabela e copie o valor
5. Formate-os como uma string separada por ponto e vírgula para usar no Python

Configure a sessão assim:

1import requests
2session = requests.Session()
3# Cole aqui os valores dos seus cookies
4cookies = {
5    "session-id": "YOUR_SESSION_ID",
6    "session-id-time": "YOUR_SESSION_ID_TIME",
7    "session-token": "YOUR_SESSION_TOKEN",
8    "ubid-main": "YOUR_UBID_MAIN",
9    "at-main": "YOUR_AT_MAIN",
10    "sess-at-main": "YOUR_SESS_AT_MAIN",
11    "x-main": "YOUR_X_MAIN",
12}
13headers = {
14    "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",
15    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
16    "Accept-Language": "en-US,en;q=0.5",
17}
18session.cookies.update(cookies)
19session.headers.update(headers)

Importante: reutilize o mesmo objeto session em todas as requisições. Isso mantém os cookies consistentes e imita uma sessão real de navegador. Normalmente, os cookies duram de dias a semanas sob carga de scraping, mas se você começar a ser redirecionado para o login de novo, atualize-os pelo 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: 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:

1https://www.amazon.com/product-reviews/{ASIN}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1

A função principal:

1from bs4 import BeautifulSoup
2import time, random
3def get_soup(session, url):
4    time.sleep(random.uniform(2, 5))  # Atraso educado
5    response = session.get(url, timeout=15)
6    # Detecta a tela de login
7    if "ap_email" in response.text or "Amazon Sign-In" in response.text:
8        raise Exception("Tela de login detectada — atualize seus cookies")
9    if response.status_code != 200:
10        raise Exception(f"HTTP {response.status_code}")
11    return BeautifulSoup(response.text, "lxml")

Um truque simples que ajuda: antes de abrir 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.

1# Visite a página do produto primeiro (simula navegação real)
2product_url = f"https://www.amazon.com/dp/{asin}"
3session.get(product_url, timeout=15)
4time.sleep(random.uniform(1, 3))
5# Depois acesse a página de avaliações
6reviews_url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1"
7soup = 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 maioria dos tutoriais de 2022–2023 quebra. A Amazon ofusca os nomes das classes CSS — eles mudam periodicamente e, como um desenvolvedor frustrado comentou em um 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 das avaliações, e eles são surpreendentemente estáveis. São identificadores semânticos dos quais o frontend da própria Amazon depende, então não são aleatorizados.

O código de extração com seletores data-hook:

1import re
2def extract_reviews(soup):
3    reviews = []
4    review_divs = soup.select('[data-hook="review"]')
5    for div in review_divs:
6        # Nota por estrelas
7        rating_el = div.select_one('[data-hook="review-star-rating"]')
8        rating = None
9        if rating_el:
10            rating_text = rating_el.get_text(strip=True)
11            match = re.search(r'(\d\.?\d?)', rating_text)
12            if match:
13                rating = float(match.group(1))
14        # Título
15        title_el = div.select_one('[data-hook="review-title"]')
16        title = title_el.get_text(strip=True) if title_el else ""
17        # Corpo
18        body_el = div.select_one('[data-hook="review-body"]')
19        body = body_el.get_text(strip=True) if body_el else ""
20        # Autor
21        author_el = div.select_one('span.a-profile-name')
22        author = author_el.get_text(strip=True) if author_el else ""
23        # Data e país
24        date_el = div.select_one('[data-hook="review-date"]')
25        date_text = date_el.get_text(strip=True) if date_el else ""
26        # Formato: "Reviewed in the United States on January 15, 2025"
27        country_match = re.search(r'Reviewed in (.+?) on', date_text)
28        date_match = re.search(r'on (.+)$', date_text)
29        country = country_match.group(1) if country_match else ""
30        date = date_match.group(1) if date_match else ""
31        # Compra verificada
32        verified_el = div.select_one('[data-hook="avp-badge"]')
33        verified = bool(verified_el)
34        reviews.append({
35            "author": author,
36            "rating": rating,
37            "title": title,
38            "content": body,
39            "date": date,
40            "country": country,
41            "verified": verified,
42        })
43    return reviews

Tenho usado esse conjunto de seletores com vários ASINs há meses, e os atributos data-hook não mudaram uma única vez. Já as classes CSS, por outro lado, mudaram pelo menos duas vezes no mesmo período.

Passo 4: trate 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 filtro. O botão "Próxima página" simplesmente desaparece depois da página 10.

Loop básico de paginação:

1all_reviews = []
2for page in range(1, 11):
3    url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber={page}"
4    soup = get_soup(session, url)
5    page_reviews = extract_reviews(soup)
6    if not page_reviews:
7        break  # Não há mais avaliações nesta página
8    all_reviews.extend(page_reviews)
9    print(f"Página {page}: {len(page_reviews)} avaliações")

Como obter mais de 10 páginas de avaliações da Amazon

A saída é usar buckets por filtro. 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 por 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 notas, muitas vezes dá para chegar bem perto do conjunto completo.

1star_filters = ["one_star", "two_star", "three_star", "four_star", "five_star"]
2sort_orders = ["recent", "helpful"]
3all_reviews = []
4seen_titles = set()  # Deduplicação simples
5for star in star_filters:
6    for sort in sort_orders:
7        for page in range(1, 11):
8            url = (
9                f"https://www.amazon.com/product-reviews/{asin}"
10                f"?filterByStar={star}&sortBy={sort}&pageNumber={page}"
11            )
12            soup = get_soup(session, url)
13            page_reviews = extract_reviews(soup)
14            if not page_reviews:
15                break
16            for review in page_reviews:
17                # Deduplica pela combinação título + autor
18                key = (review["title"], review["author"])
19                if key not in seen_titles:
20                    seen_titles.add(key)
21                    all_reviews.append(review)
22            print(f"[{star}/{sort}] Página {page}: {len(page_reviews)} avaliações")
23print(f"Total de avaliações únicas: {len(all_reviews)}")

Vai haver sobreposição entre os buckets, então a deduplicação é essencial. Eu uso a combinação título da avaliação + nome do autor como chave rápida — não é perfeita, mas pega a grande maioria das duplicatas.

Passo 5: drible as defesas anti-bot (rotacione, reduza a velocidade, tente de novo)

A Amazon usa o AWS WAF Bot Control, e ele ficou bem mais agressivo. Contramedidas de uma camada só — como apenas rotacionar User-Agents ou só adicionar atrasos — já não bastam.

Um wrapper de retry pronto para produção:

1import time, random
2USER_AGENTS = [
3    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
4    "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",
5    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0",
6    "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",
7    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36",
8]
9def scrape_with_retries(session, url, max_retries=3):
10    for attempt in range(max_retries):
11        try:
12            session.headers["User-Agent"] = random.choice(USER_AGENTS)
13            time.sleep(random.uniform(2, 5))
14            response = session.get(url, timeout=15)
15            # Detecta bloqueios
16            if "validateCaptcha" in response.url or "Robot Check" in response.text:
17                wait = (2 ** attempt) * 5
18                print(f"CAPTCHA detectado. Aguardando {wait}s...")
19                time.sleep(wait)
20                continue
21            if response.status_code in (429, 503):
22                wait = (2 ** attempt) * 2
23                print(f"Limite de requisições ({response.status_code}). Aguardando {wait}s...")
24                time.sleep(wait)
25                continue
26            if "ap_email" in response.text:
27                raise Exception("Tela de login — cookies expiraram")
28            return BeautifulSoup(response.text, "lxml")
29        except Exception as e:
30            if attempt == max_retries - 1:
31                raise
32            print(f"Tentativa {attempt + 1} falhou: {e}")
33    return None

Uma observação sobre proxies: a Amazon (AWS, GCP, Azure, DigitalOcean) em nível de rede. Se você for raspar mais de algumas centenas de páginas, proxies residenciais acabam sendo praticamente obrigatórios — espere gastar US$ 50–200+/mês, dependendo do volume. Para projetos menores (menos de 100 requisições/dia), um throttling cuidadoso com seu IP doméstico costuma funcionar bem.

A Amazon também inspeciona fingerprints de TLS. O requests padrão do Python tem um . Em scrapers de produção, vale considerar curl_cffi, que imita stacks de TLS de navegadores reais. Para scraping em escala de tutorial (algumas centenas de páginas), requests com bons headers normalmente dá conta.

Passo 6: exporte suas avaliações raspadas da Amazon para CSV ou Excel

Depois de coletar as avaliações, colocá-las num formato utilizável é simples com pandas:

1import pandas as pd
2df = pd.DataFrame(all_reviews)
3df.to_csv("amazon_reviews.csv", index=False)
4print(f"Exportadas {len(df)} avaliações para amazon_reviews.csv")

Exemplo de saída:

Para exportar em Excel: df.to_excel("amazon_reviews.xlsx", index=False) (requer openpyxl).

Para o Google Sheets, a biblioteca gspread funciona, mas exige — criar um projeto, habilitar duas APIs, gerar credenciais de service account, compartilhar a planilha. Se isso parece mais trabalho do que o próprio scraping, você não está errado. (É nessas horas que uma ferramenta como a , que exporta para o Google Sheets com um clique, começa a parecer muito atraente.)

Bônus: adicione análise de sentimento às avaliações raspadas 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ões de negócio.

O baseline mais rápido usa TextBlob:

1from textblob import TextBlob
2df["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:

As linhas mais interessantes são os desencontros — uma avaliação de 3 estrelas com texto positivo, ou uma avaliação de 5 estrelas com linguagem negativa. Essas discrepâncias muitas vezes revelam opiniões mais nuançadas do cliente, que a nota por estrelas sozinha não mostra.

Para precisão em nível de produção, a recomendação é usar Hugging Face Transformers. , e em comparação com ferramentas baseadas em léxico. O modelo nlptown/bert-base-multilingual-uncased-sentiment ainda prevê diretamente notas de 1 a 5 estrelas:

1from transformers import pipeline
2clf = pipeline("sentiment-analysis",
3               model="nlptown/bert-base-multilingual-uncased-sentiment")
4df["predicted_stars"] = df["content"].apply(
5    lambda x: int(clf(str(x)[:512])[0]["label"][0])
6)

As avaliações da Amazon seguem uma — um grande pico em 5 estrelas, um pico menor em 1 estrela e um vale no meio. Isso significa que a nota média muitas vezes é um péssimo proxy da qualidade real do produto. Segmente o grupo de 1 estrela e procure temas recorrentes — geralmente é ali que está escondido um defeito único e corrigível.

O trade-off honesto: Python faça-você-mesmo vs. APIs pagas de scraping vs. Thunderbit

Eu já mantive scrapers em Python para a Amazon e, sendo 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 em fóruns relatam a mesma frustração — scripts DIY que "funcionavam no mês passado" agora precisam de correções constantes.

Veja como as três abordagens principais se comparam:

Python dá controle total e é, de fato, a melhor forma de aprender como o web scraping funciona por baixo dos panos. APIs pagas (ScrapingBee, Oxylabs, Bright Data) fazem sentido para pipelines de produção em que disponibilidade importa mais que custo. E, para equipes que precisam de dados de avaliações sem a sobrecarga de desenvolvimento — operações de e-commerce monitorando produtos concorrentes semanalmente, times de marketing coletando a linguagem dos clientes para anúncios — existe um terceiro caminho.

Como raspar avaliações da Amazon com a Thunderbit (sem código, sem manutenção)

Criamos a para lidar exatamente com os cenários em que manter um scraper em Python parece exagero. O fluxo é este:

1. Instale a
2. Acesse 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 um problema)
3. 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
4. Clique em "Scrape" — os dados são extraídos na hora, com paginação integrada
5. Exporte para Excel, Google Sheets, Airtable ou Notion

A grande vantagem é que a IA da Thunderbit lê a estrutura da página do zero a cada vez. Sem seletores CSS para manter, sem gerenciamento de cookies, sem código anti-bot. Quando a Amazon muda o HTML, a IA se adapta. Para leitores que querem acesso programático sem construir tudo do zero, a Thunderbit também oferece uma — extração estruturada via API com detecção de campos por IA, sem manutenção de seletores.

Para mergulhos mais profundos em dados da Amazon, veja nossos guias sobre e .

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 bastante dor de cabeça:

• Agrupe seus ASINs com pausas entre produtos, não só entre páginas. Eu uso intervalos de 10–15 segundos entre ASINs.
• Deduplicate com força. Ao combinar múltiplas combinações de filtro por estrelas e ordem de classificação, você vai ter avaliações sobrepostas. 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 retentar sem precisar raspar tudo de novo.
• Armazene em um banco de dados para projetos grandes. Um banco SQLite simples escala muito melhor do que arquivos CSV que só crescem:

1import sqlite3
2conn = sqlite3.connect("reviews.db")
3df.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 a agenda, e o sistema cuida do resto sem precisar de servidor.

Para outras abordagens, nossos posts sobre e trazem mais opções.

Uma nota rápida sobre considerações legais e éticas

Os proíbem explicitamente "o uso de qualquer robô, spider, scraper ou outro meio automatizado para acessar os serviços da Amazon". Dito isso, casos recentes nos EUA têm sido favoráveis a quem faz scraping de dados públicos. Em , um tribunal federal decidiu que fazer scraping de dados publicamente acessíveis não viola os termos de serviço quando o scraper não é um "usuário" logado.

O ponto importante: fazer scraping atrás de login (que é o foco deste tutorial) entra em território contratual, já que você aceitou os Termos de Uso da Amazon ao criar sua conta. Raspar avaliações em destaque visíveis publicamente apresenta menos risco jurídico do que raspar além da tela de login.

Orientações práticas: não redistribua comercialmente os dados raspados, não colete dados pessoais de usuários além do que já está publicamente exibido, 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 .

Conclusão: faça scraping de avaliações da Amazon com Python ou pule o código por completo

Resumo rápido do que este guia cobriu:

• A tela de login é real, mas dá para contornar com autenticação baseada em cookies — copie 7 cookies do navegador e injete-os em um requests.Session()
• Use seletores data-hook, e não classes CSS, para uma extração que não quebra a cada poucas semanas
• Combine filtros por estrelas e ordem de classificação para superar 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 com Hugging Face Transformers para precisão em produção
• Mantenha defesas anti-bot: limitação de ritmo, rotação de User-Agent, backoff exponencial e proxies residenciais para escalar

Python oferece controle total e é a melhor forma de entender o que acontece por baixo dos panos. Mas, se o seu caso de uso é "preciso de dados de avaliações de concorrentes numa planilha até sexta-feira" em vez de "quero construir um pipeline de dados em produção", o custo de manutenção de um scraper personalizado pode não compensar.

A lida com autenticação, seletores, paginação e exportação com poucos cliques — experimente o e veja se ele se encaixa no seu fluxo de trabalho. À medida que a Amazon continua apertando as medidas anti-bot, ferramentas com IA que se adaptam em tempo real vão deixar de ser um diferencial interessante e passar a ser uma necessidade.

Você também pode explorar o nosso para ver tutoriais em vídeo sobre fluxos de scraping.

FAQs

1. Dá para raspar avaliações da Amazon sem fazer login?

Sim, mas apenas 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 a tela de login.

2. É legal fazer scraping de avaliações da Amazon?

Os Termos de Serviço 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 ao scraping de dados publicamente acessíveis. Fazer scraping 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 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 todos os 5 filtros por estrelas × 2 ordenações, você pode acessar 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 muita duplicação.

4. Qual é a melhor biblioteca Python para raspar avaliações da Amazon?

requests + BeautifulSoup para HTML estático é a combinação mais comum e confiável. Selenium é útil quando a renderização em JavaScript é necessária. Para uma alternativa sem código que lida com tela de login e paginação automaticamente, experimente a .

5. Como evitar bloqueios ao raspar a Amazon?

Rote os User-Agents de um conjunto de 10+ strings reais de navegadores, adicione 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 cookies de sessão consistentes entre requisições. Para uma abordagem sem manutenção, a Thunderbit lida automaticamente com as defesas anti-bot por meio da sua sessão de navegador.

Saiba mais