Aprenda a Extrair Produtos da Amazon com Python

Se você já seguiu um tutorial de scraping da Amazon e mesmo assim acabou esbarrando numa parede de CAPTCHAs, erros 503 ou resultados totalmente em branco — bem-vindo ao clube. A maioria dos guias de Python para extrair dados da Amazon que circulam por aí foi escrita em 2022 ou 2023 e usa seletores e técnicas que a Amazon já corrigiu faz tempo.

Passei anos criando ferramentas de extração de dados na Thunderbit e, pela prática, posso dizer: a Amazon é um dos sites mais difíceis de extrair com confiabilidade. A plataforma muda a estrutura do HTML o tempo todo, aplica uma defesa anti-bot em seis camadas e ainda mostra layouts diferentes para usuários diferentes por meio de testes A/B. Neste guia, vou te mostrar um scraper em Python para Amazon que realmente funciona em 2025 — com seletores CSS verificados, uma estratégia em camadas para evitar bloqueios e orientações sobre agendamento e exportação que a maioria dos tutoriais simplesmente ignora. E, para quem só quer os dados sem brigar com Python, também vou mostrar como a faz o mesmo trabalho em cerca de dois cliques.

O que é a extração de produtos da Amazon?

A extração de produtos da Amazon é o processo de coletar programaticamente dados públicos — como nome do produto, preço, avaliações, quantidade de reviews, imagens, disponibilidade e muito mais — das páginas de produto e de resultados de busca da Amazon. Em vez de copiar manualmente informações de centenas de listagens, um scraper visita cada página, lê o HTML e organiza os dados que você definiu em um formato estruturado, como CSV, Excel ou banco de dados.

Pensa nisso como contratar um estagiário incansável que consegue visitar mil páginas de produto no tempo em que você termina o café da manhã. Só que esse estagiário nunca erra a grafia de nada e não precisa de pausa para o almoço.

Por que extrair produtos da Amazon com Python?

A Amazon abriga algo em torno de em mais de 30 categorias, movida por aproximadamente . Hoje, vendedores de terceiros já representam 69% do GMV total. Monitorar manualmente nem que seja uma fração desse catálogo é impossível. Veja por que equipes extraem dados da Amazon:

A escala dos preços na Amazon, por si só, já deixa claro por que a automação é indispensável: a Amazon altera preços , com a atualização do preço de um produto ocorrendo, em média, a cada 10 minutos. Em contraste, concorrentes como Best Buy e Walmart mudam preços apenas cerca de 50 mil vezes por mês. Nenhuma equipe humana consegue acompanhar isso.

O Python dá controle total sobre o processo de scraping — você decide o que extrair, como tratar erros e onde armazenar os dados. Mas isso também significa que você fica responsável pela manutenção, pelos mecanismos anti-bloqueio e por acompanhar as mudanças frequentes no HTML da Amazon.

O que você pode extrair da Amazon — e o que não deve

Em páginas de produtos públicas, normalmente é possível extrair:

• Título do produto (nome, marca)
• Preço (atual, original, promocional)
• Avaliação (média de estrelas)
• Quantidade de avaliações
• Imagens do produto (URL da imagem principal)
• Disponibilidade / status de estoque
• ASIN (Amazon Standard Identification Number)
• Descrição do produto e bullets
• Informações do vendedor
• Variações do produto (tamanho, cor etc.)

O que você deve evitar:

• Dados atrás de login: páginas de avaliações estendidas, dados da conta pessoal, histórico de pedidos
• Informações pessoais: nome do comprador, endereço, dados de pagamento
• Conteúdo protegido por direitos autorais para republicação: descrições e imagens podem ser usadas para análise, mas não como se fossem suas

O da Amazon bloqueia mais de 50 bots nomeados (incluindo GPTBot, Scrapy e ClaudeBot) e restringe caminhos como contas de usuário, carrinhos e listas de desejos. Páginas de detalhes de produtos não são proibidas explicitamente, mas os Termos de Serviço da Amazon proíbem acesso automatizado. Os tribunais, em geral, diferenciam violações de ToS (questão civil) de violações criminais sob a CFAA — voltaremos à legalidade no final deste guia.

Ferramentas e bibliotecas que você vai precisar

Aqui está a stack Python para este tutorial:

Opcional (para conteúdo renderizado por JavaScript):

• selenium ou playwright — automação com navegador headless

Configurando seu ambiente Python

Abra o terminal e execute:

1mkdir amazon-scraper && cd amazon-scraper
2python -m venv venv
3source venv/bin/activate  # No Windows: venv\Scripts\activate
4pip install requests beautifulsoup4 lxml curl_cffi pandas

Verifique se tudo foi instalado:

1import requests, bs4, curl_cffi, pandas
2print("Tudo certo!")

Se aparecer "Tudo certo!" sem erros, está pronto.

Por que a maioria dos tutoriais de scraping da Amazon quebra — e o que muda neste

Essa é a parte que a maioria dos guias pula, e é provavelmente o motivo de você estar lendo este artigo.

A Amazon atualiza com frequência sua estrutura de HTML, nomes de classes e IDs de elementos. A comunidade de scraping relata que dos crawlers precisam de correções semanais por causa de mudanças no DOM e no fingerprint. O caso mais famoso? O seletor #priceblock_ourprice, presente em centenas de tutoriais entre 2018 e 2023. Esse ID não existe mais nas páginas de produto da Amazon.

Uma comparação rápida do que está quebrado e do que funciona hoje:

Todos os trechos de código deste guia foram testados em páginas reais da Amazon em 2025. Vou te mostrar os seletores CSS reais junto com o resultado esperado — nada de copiar código de 2022.

Antes de começar

• Nível: Intermediário (pressupõe conhecimento básico de Python)
• Tempo necessário: ~30 a 45 minutos para o tutorial completo; ~10 minutos para o scraper básico
• O que você vai precisar: Python 3.9+, navegador Chrome (para inspecionar páginas da Amazon), um terminal e, opcionalmente, a se quiser comparar com a abordagem sem código

Etapa 1: faça sua primeira requisição à Amazon

Abra qualquer página de produto da Amazon no navegador e copie a URL. Vamos começar com um requests.get() simples:

1import requests
2url = "https://www.amazon.com/dp/B0DGNFM9YJ"
3response = requests.get(url)
4print(response.status_code)
5print(response.text[:500])

Execute isso e você quase certamente verá um código de status 503 ou uma página dizendo "To discuss automated access to Amazon data please contact…". Esse é o WAF (Web Application Firewall) da Amazon detectando seu script em Python. Um requests.get() puro, sem cabeçalhos adequados, tem algo em torno de na Amazon.

Você deve ver algo como: 503 e uma página de bloqueio no HTML. Isso é esperado — vamos corrigir no próximo passo.

Etapa 2: configure cabeçalhos personalizados e impersonação de TLS

Adicionar apenas um cabeçalho User-Agent já não basta. A Amazon compara seus cabeçalhos HTTP com o seu fingerprint TLS. Se você afirma ser o Chrome 120, mas o handshake TLS denuncia a biblioteca requests do Python, você é .

A abordagem mais confiável em 2025 é usar curl_cffi com impersonação de navegador:

1from curl_cffi import requests as cfreq
2headers = {
3    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
4    "Accept-Language": "en-US,en;q=0.9",
5    "Accept-Encoding": "gzip, deflate, br",
6    "Referer": "https://www.google.com/",
7    "DNT": "1",
8    "Connection": "keep-alive",
9    "Upgrade-Insecure-Requests": "1",
10}
11url = "https://www.amazon.com/dp/B0DGNFM9YJ"
12response = cfreq.get(url, headers=headers, impersonate="chrome124")
13print(response.status_code)
14print(len(response.text))

Com curl_cffi impersonando o Chrome 124, a taxa de sucesso sobe para cerca de — uma melhoria de 47x em relação ao requests puro. Agora você deve ver um status 200 e uma resposta HTML bem mais longa (mais de 100.000 caracteres).

Se ainda aparecer 503, tente outro valor em impersonate (por exemplo, "chrome131") ou adicione uma pequena pausa antes de tentar novamente.

Etapa 3: analisar o HTML e extrair os dados do produto

Agora que temos o HTML completo, vamos extrair os dados usando BeautifulSoup com seletores verificados de 2025:

1from bs4 import BeautifulSoup
2soup = BeautifulSoup(response.text, "lxml")
3# Título do produto
4title_el = soup.select_one("span#productTitle")
5title = title_el.get_text(strip=True) if title_el else None
6# Preço
7price_el = soup.select_one(
8    "div#corePriceDisplay_desktop_feature_div span.a-price .a-offscreen"
9)
10if not price_el:
11    price_el = soup.select_one("span.priceToPay .a-offscreen")
12if not price_el:
13    price_el = soup.select_one(".apexPriceToPay .a-offscreen")
14price = price_el.get_text(strip=True) if price_el else None
15# Avaliação
16rating_el = soup.select_one("#acrPopover span.a-icon-alt")
17rating = rating_el.get_text(strip=True) if rating_el else None
18# Quantidade de avaliações
19reviews_el = soup.select_one("span#acrCustomerReviewText")
20reviews = reviews_el.get_text(strip=True) if reviews_el else None
21# Disponibilidade
22avail_el = soup.select_one("div#availability span")
23availability = avail_el.get_text(strip=True) if avail_el else None
24# URL da imagem principal
25img_el = soup.select_one("#landingImage")
26image_url = img_el.get("src") if img_el else None
27print(f"Título: {title}")
28print(f"Preço: {price}")
29print(f"Avaliação: {rating}")
30print(f"Reviews: {reviews}")
31print(f"Disponibilidade: {availability}")
32print(f"Imagem: {image_url}")

Saída esperada (exemplo):

1Título: Apple AirPods Pro (2nd Generation) with USB-C
2Preço: $189.99
3Avaliação: 4.7 out of 5 stars
4Reviews: 98,432 ratings
5Disponibilidade: In Stock
6Imagem: https://m.media-amazon.com/images/I/61SUj2...

Observe que há vários seletores de fallback para o preço — a Amazon usa contêineres diferentes dependendo do tipo de produto, do status da oferta e da variante do teste A/B. Envolver cada extração em uma verificação condicional evita que seu scraper quebre quando um seletor não corresponder.

Etapa 4: extraia vários produtos a partir dos resultados de busca

Para montar um dataset real, você vai querer começar por uma página de resultados de busca da Amazon, coletar ASINs e depois extrair cada página de detalhe do produto.

1import time
2import random
3def get_search_asins(keyword, max_pages=1):
4    """Coleta ASINs a partir dos resultados de busca da Amazon."""
5    asins = []
6    for page in range(1, max_pages + 1):
7        search_url = f"https://www.amazon.com/s?k={keyword}&page={page}"
8        resp = cfreq.get(search_url, headers=headers, impersonate="chrome124")
9        if resp.status_code != 200:
10            print(f"A página {page} retornou {resp.status_code}")
11            break
12        search_soup = BeautifulSoup(resp.text, "lxml")
13        results = search_soup.select('div[data-component-type="s-search-result"]')
14        for r in results:
15            asin = r.get("data-asin")
16            if asin:
17                asins.append(asin)
18        print(f"Página {page}: {len(results)} produtos encontrados")
19        time.sleep(random.uniform(2, 5))  # Pausa educada
20    return asins
21asins = get_search_asins("wireless+earbuds", max_pages=2)
22print(f"{len(asins)} ASINs coletados")

Cada ASIN corresponde a uma URL limpa de produto: https://www.amazon.com/dp/{ASIN}. Isso é mais confiável do que usar as URLs completas dos resultados de busca, que podem conter parâmetros específicos de sessão.

Etapa 5: lidar com paginação e extrair em escala

Agora vamos combinar a coleta de busca e a extração das páginas de detalhes em um pipeline completo:

1import pandas as pd
2def scrape_product(asin):
3    """Extrai uma única página de detalhe de produto da Amazon."""
4    url = f"https://www.amazon.com/dp/{asin}"
5    try:
6        resp = cfreq.get(url, headers=headers, impersonate="chrome124")
7        if resp.status_code != 200:
8            return None
9        soup = BeautifulSoup(resp.text, "lxml")
10        title_el = soup.select_one("span#productTitle")
11        price_el = (
12            soup.select_one("div#corePriceDisplay_desktop_feature_div span.a-price .a-offscreen")
13            or soup.select_one("span.priceToPay .a-offscreen")
14            or soup.select_one(".apexPriceToPay .a-offscreen")
15        )
16        rating_el = soup.select_one("#acrPopover span.a-icon-alt")
17        reviews_el = soup.select_one("span#acrCustomerReviewText")
18        avail_el = soup.select_one("div#availability span")
19        img_el = soup.select_one("#landingImage")
20        return {
21            "asin": asin,
22            "title": title_el.get_text(strip=True) if title_el else None,
23            "price": price_el.get_text(strip=True) if price_el else None,
24            "rating": rating_el.get_text(strip=True) if rating_el else None,
25            "reviews": reviews_el.get_text(strip=True) if reviews_el else None,
26            "availability": avail_el.get_text(strip=True) if avail_el else None,
27            "image_url": img_el.get("src") if img_el else None,
28            "url": url,
29        }
30    except Exception as e:
31        print(f"Erro ao extrair {asin}: {e}")
32        return None
33# Extrair todos os ASINs coletados
34products = []
35for i, asin in enumerate(asins):
36    print(f"Extraindo {i+1}/{len(asins)}: {asin}")
37    product = scrape_product(asin)
38    if product:
39        products.append(product)
40    time.sleep(random.uniform(2, 5))  # Atraso aleatório entre requisições
41df = pd.DataFrame(products)
42print(f"\n{len(df)} produtos extraídos com sucesso")
43print(df.head())

O atraso aleatório entre 2 e 5 segundos é essencial. Um timing perfeitamente regular (por exemplo, exatamente 3 segundos toda vez) parece suspeito para a análise comportamental da Amazon. Intervalos aleatórios simulam padrões humanos de navegação.

Etapa 6: salve os dados extraídos em CSV

1df.to_csv("amazon_products.csv", index=False, encoding="utf-8-sig")
2print("Salvo em amazon_products.csv")

Agora você deve ter um CSV limpo com colunas para ASIN, título, preço, avaliação, reviews, disponibilidade, URL da imagem e URL do produto. É aqui que a maioria dos tutoriais para — mas, se você está construindo um fluxo real, CSV é só o começo.

Mergulho profundo em anti-bloqueio: como manter seu scraper funcionando

Ser bloqueado é o para quem tenta extrair produtos da Amazon com Python. A defesa em seis camadas da Amazon inclui análise de reputação de IP, fingerprinting TLS, checagem do ambiente do navegador, biometria comportamental, CAPTCHAs e detecção de anomalias com ML. A seguir, uma estratégia em camadas para lidar com cada uma delas.

Rotacione User-Agents e cabeçalhos completos

Um único User-Agent estático é identificado rapidamente. Faça rotação entre strings atuais de navegador:

1import random
2USER_AGENTS = [
3    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.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/143.0.0.0 Safari/537.36",
5    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0",
6    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15",
7]
8def get_headers():
9    return {
10        "User-Agent": random.choice(USER_AGENTS),
11        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
12        "Accept-Language": "en-US,en;q=0.9",
13        "Accept-Encoding": "gzip, deflate, br",
14        "Referer": "https://www.google.com/",
15        "DNT": "1",
16        "Connection": "keep-alive",
17    }

Um detalhe que costuma pegar muita gente: o Accept-Language precisa combinar com a localização geográfica sugerida pelo seu IP. Enviar Accept-Language: en-US a partir de um IP alemão é sinal de alerta.

Impersonação de fingerprint TLS com curl_cffi

Já vimos isso na Etapa 2, mas vale reforçar: essa é a técnica que traz o maior ganho de taxa de sucesso. O requests padrão do Python alcança cerca de 2% de sucesso contra a Amazon. Com impersonação via curl_cffi, você chega a aproximadamente 94%. É a diferença entre um scraper funcional e um quebrado.

1from curl_cffi import requests as cfreq
2# Rotacione também os alvos de impersonação
3BROWSERS = ["chrome120", "chrome124", "chrome131"]
4response = cfreq.get(
5    url,
6    headers=get_headers(),
7    impersonate=random.choice(BROWSERS),
8)

Rotação de proxies

Para extrair mais do que algumas poucas páginas, você vai precisar de rotação de proxies. A Amazon monitora endereços IP e bloqueia qualquer IP único que faça requisições demais.

1PROXIES = [
2    "http://user:pass@proxy1.example.com:8080",
3    "http://user:pass@proxy2.example.com:8080",
4    "http://user:pass@proxy3.example.com:8080",
5]
6proxy = random.choice(PROXIES)
7response = cfreq.get(
8    url,
9    headers=get_headers(),
10    impersonate="chrome124",
11    proxies={"http": proxy, "https": proxy},
12)

Proxies residenciais são mais eficazes do que proxies de datacenter (a Amazon bloqueia faixas de IP de datacenter de forma proativa), mas também são mais caros. Para um projeto pequeno, você pode começar com um e escalar conforme a necessidade.

Limitação de taxa e backoff exponencial

Nenhum artigo concorrente que encontrei cobre isso, mas é essencial. Quando receber um 503 ou uma resposta de CAPTCHA, não tente de novo imediatamente — isso é um atalho para um banimento permanente.

1import time
2import random
3def fetch_with_backoff(url, max_retries=3):
4    """Faz a requisição a uma URL com backoff exponencial em caso de falha."""
5    for attempt in range(max_retries):
6        response = cfreq.get(
7            url,
8            headers=get_headers(),
9            impersonate=random.choice(BROWSERS),
10        )
11        if response.status_code == 200:
12            return response
13        # Backoff exponencial com jitter
14        wait = min(2 ** attempt + random.uniform(0, 1), 30)
15        print(f"Tentativa {attempt+1} falhou ({response.status_code}). Aguardando {wait:.1f}s...")
16        time.sleep(wait)
17    return None  # Todas as tentativas foram esgotadas

A fórmula wait = min(2^attempt + jitter, max_delay) faz com que os atrasos cresçam (2s, 4s, 8s...) sem ultrapassar um limite razoável. O jitter aleatório impede que seu padrão de retry seja identificado.

Fallback com Selenium ou Playwright para conteúdo renderizado por JS

Algumas páginas da Amazon — especialmente as que têm widgets dinâmicos de preço ou seletores de variação — exigem JavaScript para renderizar completamente. Quando o curl_cffi retorna HTML incompleto, um navegador headless é o plano B:

1from playwright.sync_api import sync_playwright
2def scrape_with_browser(url):
3    with sync_playwright() as p:
4        browser = p.chromium.launch(headless=True)
5        page = browser.new_page()
6        page.goto(url, wait_until="domcontentloaded")
7        page.wait_for_timeout(3000)  # Deixa o JS renderizar
8        html = page.content()
9        browser.close()
10        return html

Isso é mais lento — de 3 a 5 segundos por página, contra menos de 1 segundo com curl_cffi. Use só quando necessário.

Na minha experiência, o curl_cffi resolve mais de 90% das páginas de produto da Amazon sem precisar de navegador.

Resumo anti-bloqueio

Além do CSV: exporte os dados da Amazon para Google Sheets, Airtable e mais

Todo tutorial que analisei para no CSV. Mas fluxos de trabalho reais precisam dos dados em Google Sheets, bancos de dados ou ferramentas como Airtable e Notion.

Exportar para Google Sheets com gspread

Primeiro, configure uma conta de serviço do Google (configuração única):

1. Acesse o → APIs & Services → Credentials
2. Crie uma service account e baixe o arquivo de chave JSON
3. Salve em ~/.config/gspread/service_account.json
4. Compartilhe a planilha de destino com o client_email do arquivo JSON

Depois:

1import gspread
2from gspread_dataframe import set_with_dataframe
3gc = gspread.service_account()
4sh = gc.open("Amazon Scrape Data")
5worksheet = sh.sheet1
6set_with_dataframe(worksheet, df)
7print("Dados exportados para o Google Sheets!")

Isso grava todo o seu DataFrame diretamente em uma planilha do Google — ao vivo, compartilhável e pronta para dashboards.

Armazenar em SQLite para análise local

Para conjuntos maiores ou acompanhamento histórico, SQLite é perfeito — sem configuração de servidor, apenas um arquivo:

1import sqlite3
2conn = sqlite3.connect("amazon_products.db")
3df.to_sql("products", conn, if_exists="append", index=False)
4print(f"Armazenados {len(df)} produtos no SQLite")
5# Consultar depois:
6historical = pd.read_sql_query(
7    "SELECT * FROM products WHERE price IS NOT NULL ORDER BY rowid DESC LIMIT 100",
8    conn,
9)

A alternativa sem código

Se você não quiser manter scripts de exportação em Python, a oferece exportação gratuita para Google Sheets, Airtable, Notion, Excel, CSV e JSON — incluindo campos de imagem que aparecem diretamente no Airtable e no Notion. Sem configuração do gspread, sem credenciais de API, sem código. Para equipes que precisam enviar dados diretamente para as ferramentas que já usam, isso economiza muito tempo.

Agendando extrações automáticas da Amazon — o capítulo que faltava

Monitoramento de preços e controle de estoque exigem extrações recorrentes, não execuções únicas. Mesmo assim, não encontrei nenhum artigo concorrente que abordasse agendamento. Veja como automatizar seu scraper em Python.

Cron jobs (Linux/macOS)

Abra seu crontab:

1crontab -e

Adicione uma linha para rodar o scraper todos os dias às 6h da manhã:

10 6 * * * cd /path/to/amazon-scraper && /path/to/venv/bin/python scraper.py >> ~/scraper.log 2>&1

Ou a cada 6 horas:

10 */6 * * * cd /path/to/amazon-scraper && /path/to/venv/bin/python scraper.py >> ~/scraper.log 2>&1

Agendador de Tarefas do Windows

Crie um arquivo em lote run_scraper.bat:

1@echo off
2cd /d "C:\path\to\amazon-scraper"
3call venv\Scripts\activate
4python scraper.py
5deactivate

Depois abra o Agendador de Tarefas → Criar Tarefa Básica → defina o gatilho (Diário, de hora em hora) → Ação: "Iniciar um programa" → selecione run_scraper.bat.

GitHub Actions (camada gratuita)

Para um agendamento em nuvem, sem infraestrutura:

1name: Amazon Scraper
2on:
3  schedule:
4    - cron: "0 6 * * *"  # Diário às 6h UTC
5  workflow_dispatch:       # Execução manual
6jobs:
7  scrape:
8    runs-on: ubuntu-latest
9    steps:
10      - uses: actions/checkout@v3
11      - name: Configurar Python
12        uses: actions/setup-python@v4
13        with:
14          python-version: "3.11"
15      - name: Instalar dependências
16        run: pip install -r requirements.txt
17      - name: Executar scraper
18        run: python scraper.py
19      - name: Commitar resultados
20        run: |
21          git config user.name 'GitHub Actions'
22          git config user.email 'actions@github.com'
23          git add data/
24          git diff --staged --quiet || git commit -m "Atualiza dados extraídos"
25          git push

Armazene as credenciais de proxy nos GitHub Secrets e você terá um pipeline de scraping automatizado e gratuito.

Alternativa sem código: Scheduled Scraper da Thunderbit

Para equipes que não querem lidar com sintaxe de cron ou infraestrutura em nuvem, a Thunderbit oferece um embutido. Você descreve a agenda em linguagem natural (por exemplo, "todos os dias às 8h" ou "toda segunda-feira"), adiciona as URLs da Amazon e clica em "Schedule". Sem terminal, sem arquivos YAML, sem pipeline de deploy. É especialmente útil para equipes de ecommerce que fazem monitoramento contínuo de preços ou estoque.

Python DIY vs. Scraper API vs. No-Code: qual abordagem você deve usar?

Essa é uma pergunta que vejo o tempo todo em fóruns, e nenhum artigo bem ranqueado oferece uma resposta estruturada. Então aqui vai minha visão sincera:

Python é a escolha certa se você quer aprender, personalizar cada detalhe e não se importa com manutenção contínua. As Scraper APIs cuidam do anti-bloqueio para você, mas ainda exigem código. Já a Thunderbit é o caminho mais rápido para vendas, operações de ecommerce ou qualquer pessoa que só precise dos dados — sem seletores, sem código e sem manutenção quando a Amazon mudar o HTML.

Como a Thunderbit extrai produtos da Amazon em 2 cliques

Sou suspeito, claro — minha equipe construiu isso. Mas o fluxo realmente é tão simples assim:

1. Instale a
2. Abra uma página de resultados de busca ou uma página de produto da Amazon
3. Clique em "AI Suggest Fields" (ou use o template instantâneo de scraper da Amazon)
4. Clique em "Scrape"

A IA da Thunderbit lê a página, identifica a estrutura dos dados e extrai tudo para uma tabela limpa. Você pode exportar para Excel, Google Sheets, Airtable ou Notion gratuitamente. O grande diferencial: quando a Amazon mudar o HTML na próxima semana (e ela vai mudar), a IA da Thunderbit se adapta automaticamente. Sem scripts quebrados, sem atualizar seletores.

Para enriquecer listas de produtos com dados de páginas de detalhe, o recurso Subpage Scraping da Thunderbit segue automaticamente links para páginas de produto e puxa campos adicionais como imagens, descrições e variações — algo que exige bastante código extra em Python.

Dicas para manter seu scraper em Python funcionando por muito tempo

Se você for seguir o caminho do Python, aqui estão algumas formas de reduzir a dor de manutenção:

• Verifique os seletores com frequência. A Amazon os altera bastante. Salve este artigo nos favoritos — vou atualizar a tabela de seletores conforme as mudanças acontecerem.
• Monitore sua taxa de sucesso. Acompanhe a proporção de respostas 200 versus 503/CAPTCHA. Configure um alerta (até um e-mail simples) quando a taxa cair abaixo de 80%.
• Guarde o HTML bruto. Salve a resposta completa em HTML junto com os dados parseados. Se os seletores mudarem, você pode reprocessar dados históricos sem precisar raspar tudo de novo.
• Gire proxies e User-Agents com frequência. Fingerprints estáticos são identificados em questão de horas quando o volume é alto.
• Use backoff exponencial. Nunca tente novamente imediatamente depois de um bloqueio.
• Empacote com Docker. Coloque o scraper em um container Docker para facilitar o deploy e a portabilidade.
• Adicione validação de dados. Verifique se os preços são numéricos, se as avaliações estão entre 1 e 5 e se os títulos não estão vazios. Uma equipe relatou uma depois de adicionar camadas de validação.

Ou, se tudo isso parece mais trabalho do que você queria assumir, considere se uma ferramenta sem código como a Thunderbit não seria uma opção melhor para o seu caso. Não há vergonha nenhuma em escolher o caminho mais rápido — já passei anos suficientes depurando scrapers para saber que, às vezes, o melhor código é aquele que você não precisa escrever.

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

Como isso sempre aparece em qualquer conversa sobre scraping da Amazon, aqui vai uma nota rápida sobre o cenário jurídico:

• Extrair dados públicos é, em geral, legal nos EUA. A decisão histórica (2022) estabeleceu que acessar dados públicos não viola a CFAA. Mais recentemente, (2024) e (2024) reforçaram esse princípio.
• Os ToS da Amazon proíbem acesso automatizado. Isso é uma questão civil (violação contratual), não criminal. Os tribunais, em geral, distinguem as duas coisas.
• Amazon v. Perplexity (2025) é um caso em andamento envolvendo scraping por IA das páginas da Amazon. Uma liminar preliminar foi emitida em março de 2026. Vale acompanhar.
• Restrinja-se a páginas públicas. Não extraia conteúdo protegido por login, dados pessoais ou qualquer coisa atrás de autenticação.
• Respeite os limites de requisição. Não sobrecarregue os servidores da Amazon. Um intervalo de 2 a 5 segundos entre requisições é razoável.
• Use os dados com responsabilidade. Extraia para análise, não para republicar conteúdo protegido por direitos autorais.
• Consulte um advogado para uso comercial em grande escala, especialmente se você estiver na UE (o GDPR se aplica a dados pessoais).

Para uma análise mais profunda, veja nosso guia sobre .

Encerrando

Agora você tem um scraper em Python para a Amazon funcionando, com seletores verificados de 2025, uma estratégia anti-bloqueio em camadas que vai muito além de "adicionar um User-Agent", opções práticas de agendamento para monitoramento contínuo e métodos de exportação que levam seus dados para Google Sheets, bancos de dados ou qualquer ferramenta que sua equipe use.

Resumo rápido:

• Python + curl_cffi + BeautifulSoup oferece controle total e uma taxa de sucesso de ~94% quando combinado com impersonação TLS
• Anti-bloqueio exige várias camadas: rotação de cabeçalhos, impersonação TLS, rotação de proxies, limitação de taxa e backoff exponencial
• Agendamento transforma um script pontual em um pipeline contínuo de monitoramento (cron, GitHub Actions ou o agendador nativo da Thunderbit)
• Ir além do CSV — Google Sheets, SQLite, Airtable, Notion — é onde está o valor real para negócios
• Thunderbit oferece uma alternativa em 2 cliques para não desenvolvedores ou para quem prefere gastar tempo analisando dados em vez de depurar seletores

Se você quiser testar o código, tudo neste guia está pronto para copiar e executar. E, se preferir pular completamente a programação, o permite testar a abordagem sem código na Amazon imediatamente.

Para saber mais, veja nossos guias sobre , e . Você também pode assistir a tutoriais passo a passo no .

Boas extrações — e que seus seletores sobrevivam até a próxima atualização da Amazon.

Perguntas frequentes

1. Por que meu scraper em Python para Amazon é bloqueado depois de poucas requisições?

A Amazon usa um sistema de defesa em seis camadas: análise de reputação do IP, fingerprinting TLS (JA3/JA4), detecção do ambiente do navegador, biometria comportamental, desafios de CAPTCHA e detecção de anomalias baseada em ML. Um script básico com requests e apenas um cabeçalho User-Agent atinge cerca de de sucesso. Para manter acesso confiável, você precisa de impersonação TLS (curl_cffi), rotação completa de cabeçalhos, rotação de proxies e limitação de taxa com jitter aleatório.

2. Quais bibliotecas Python são melhores para extrair produtos da Amazon em 2025?

curl_cffi para requisições HTTP com impersonação de TLS (a maior melhora isolada), BeautifulSoup4 com lxml para análise de HTML, pandas para estruturação e exportação de dados, e Selenium ou Playwright como alternativa para conteúdo renderizado por JavaScript. Python é usado por dos desenvolvedores de scraping.

3. É legal extrair dados de produtos da Amazon?

Extrair dados públicos é, em geral, legal nos EUA, com respaldo de decisões como hiQ v. LinkedIn e Meta v. Bright Data. Os Termos de Serviço da Amazon proíbem acesso automatizado, mas os tribunais distinguem entre violação de ToS (civil) e violação criminal. Sempre evite conteúdo protegido por login, respeite os limites de requisição e consulte um advogado para uso comercial em grande escala.

4. Posso extrair dados da Amazon sem escrever código?

Sim. Ferramentas como a permitem extrair produtos da Amazon em 2 cliques com uma extensão do Chrome. A detecção de campos com IA estrutura os dados automaticamente, e você pode exportar para Excel, Google Sheets, Airtable ou Notion gratuitamente. Quando a Amazon muda o HTML, a IA da Thunderbit se adapta sem atualizações manuais.

5. Com que frequência a Amazon muda seus seletores HTML, e como mantenho meu scraper atualizado?

Com frequência e sem aviso. A comunidade de scraping relata que dos crawlers precisam de correções semanais por causa de mudanças no DOM. Para se manter à frente, monitore a taxa de sucesso do seu scraper, armazene o HTML bruto para reprocessamento e revise os seletores em páginas reais regularmente. Como alternativa, ferramentas com IA como a Thunderbit se adaptam automaticamente, eliminando essa manutenção.

Saiba mais