Testei 4 maneiras de extrair os Mais Vendidos da Amazon com Python e ...

No último fim de semana, virei uma panela inteira de café tentando extrair a página de Mais Vendidos da Amazon de quatro formas diferentes. Duas funcionaram muito bem, uma quase fez meu IP ser bloqueado e uma levou literalmente dois cliques. Aqui está tudo o que aprendi.

A Amazon é um monstro do varejo digital — , e um sistema de Best Sellers Rank (BSR) que é atualizado de hora em hora. Se você faz pesquisa de produtos para FBA, análise competitiva de preços ou simplesmente quer identificar tendências antes dos concorrentes, os dados dos Mais Vendidos valem ouro.

Mas tirar esses dados da Amazon e levá-los para uma planilha? É aí que a coisa fica interessante. Testei requests + BeautifulSoup, Selenium, uma API de scraping e o (nosso web scraper de IA sem código) para descobrir qual abordagem realmente entrega resultado — e quais te deixam encarando uma tela de CAPTCHA.

O que são os Mais Vendidos da Amazon e por que isso importa?

O Amazon Best Sellers Rank (BSR) é o ranking em tempo real da Amazon, que classifica os produtos pelo volume de vendas dentro de cada categoria. Pense nele como uma disputa de popularidade, atualizada a cada hora, com base em dados de vendas recentes e históricos. A própria Amazon explica assim:

“O cálculo dos Mais Vendidos da Amazon é baseado nas vendas da Amazon e é atualizado de hora em hora para refletir as vendas recentes e históricas de cada item vendido na Amazon.” —

A página de Mais Vendidos mostra os 100 principais produtos por categoria, divididos em duas páginas de 50 itens cada. A página 1 cobre as posições #1–50, e a página 2 cobre as posições #51–100. A Amazon já confirmou que visualizações de página e avaliações de clientes NÃO afetam o BSR — ele é determinado exclusivamente pelas vendas.

Quem se interessa por esses dados? Vendedores de e-commerce pesquisando produtos para FBA, equipes comerciais montando inteligência competitiva, times de operações acompanhando tendências de preço e analistas de mercado monitorando o crescimento das categorias. Pela minha experiência, quem vende na Amazon ou compete com ela acaba precisando desses dados em uma planilha em algum momento.

Por que extrair os Mais Vendidos da Amazon com Python?

Pesquisa manual de produtos consome tempo demais. Um descobriu que funcionários gastam 9,3 horas por semana só procurando e reunindo informações. Para times de e-commerce, isso vira horas clicando por páginas da Amazon, copiando nomes e preços de produtos e colando tudo em planilhas — para repetir o processo inteiro na semana seguinte.

Veja rapidamente alguns casos de uso que tornam a extração dos Mais Vendidos tão útil:

O retorno é real: uma com 2.700 profissionais de comércio mostrou que ferramentas de IA economizam, em média, para profissionais de e-commerce. E vendedores que usam monitoramento automatizado de preços mantêm a Buy Box , contra 42% de quem faz esse acompanhamento manualmente — um aumento de 37% nas vendas impulsionado por reações mais rápidas às mudanças de preço.

4 formas de extrair os Mais Vendidos da Amazon com Python: comparação rápida

Antes de entrar nos tutoriais passo a passo, aqui vai a comparação lado a lado que eu gostaria de ter visto antes de começar os testes. Esta tabela deve ajudar você a escolher o método certo para o seu caso:

Se você quer aprender os fundamentos de scraping com Python, comece pelo Método 1 ou 2. Se precisa de confiabilidade em escala de produção, vá de Método 3. Se quer resultados em dois cliques sem escrever código, pule direto para o Método 4.

Antes de começar

• Nível: Iniciante a intermediário (dependendo do método)
• Tempo necessário: ~15 minutos para o Thunderbit, ~45 minutos para os métodos em Python
• O que você vai precisar: Python 3.8+ (para os Métodos 1–3), navegador Chrome, (para o Método 4) e a URL da categoria de Mais Vendidos da Amazon que você quer extrair

Método 1: extrair os Mais Vendidos da Amazon com requests + BeautifulSoup

Esta é a abordagem leve e amigável para iniciantes — sem automação de navegador, apenas requisições HTTP e análise de HTML. Também foi a que mais me ensinou sobre as defesas anti-scraping da Amazon.

Passo 1: configurar o ambiente

Instale os pacotes necessários:

1pip install requests beautifulsoup4 pandas

Depois, organize os imports:

1import requests
2from bs4 import BeautifulSoup
3import pandas as pd
4import random
5import time

Passo 2: enviar uma requisição com headers realistas

A Amazon bloqueia requisições com aparência de bot. A defesa mais básica é usar um cabeçalho User-Agent que imite um navegador real. Aqui vai um exemplo com uma lista de User-Agents atuais e realistas (fonte: , março de 2026):

1USER_AGENTS = [
2    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
3    "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",
4    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0",
5    "Mozilla/5.0 (Macintosh; Intel Mac OS X 15.7; 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]
8headers = {"User-Agent": random.choice(USER_AGENTS)}
9url = "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"
10response = requests.get(url, headers=headers)
11print(response.status_code)  # Deve retornar 200

Se aparecer status 200, tudo certo. Se vier 503 ou você for redirecionado para uma página de CAPTCHA, a Amazon sinalizou sua requisição.

Passo 3: analisar os dados dos produtos com BeautifulSoup

Inspecione o HTML da página da Amazon usando as DevTools do navegador (clique com o botão direito → Inspecionar). Os contêineres dos produtos usam o ID gridItemRoot. Dentro de cada contêiner, você encontra nome, preço, avaliação e URL do produto.

1soup = BeautifulSoup(response.text, "html.parser")
2products = []
3for item in soup.find_all("div", id="gridItemRoot"):
4    title_tag = item.find("div", class_="_cDEzb_p13n-sc-css-line-clamp-3_g3dy1")
5    price_tag = item.find("span", class_="_cDEzb_p13n-sc-price_3mJ9Z")
6    link_tag = item.find("a", class_="a-link-normal")
7    title = title_tag.get_text(strip=True) if title_tag else "N/A"
8    price = price_tag.get_text(strip=True) if price_tag else "N/A"
9    url = "https://www.amazon.com" + link_tag["href"] if link_tag else "N/A"
10    products.append({"Title": title, "Price": price, "URL": url})

Atenção: os nomes de classe com prefixo _cDEzb_ são hashes de módulos CSS que a Amazon recria periodicamente. O ID gridItemRoot e a classe a-link-normal são mais estáveis, mas sempre valide os seletores nas DevTools antes de rodar o scraper.

Passo 4: exportar para CSV

1df = pd.DataFrame(products)
2df.to_csv("amazon_best_sellers.csv", index=False)
3print(f"Extraídos {len(products)} produtos")

O que esperar — e o que dá errado

No meu teste, esse método retornou cerca de 30 produtos em vez de 50. Isso não é bug no código — é o lazy loading da Amazon. Apenas ~30 produtos são renderizados no carregamento inicial da página; os demais aparecem depois da rolagem, o que exige execução de JavaScript que requests não consegue lidar.

Outras limitações:

• Bloqueios de IP acontecem rápido sem rotação de proxies (fui bloqueado depois de cerca de 15 requisições seguidas)
• Os seletores CSS quebram quando a Amazon altera o layout da página — e isso acontece com frequência
• Não há tratamento de paginação pronto para uso

Para aprender scraping em Python, essa abordagem é ótima. Para uso em produção, é frágil.

Método 2: extrair os Mais Vendidos da Amazon com Selenium

O Selenium resolve o problema do lazy loading executando um navegador real — mais pesado de configurar, mas ele captura todos os 50 produtos por página.

Passo 1: instalar o Selenium

1pip install selenium pandas

Boa notícia: a partir do Selenium 4.6+, você não precisa mais do webdriver-manager. O Selenium Manager cuida do download dos drivers automaticamente.

1from selenium import webdriver
2from selenium.webdriver.chrome.options import Options
3from selenium.webdriver.common.by import By
4from selenium.webdriver.common.keys import Keys
5import time
6import pandas as pd
7options = Options()
8options.add_argument("--headless=new")
9options.add_argument("--window-size=1920,1080")
10options.add_argument("--disable-blink-features=AutomationControlled")
11driver = webdriver.Chrome(options=options)

A flag --headless=new (introduzida no Chrome 109+) usa a mesma pipeline de renderização do Chrome com interface, o que dificulta a detecção pela Amazon.

Passo 2: rolar além do lazy loading

Este é o passo que faz o Selenium valer o esforço de configuração. A página de Mais Vendidos da Amazon carrega inicialmente cerca de 30 produtos — o restante aparece depois da rolagem.

1def scroll_page(driver, scrolls=5, delay=2):
2    for _ in range(scrolls):
3        driver.find_element(By.TAG_NAME, "body").send_keys(Keys.PAGE_DOWN)
4        time.sleep(delay)
5driver.get("https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/")
6time.sleep(3)
7scroll_page(driver)

Depois da rolagem, os 50 produtos devem aparecer no DOM. Descobri que 5 rolagens com tecla Page Down e intervalo de 2 segundos eram suficientes, mas talvez você precise ajustar de acordo com a velocidade da conexão.

Passo 3: extrair os dados dos produtos

1items = driver.find_elements(By.ID, "gridItemRoot")
2products = []
3for item in items:
4    try:
5        title = item.find_element(By.CSS_SELECTOR, "div._cDEzb_p13n-sc-css-line-clamp-3_g3dy1").text
6    except:
7        title = "N/A"
8    try:
9        price = item.find_element(By.CSS_SELECTOR, "span._cDEzb_p13n-sc-price_3mJ9Z").text
10    except:
11        price = "N/A"
12    try:
13        url = item.find_element(By.CSS_SELECTOR, "a.a-link-normal").get_attribute("href")
14    except:
15        url = "N/A"
16    products.append({"Title": title, "Price": price, "URL": url})

Usar try/except em cada extração é importante — alguns produtos podem estar indisponíveis ou sem certos campos, e você não quer que um único elemento com problema derrube toda a extração.

Passo 4: lidar com paginação

A Amazon divide os 100 Mais Vendidos em duas páginas com estruturas de URL diferentes:

1urls = [
2    "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/",
3    "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/ref=zg_bs_pg_2_electronics?_encoding=UTF8&pg=2"
4]
5all_products = []
6for url in urls:
7    driver.get(url)
8    time.sleep(3)
9    scroll_page(driver)
10    # ... extrair os produtos como acima ...
11    all_products.extend(products)
12driver.quit()

O que esperar

No meu teste, o Selenium capturou todos os 50 produtos por página — uma vitória clara sobre requests + BS4. O lado negativo: levou cerca de 45 segundos por página (incluindo os atrasos de rolagem), e eu ainda fui sinalizado depois de rodar várias vezes sem rotação de proxy. O Selenium também pode ser detectado pelos sistemas anti-bot da Amazon, mesmo com flags de anti-detecção — para escala séria, você vai precisar de medidas extras (veja o guia anti-bloqueio abaixo).

Outros problemas:

• Incompatibilidades de versão do WebDriver ainda acontecem de vez em quando, embora o Selenium Manager tenha reduzido bastante esse problema
• Os seletores CSS precisam ser atualizados sempre que a Amazon altera o DOM
• O consumo de memória é alto — cada instância do navegador usa de 200 a 400 MB de RAM

Método 3: extrair os Mais Vendidos da Amazon com uma API de scraping

APIs de scraping são a abordagem do tipo “deixe que outra ferramenta cuide das partes difíceis”. Serviços como Scrape.do, Oxylabs e ScrapingBee gerenciam rotação de proxy, renderização de JavaScript e medidas anti-bot — você só envia a URL e recebe HTML ou JSON de volta.

Como funciona

Você envia a URL de destino para o endpoint da API. A API renderiza a página usando um navegador real na infraestrutura dela, alterna proxies, lida com CAPTCHAs e devolve HTML limpo. Depois, você analisa o HTML retornado com BeautifulSoup normalmente.

Passo 1: enviar uma requisição pela API

Aqui vai um exemplo usando Scrape.do (os preços começam em US$ 29/mês para 150.000 créditos; 1 crédito = 1 requisição, independentemente da renderização):

1import requests
2from bs4 import BeautifulSoup
3api_token = "YOUR_API_TOKEN"
4target_url = "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"
5api_url = f"https://api.scrape.do?token={api_token}&url={target_url}&render=true&geoCode=us"
6response = requests.get(api_url)
7soup = BeautifulSoup(response.text, "html.parser")

A partir daqui, a análise é idêntica ao Método 1 — mesmos seletores, mesma lógica de extração.

Realidade dos preços

Aqui estão os principais preços cobrados por 1.000 requisições à Amazon nas melhores condições oferecidas por cada provedor:

Prós e contras

Prós: alta confiabilidade ( na Amazon entre os provedores líderes), sem manutenção de driver, anti-bot tratado automaticamente, boa escala.

Contras: cobrança por requisição (os custos aumentam em escala), ainda exige que você escreva o código de parsing e continua vulnerável a mudanças nos seletores CSS. Para 100.000 páginas/mês, a comparação de custo total é gritante: construir internamente custa cerca de — uma economia de 71%.

O ponto de equilíbrio costuma ficar entre 500 mil e 1 milhão de requisições por mês. Abaixo disso, o ganho de tempo da API supera de longe o custo.

Método 4: extrair os Mais Vendidos da Amazon com Thunderbit (sem Python)

Transparência total: eu trabalho na Thunderbit, então leve esta seção com esse contexto em mente. Ainda assim, testei os quatro métodos em sequência de verdade, e a diferença no tempo até ter os dados foi impressionante.

é um web scraper com IA que funciona como extensão do Chrome. A ideia principal é simples: em vez de escrever seletores CSS ou código Python, a IA lê a página e descobre o que precisa ser extraído. Para os Mais Vendidos da Amazon, o Thunderbit já tem modelos prontos que funcionam com um clique.

Passo 1: instalar a extensão do Thunderbit para Chrome

Vá até a e clique em “Add to Chrome”. Crie uma conta gratuita — o plano grátis oferece créditos suficientes para testar.

Passo 2: abrir a página de Mais Vendidos da Amazon

Abra qualquer página de categoria dos Mais Vendidos da Amazon no Chrome. Por exemplo: https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/

Passo 3: clicar em “AI Suggest Fields”

Abra a barra lateral do Thunderbit e clique em “AI Suggest Fields”. A IA analisa a estrutura da página e sugere colunas como Nome do Produto, Preço, Avaliação, URL da Imagem, Vendedor, URL do Produto e Ranking. No meu teste, ela identificou corretamente todos os campos relevantes em cerca de 3 segundos.

Você pode renomear, remover ou adicionar colunas. Também é possível adicionar prompts personalizados de IA por campo — por exemplo, “classificar como Eletrônicos/Vestuário/Casa” para adicionar uma tag de categoria a cada produto.

Passo 4: clicar em “Scrape”

Clique no botão “Scrape”. O Thunderbit preenche uma tabela estruturada com todos os dados dos produtos da página. No modo cloud, ele processa até 50 páginas ao mesmo tempo em paralelo, lidando automaticamente com lazy loading e paginação.

Passo 5: exportar gratuitamente

Clique em “Export” e escolha o destino: Excel, Google Sheets, Airtable ou Notion. Todas as exportações são gratuitas em qualquer plano — sem cobranças escondidas.

O processo inteiro levou cerca de 90 segundos, desde abrir a página até ter a planilha pronta. Para comparar: o Método 1 levou cerca de 20 minutos (incluindo o debugging do problema de lazy loading), o Método 2 levou cerca de 35 minutos (incluindo a configuração do Selenium) e o Método 3 levou cerca de 15 minutos (incluindo a criação da conta na API).

Por que o Thunderbit lida bem com a Amazon

Como a IA lê a página do zero a cada vez, ela se adapta automaticamente às mudanças de layout — sem necessidade de manter seletores CSS. Isso resolve diretamente a reclamação mais comum em fóruns de scraping: “um scraper básico não dá conta, você precisa adicionar várias 'proteções' para mudanças nos elementos”. Quando a Amazon altera o DOM (o que acontece com frequência), você não precisa atualizar nada.

O modo de scraping em nuvem lida com rotação de proxy, renderização e medidas anti-bot de forma transparente. Para quem quer uma solução que “simplesmente funcione”, isso elimina toda a dor de cabeça com bloqueios.

O guia anti-bloqueio: como evitar ser bloqueado pela Amazon

A detecção de bots da Amazon é agressiva. Durante os testes, meu IP foi temporariamente bloqueado, e usuários de fóruns relatam o mesmo: “erros em todo lugar, a Amazon até começou a me redirecionar para a página inicial”. Se você for pelo caminho de Python (Métodos 1–3), esta seção é essencial.

Aqui está uma estratégia em camadas, da mais básica à mais avançada:

1. Alterne strings de User-Agent

Enviar o mesmo User-Agent repetidamente é um sinal de alerta. Use o conjunto de 5+ strings do exemplo do Método 1 e escolha uma aleatoriamente a cada requisição:

1headers = {"User-Agent": random.choice(USER_AGENTS)}

2. adicione atrasos aleatórios entre requisições

Atrasos fixos são detectáveis. Intervalos aleatórios são mais seguros:

1time.sleep(random.uniform(2, 5))

Percebi que intervalos de 2 a 5 segundos entre requisições me mantiveram fora do radar em lotes pequenos (menos de 50 requisições). Para execuções maiores, aumente para 3 a 7 segundos.

3. use rotação de proxy

Aqui está o ponto mais importante. mostram que proxies residenciais têm em média ~94% de sucesso na Amazon, contra ~59% de proxies de datacenter — uma diferença de 35 pontos percentuais. A pilha de detecção da Amazon inclui fingerprint TLS, análise comportamental e limitação por IP, então IPs padrão de datacenter são sinalizados em segundos.

Proxies residenciais são mais caros (US$ 2–US$ 12 por GB, dependendo do provedor), mas muito mais confiáveis. Exemplo de código:

1proxies = {
2    "http": "http://user:pass@residential-proxy.example.com:8080",
3    "https": "http://user:pass@residential-proxy.example.com:8080"
4}
5response = requests.get(url, headers=headers, proxies=proxies)

4. fortaleça o fingerprint do navegador (Selenium)

1options.add_argument('--disable-blink-features=AutomationControlled')
2options.add_experimental_option("excludeSwitches", ["enable-automation"])
3options.add_experimental_option('useAutomationExtension', False)
4# Depois de iniciar o driver, remova a flag navigator.webdriver
5driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
6    'source': "Object.defineProperty(navigator, 'webdriver', {get: () => undefined})"
7})

5. gerencie sessões e cookies

Manter cookies entre requisições faz o scraper parecer mais com uma sessão real de usuário:

1session = requests.Session()
2# Primeiro visite a home para obter cookies mais realistas
3session.get("https://www.amazon.com", headers=headers)
4time.sleep(2)
5# Depois faça a extração da página alvo
6response = session.get(target_url, headers=headers)

6. quando vale pular toda a dor de cabeça

Para quem não quer gerenciar nada disso, o scraping em nuvem do Thunderbit cuida de rotação de proxy, renderização e medidas anti-bot de forma transparente. APIs de scraping também resolvem a maior parte dessas preocupações automaticamente. Pela minha experiência, o tempo gasto depurando problemas de bloqueio costuma superar o tempo gasto escrevendo o próprio código de scraping — então a abordagem que “simplesmente funciona” tem ROI real.

Enriquecimento de subpáginas: extraindo páginas de detalhe do produto para dados mais ricos

A página de listagem dos Mais Vendidos mostra só informações básicas — título, preço, avaliação e ranking. Mas o verdadeiro valor para pesquisa de FBA está nas páginas individuais de detalhe dos produtos. Veja o que você perde se extrair apenas a listagem:

Esse campo “Data de primeira disponibilidade” é especialmente valioso — ele mostra há quanto tempo o produto está no mercado, um sinal importante para análise de concorrência. E saber o número de vendedores e quem controla a Buy Box ajuda a avaliar se vale a pena entrar em um nicho (se a própria Amazon detém mais de 30% da participação da Buy Box, competir fica extremamente difícil).

Abordagem em Python: percorrendo as URLs dos produtos

Depois de coletar as URLs dos produtos na página de listagem, percorra cada uma com um atraso:

1for product in products:
2    time.sleep(random.uniform(3, 6))
3    detail_response = session.get(product["URL"], headers={"User-Agent": random.choice(USER_AGENTS)})
4    detail_soup = BeautifulSoup(detail_response.text, "html.parser")
5    # Extrair marca
6    brand_tag = detail_soup.find("a", id="bylineInfo")
7    product["Brand"] = brand_tag.get_text(strip=True) if brand_tag else "N/A"
8    # Extrair ASIN do código-fonte ou da URL
9    # Extrair Data de primeira disponibilidade da tabela de detalhes do produto
10    # ... campos adicionais ...

Aviso: acessar 100 páginas individuais de produto aumenta bastante o risco de bloqueio. Considere rotação de proxies e atrasos maiores.

Abordagem do Thunderbit: scraping de subpáginas com um clique

Depois de extrair a página de listagem em uma tabela, clique em “Scrape Subpages” no Thunderbit. A IA visita cada URL de produto e enriquece a tabela com colunas adicionais — marca, ASIN, especificações, recursos — automaticamente. Sem código extra, sem seletores, sem configuração. Isso é especialmente útil para times de e-commerce que precisam do panorama completo para decisões de sourcing, mas não querem escrever e manter um parser de páginas de detalhe.

Automatizando extrações recorrentes: monitore os Mais Vendidos ao longo do tempo

Uma extração pontual é útil, mas o verdadeiro ganho competitivo está no monitoramento contínuo. Acompanhar quais produtos sobem e descem, identificar tendências cedo e monitorar mudanças de preço por semanas ou meses — é isso que diferencia uma pesquisa casual de uma tomada de decisão orientada por dados.

Abordagem em Python: agendamento com cron

No Linux/Mac, você pode agendar seu script Python com cron. Aqui está a entrada do crontab para uma extração diária às 8h da manhã:

10 8 * * * /usr/bin/python3 /home/user/amazon_scraper.py >> /home/user/logs/scrape.log 2>&1

Para uma extração semanal às segundas-feiras às 9h:

10 9 * * 1 /usr/bin/python3 /home/user/amazon_scraper.py >> /home/user/logs/scrape.log 2>&1

No Windows, use o Agendador de Tarefas para fazer a mesma coisa. Para agendamento contínuo sem deixar o laptop ligado, publique em uma VPS ou AWS Lambda — embora isso adicione complexidade de infraestrutura.

Adicione logs e notificações de erro para detectar execuções falhas. Não há nada pior do que descobrir, duas semanas depois, que o scraper quebrou silenciosamente.

Abordagem do Thunderbit: Scheduled Scraper em linguagem simples

O Scheduled Scraper do Thunderbit permite descrever o intervalo em linguagem natural — digite “toda segunda às 9h” ou “todo dia às 8h” e a IA interpreta o agendamento. As extrações rodam nos servidores em nuvem da Thunderbit (não precisa deixar navegador ou computador ligados), e os dados são exportados automaticamente para Google Sheets ou Airtable. Isso cria um painel de monitoramento ao vivo sem nenhuma gestão de servidor — ideal para times de operações que querem visibilidade contínua sem o peso de DevOps.

Considerações legais e éticas ao extrair dados da Amazon

Não sou advogado, e isto não é aconselhamento jurídico. Mas ignorar o cenário legal em um tutorial de scraping seria irresponsável — usuários de fóruns levantam explicitamente preocupações com os termos de uso, e por um bom motivo.

robots.txt da Amazon: Em 2026, o robots.txt da Amazon contém mais de 80 caminhos específicos em Disallow, mas /gp/bestsellers/ NÃO está explicitamente bloqueado para user agents padrão. No entanto, mais de 35 user agents específicos de IA (ClaudeBot, GPTBot, Scrapy etc.) recebem um Disallow: / geral. A ausência de um bloqueio específico não significa que a Amazon aprove scraping.

Termos de uso da Amazon: As da Amazon (atualizadas em maio de 2025) proíbem explicitamente “usar qualquer processo ou tecnologia automatizada para acessar, adquirir, copiar ou monitorar qualquer parte do Website da Amazon” sem permissão por escrito. Isso não é teoria — a Amazon em novembro de 2025 por acesso automatizado não autorizado e conseguiu uma liminar preliminar.

O precedente hiQ v. LinkedIn: Em (Nono Circuito, 2022), o tribunal entendeu que extrair dados publicamente disponíveis provavelmente não viola o Computer Fraud and Abuse Act. Mas a hiQ acabou fazendo acordo e concordando em parar de fazer scraping — vencer no CFAA não protege contra ações por violação contratual.

Diretrizes práticas:

• Extraia apenas dados publicamente disponíveis (preços, BSR, títulos de produtos — não PII)
• Respeite limites de taxa e não sobrecarregue os servidores
• Use os dados para inteligência competitiva legítima
• Consulte seu departamento jurídico antes de fazer scraping em escala
• Esteja ciente de que já têm legislação abrangente de privacidade

O scraping em nuvem do Thunderbit usa padrões de requisição semelhantes aos de navegadores comuns, mas você deve sempre verificar a conformidade com seu próprio aconselhamento jurídico.

Qual método você deve usar? Um guia rápido de decisão

Versão curta:

• “Estou aprendendo Python e quero um projeto de fim de semana.” → Método 1 (requests + BeautifulSoup). Você vai aprender bastante sobre requisições HTTP, parsing de HTML e as defesas anti-bot da Amazon.
• “Preciso extrair páginas pesadas em JavaScript ou sessões com login.” → Método 2 (Selenium). É mais pesado, mas lida com conteúdo dinâmico.
• “Estou fazendo scraping em produção e em escala.” → Método 3 (API de scraping). Deixe outra empresa gerenciar proxies e renderização. O favorece APIs abaixo de 500 mil requisições por mês.
• “Não sou desenvolvedor e quero os dados em 2 minutos.” → Método 4 (). Sem código, sem seletores, sem manutenção.
• “Preciso de monitoramento contínuo sem gerenciar servidor.” → Thunderbit Scheduled Scraper. Configure uma vez e esqueça.

Conclusão e principais aprendizados

Depois de um fim de semana testando, aqui está o que realmente ficou claro:

requests + BeautifulSoup é ótimo para aprendizado, mas a limitação do lazy loading (só ~30 dos 50 produtos) e os seletores CSS frágeis tornam essa abordagem pouco prática para produção.

Selenium resolve o problema do lazy loading e captura todos os 50 produtos por página, mas é lento, consome muita memória e ainda pode ser detectado pelas defesas anti-bot da Amazon.

APIs de scraping oferecem a melhor confiabilidade para scraping em escala de produção — na Amazon — mas os custos aumentam e você ainda precisa escrever o código de parsing.

Thunderbit foi, disparado, o mais rápido para transformar página em dado. A IA lida com mudanças de layout, lazy loading, paginação e medidas anti-bot sem nenhuma configuração. Para usuários não técnicos ou equipes que precisam de dados recorrentes sem a sobrecarga de DevOps, é a opção mais prática.

A maior lição? As defesas anti-bot da Amazon e as mudanças frequentes de layout fazem com que soluções sem manutenção economizem mais tempo no longo prazo. Cada hora gasta corrigindo seletores quebrados e rotacionando proxies é uma hora que você deixa de investir em análise de verdade.

Quer experimentar a abordagem sem código? O oferece créditos suficientes para extrair algumas categorias de Mais Vendidos e ver os resultados por conta própria. Prefere seguir pelo caminho do Python? Os exemplos de código acima devem ajudar você a começar. De qualquer forma, você terá dados dos Mais Vendidos da Amazon em uma planilha em vez de ficar encarando uma aba do navegador.

Para saber mais sobre abordagens de web scraping, confira nossos guias sobre , e . Você também pode assistir aos tutoriais passo a passo no .

Saiba mais