Como Fazer Scraping de Dados de Produtos da Amazon com Proxies

Por que raspar dados do produto Amazon?

A Amazon hospeda mais de 350 milhões de produtos em dezenas de mercados em todo o mundo. Para as empresas de e-commerce, estes dados são inestimáveis: preços de concorrentes, descrições de produtos, avaliações de clientes, classificação de melhores vendedores e sinais de inventário podem conduzir decisões mais inteligentes. Se você está construindo um Ferramenta de monitorização dos preços, realizando pesquisa de mercado ou treinando um modelo de IA, os dados de produtos da Amazon são um dos alvos de maior valor na web.

O desafio é que a Amazon investe fortemente em defesas antibots. Sem a estratégia de proxy certa, seus raspadores atingirão CAPTCHAs, blocos IP e respostas enganosas em minutos. Este guia orienta você através da arquitetura, código e configuração proxy necessários para raspar Amazon de forma confiável em escala.

Proteção Anti-Bot da Amazon

Antes de escrever uma única linha de código, você precisa entender o que você está enfrentando. A Amazon emprega um sistema de detecção em camadas que analisa cada solicitação recebida.

Solicitar impressão digital

Amazon inspeciona cabeçalhos HTTP, impressões digitais TLS e solicitação de pedidos. Pedidos faltando cabeçalhos padrão do navegador ou usando assinaturas de bot conhecidos são sinalizados imediatamente. A Accept-Language, Accept-Encoding, e User-Agent Os cabeçalhos devem ser consistentes e realistas.

Análise comportamental

Pedidos que chegam a uma taxa que nenhum humano pode alcançar, ou seguindo padrões previsíveis (por exemplo, ASINs sequenciais), limitam a taxa de desencadeamento. Amazon rastreia o comportamento da sessão em várias solicitações, então cada IP precisa se comportar como um comprador genuíno.

Desafios CAPTCHA

Quando a Amazon suspeita de tráfego automatizado, ela serve uma página CAPTCHA em vez de dados de produto. Os IPs residenciais recebem muito menos CAPTCHAs do que os IPs datacenters porque compartilham os mesmos pools de IP que os verdadeiros compradores da Amazon. Para uma análise mais profunda dos métodos de detecção, consulte nosso guia sobre como sistemas anti-bots detectam proxies.

Key takeaway: Proxies residenciais com rotação adequada são essenciais para a raspagem sustentada da Amazônia. Os proxies do Datacenter serão bloqueados dentro de horas.

Dados que você pode extrair da Amazon

Configurando sua Configuração do Proxy

O proxy gateway residencial da ProxyHat fornece a diversidade IP e o geo-alvo necessários para raspagem da Amazon. Conecte-se através do nosso gateway e rode IPs automaticamente em cada solicitação ou mantenha sessões pegajosas quando necessário.

Ligação Básica

# HTTP proxy
http://USERNAME:PASSWORD@gate.proxyhat.com:8080
# With geo-targeting (US Amazon)
http://USERNAME-country-US:PASSWORD@gate.proxyhat.com:8080
# With sticky session (maintain same IP for a browsing session)
http://USERNAME-session-amz001:PASSWORD@gate.proxyhat.com:8080

Para raspagem da Amazon, recomendamos direcionar o país para o mercado que você está raspando. Raspando amazon.de? Usar IPs alemães. Raspando amazon.co.jp? Usar IPs japoneses. Verificar locais disponíveis para a lista completa.

Implementação em Python

Aqui está um raspador Python completo para dados de produtos da Amazon usando O SDK Python do ProxyHatName ao lado de pedidos e BeautifulSoup.

Raspador de produto básico

import requests
from bs4 import BeautifulSoup
import random
import time
import json
PROXY_URL = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
USER_AGENTS = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:125.0) Gecko/20100101 Firefox/125.0",
]
def get_amazon_product(asin, marketplace="com"):
    """Scrape product data from Amazon by ASIN."""
    url = f"https://www.amazon.{marketplace}/dp/{asin}"
    headers = {
        "User-Agent": random.choice(USER_AGENTS),
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
        "Accept-Language": "en-US,en;q=0.9",
        "Accept-Encoding": "gzip, deflate, br",
        "Connection": "keep-alive",
    }
    proxies = {
        "http": PROXY_URL,
        "https": PROXY_URL,
    }
    response = requests.get(url, headers=headers, proxies=proxies, timeout=30)
    if response.status_code != 200:
        return None
    soup = BeautifulSoup(response.text, "html.parser")
    product = {
        "asin": asin,
        "title": extract_title(soup),
        "price": extract_price(soup),
        "rating": extract_rating(soup),
        "review_count": extract_review_count(soup),
        "bsr": extract_bsr(soup),
        "availability": extract_availability(soup),
    }
    return product
def extract_title(soup):
    el = soup.find("span", {"id": "productTitle"})
    return el.get_text(strip=True) if el else None
def extract_price(soup):
    el = soup.find("span", {"class": "a-price-whole"})
    if el:
        fraction = soup.find("span", {"class": "a-price-fraction"})
        price = el.get_text(strip=True).rstrip(".")
        if fraction:
            price += "." + fraction.get_text(strip=True)
        return price
    return None
def extract_rating(soup):
    el = soup.find("span", {"class": "a-icon-alt"})
    if el and "out of" in el.get_text():
        return el.get_text(strip=True).split(" ")[0]
    return None
def extract_review_count(soup):
    el = soup.find("span", {"id": "acrCustomerReviewCount"})
    return el.get_text(strip=True) if el else None
def extract_bsr(soup):
    el = soup.find("th", string=lambda t: t and "Best Sellers Rank" in t)
    if el:
        return el.find_next("td").get_text(strip=True)
    return None
def extract_availability(soup):
    el = soup.find("div", {"id": "availability"})
    return el.get_text(strip=True) if el else None
# Example usage
if __name__ == "__main__":
    asins = ["B0CHX3QBCH", "B0D5BKRY4R", "B0CRMZHDG7"]
    for asin in asins:
        product = get_amazon_product(asin)
        if product:
            print(json.dumps(product, indent=2))
        time.sleep(random.uniform(2, 5))  # Random delay between requests

Manuseando a Paginação para os Resultados da Pesquisa

def scrape_search_results(keyword, max_pages=5):
    """Scrape Amazon search results with pagination."""
    results = []
    for page in range(1, max_pages + 1):
        url = f"https://www.amazon.com/s?k={keyword}&page={page}"
        headers = {
            "User-Agent": random.choice(USER_AGENTS),
            "Accept-Language": "en-US,en;q=0.9",
        }
        proxies = {"http": PROXY_URL, "https": PROXY_URL}
        response = requests.get(url, headers=headers, proxies=proxies, timeout=30)
        if response.status_code != 200:
            print(f"Page {page}: status {response.status_code}")
            break
        soup = BeautifulSoup(response.text, "html.parser")
        items = soup.find_all("div", {"data-component-type": "s-search-result"})
        for item in items:
            asin = item.get("data-asin", "")
            title_el = item.find("h2")
            price_el = item.find("span", {"class": "a-price-whole"})
            results.append({
                "asin": asin,
                "title": title_el.get_text(strip=True) if title_el else None,
                "price": price_el.get_text(strip=True) if price_el else None,
                "page": page,
            })
        time.sleep(random.uniform(3, 7))
    return results

Implementação Node.js

Para projetos Node.js, use O Nó do ProxyHat SDK com cheerio para análise.

const axios = require("axios");
const cheerio = require("cheerio");
const { HttpsProxyAgent } = require("https-proxy-agent");
const PROXY_URL = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080";
const agent = new HttpsProxyAgent(PROXY_URL);
const USER_AGENTS = [
  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/124.0.0.0 Safari/537.36",
  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/124.0.0.0 Safari/537.36",
];
async function scrapeProduct(asin, marketplace = "com") {
  const url = `https://www.amazon.${marketplace}/dp/${asin}`;
  const { data } = await axios.get(url, {
    httpsAgent: agent,
    headers: {
      "User-Agent": USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)],
      "Accept-Language": "en-US,en;q=0.9",
      Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
    },
    timeout: 30000,
  });
  const $ = cheerio.load(data);
  return {
    asin,
    title: $("#productTitle").text().trim() || null,
    price: $(".a-price-whole").first().text().trim() || null,
    rating: $(".a-icon-alt").first().text().trim().split(" ")[0] || null,
    reviewCount: $("#acrCustomerReviewCount").text().trim() || null,
    availability: $("#availability").text().trim() || null,
  };
}
async function scrapeMultiple(asins) {
  const results = [];
  for (const asin of asins) {
    try {
      const product = await scrapeProduct(asin);
      results.push(product);
      console.log(`Scraped: ${product.title}`);
    } catch (err) {
      console.error(`Failed ${asin}: ${err.message}`);
    }
    // Random delay 2-5 seconds
    await new Promise((r) => setTimeout(r, 2000 + Math.random() * 3000));
  }
  return results;
}
// Usage
scrapeMultiple(["B0CHX3QBCH", "B0D5BKRY4R"]).then((results) => {
  console.log(JSON.stringify(results, null, 2));
});

Estratégias de Rotação de Proxy para Amazon

A detecção da Amazon torna-se mais agressiva quanto mais pedidos vêm de um único IP. Aqui estão as estratégias de rotação que funcionam melhor.

Rotação por pedido

Para procurar produtos em massa onde cada pedido é independente, gire IPs em cada pedido. Este é o comportamento padrão com o gateway do ProxyHat: cada nova conexão recebe um novo IP residencial.

Rotação Baseada na Sessão

Ao raspar resultados de pesquisa em várias páginas, mantenha o mesmo IP para toda a sessão. Mudar IPs no meio da paginação parece suspeito para a Amazon. Usar as sessões pegajosas do ProxyHat:

# Maintain same IP for up to 10 minutes
http://USERNAME-session-search001:PASSWORD@gate.proxyhat.com:8080

Rotação Geo- Targed

Coincidir sua localização proxy com o mercado Amazon. Acessando amazon.de de um IP dos EUA levanta bandeiras. Países-alvo específicos:

# German IPs for amazon.de
http://USERNAME-country-DE:PASSWORD@gate.proxyhat.com:8080
# Japanese IPs for amazon.co.jp
http://USERNAME-country-JP:PASSWORD@gate.proxyhat.com:8080
# UK IPs for amazon.co.uk
http://USERNAME-country-GB:PASSWORD@gate.proxyhat.com:8080

Para mais sobre técnicas de rotação, leia nosso guia detalhado sobre os melhores proxies para raspagem web em 2026.

Melhores práticas para raspagem da Amazônia

• Aleatório de atrasos: Use intervalos aleatórios de 2-7 segundos entre solicitações. Nunca raspar a uma taxa fixa.
• Rodar os Agentes do Utilizador: Mantenha um pool de pelo menos 10 strings realistas do navegador User-Agent e gire-as.
• Lidar com CAPTCHAs graciosamente: Se você receber uma resposta CAPTCHA, recue por 30-60 segundos e tente novamente com um novo IP.
• Respeitar robots.txt: Embora não seja juridicamente vinculativo na maioria das jurisdições, seguir as diretivas robots.txt demonstra boa fé.
• Usar proxies residenciais: Os IPs do Datacenter são facilmente identificados e bloqueados pela Amazon. Proxies residenciais compartilhar os mesmos intervalos de IP que os compradores reais.
• Monitorar as taxas de sucesso: Acompanhe sua taxa HTTP 200. Se cair abaixo de 90%, reduza a concorrência ou ajuste sua estratégia de rotação.
• Respostas de cache: Nunca raspe o mesmo URL duas vezes se os dados não tiverem sido alterados. Cache dados do produto e definir intervalos de atualização com base na frequência com que os preços mudam.

Escalar seu raspador de Amazônia

Ao passar de centenas para milhões de produtos, a arquitetura importa.

Arquitetura Baseada na Fila

Use uma fila de mensagens (Redis, RabbitMQ ou SQS) para gerenciar sua lista ASIN. Processos de trabalhadores puxam ASINs da fila, raspam-nos e empurram os resultados para uma loja de dados. Isto desacopla a programação da raspagem e permite escalar os trabalhadores de forma independente.

Controle de concorrência

Comece com 5-10 solicitações simultâneas e aumente gradualmente enquanto monitora as taxas de sucesso. Com a piscina residencial do ProxyHat, você normalmente pode executar 20-50 sessões simultâneas sem problemas. Veja o nosso página de caso de uso de raspagem web para configurações recomendadas.

Pipeline de Dados

Armazenar HTML bruto em uma loja de objetos (S3) para reprocessamento e processar dados em PostgreSQL ou um armazém de dados. Esta separação permite- lhe corrigir erros de análise sem re- raspar.

Pro tip: Páginas de produtos da Amazon mudam de estrutura com frequência. Armazene HTML em bruto para que você possa reextrair dados quando os seletores mudarem, sem clicar no Amazon novamente.

Considerações Legal e Ética

A raspagem na web é legal na maioria das jurisdições para dados disponíveis publicamente, mas as práticas responsáveis importam. Coleta apenas dados exibidos publicamente. Não tente acessar páginas autenticadas, contas de vendedor ou dados privados. Limite sua taxa de pedidos para evitar degradar o serviço da Amazon para outros usuários. Armazene apenas os dados de que necessita e trate-os em conformidade com as leis de privacidade aplicáveis.

Tiras de Chaves

• O sistema antibot da Amazon requer proxies residenciais com geo-segmentação para corresponder ao mercado alvo.
• Rodar IPs por pedido para procurar em massa; use sessões pegajosas para navegação paginada.
• Randomize atrasos, agentes do usuário e solicite padrões para evitar detecção.
• Construa uma arquitetura baseada na fila para escalar além de alguns milhares de produtos.
• Armazene HTML em bruto para resiliência contra as alterações do seletor.
• Utilização Proxies residenciais do ProxyHat para altas taxas de sucesso em todos os mercados da Amazon.

Pronto para começar a raspar dados da Amazon? Nossa Guia de raspagem de dados do comércio electrónico cobre a estratégia completa, e você pode explorar a infraestrutura proxy do ProxyHat em nossa página de preços.