Cómo scrapear datos de productos de Amazon con proxies

¿Por qué Scrape Amazon Product Data?

Amazon acoge más de 350 millones de productos en docenas de mercados de todo el mundo. Para las empresas de comercio electrónico, estos datos son invaluables: precios de la competencia, descripciones de productos, reseñas de clientes, Best Sellers Rank y señales de inventario pueden impulsar decisiones más inteligentes. Ya sea que usted está construyendo un herramienta de vigilancia de los precios, la realización de investigación de mercado, o la formación de un modelo AI, los datos de productos Amazon es uno de los objetivos de mayor valor en la web.

El reto es que Amazon invierte fuertemente en defensas antibot. Sin la estrategia proxy correcta, sus raspadores golpearán CAPTCHAs, bloques IP y respuestas engañosas en cuestión de minutos. Esta guía te lleva a través de la arquitectura, código y configuración proxy necesaria para raspar Amazon de forma fiable a escala.

Protección anticuerpos de Amazon

Antes de escribir una sola línea de código, necesitas entender en qué estás metido. Amazon emplea un sistema de detección de capas que analiza cada solicitud entrante.

Solicitud de huellas digitales

Amazon inspecciona las cabeceras HTTP, las huellas TLS y solicita pedidos. Las solicitudes de encabezados de navegador estándar o el uso de firmas de bot conocidos se marcan inmediatamente. El Accept-Language, Accept-Encoding, y User-Agent los encabezados deben ser consistentes y realistas.

Análisis conductual

Solicitudes que llegan a una tasa que ningún ser humano puede alcanzar, o siguiendo patrones predecibles (por ejemplo, ASINs secuenciales), la reducción de la tasa de activación. Amazon rastrea el comportamiento de sesión a través de múltiples solicitudes, por lo que cada IP necesita comportarse como un verdadero comprador.

CAPTCHA Challenges

Cuando Amazon sospecha tráfico automatizado, sirve una página CAPTCHA en lugar de datos del producto. Los IPs residenciales reciben mucho menos CAPTCHAs que los IP de centro de datos porque comparten los mismos grupos IP como verdaderos compradores de Amazon. Para una mirada más profunda a los métodos de detección, vea nuestra guía en cómo los sistemas antibot detectan proxies.

Toma de llaves: Los proxies residenciales con rotación adecuada son esenciales para el raspado sostenido de Amazon. Los proxies del centro de datos se bloquearán dentro de horas.

Datos que puede extraer de Amazon

Configuración de su configuración proxy

La puerta de entrada proxy de ProxyHat proporciona la diversidad IP y geo-targeting necesarios para el raspado de Amazon. Conectar a través de nuestra puerta de entrada y rotar IPs automáticamente en cada solicitud o mantener sesiones pegajosas cuando sea necesario.

Conexión 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 el raspado de Amazon, recomendamos seleccionar el país que coincida con el mercado que está raspando. ¿Scraping amazon.de? Usar IPs alemanas. Use IPs japonesas. Check Localidades disponibles para la lista completa.

Python Implementation

Aquí hay un raspador Python completo para los datos de productos de Amazon utilizando El SDK Python de ProxyHat junto con peticiones y BeautifulSoup.

Producto básico Scraper

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

Paginación de manejo para resultados de búsqueda

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

Node.js Implementation

Para proyectos Node.js, uso Nodo de ProxyHat SDK con porrista para la perspicacia.

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));
});

Estrategias de Rotación Proxy para Amazon

La detección de Amazon se vuelve más agresiva, mientras más solicitudes provienen de una sola IP. Aquí están las estrategias de rotación que funcionan mejor.

Rotación por conquista

Para buscar productos a granel donde cada solicitud es independiente, girar IPs en cada solicitud. Este es el comportamiento predeterminado con la puerta de entrada de ProxyHat: cada nueva conexión obtiene una IP residencial fresca.

Rotación basada en la sesión

Al raspar resultados de búsqueda a través de múltiples páginas, mantenga la misma IP para toda la sesión. Intercambiar IPs media-pagination parece sospechoso a Amazon. Use las sesiones pegajosas de ProxyHat:

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

Geo-Targeted Rotation

Coincide con su ubicación proxy en el mercado de Amazon. Acceder a amazon.de de una IP estadounidense levanta banderas. Meta para determinados países:

# 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 más información sobre técnicas de rotación, lea nuestra guía detallada sobre los mejores proxies para el raspado web en 2026.

Las mejores prácticas para Amazon Scraping

• Retrasos aleatorios: Use intervalos aleatorios de 2-7 segundos entre solicitudes. Nunca se rasca a un ritmo fijo.
• Rotate User-Agents: Mantenga una piscina de al menos 10 cadenas realistas del navegador de usuario y gire.
• Handle CAPTCHAs con gracia: Si recibe una respuesta de CAPTCHA, retroceda durante 30-60 segundos y vuelva a entrar con una nueva IP.
• Respetar robots.txt: Aunque no es jurídicamente vinculante en la mayoría de las jurisdicciones, siguiendo las directivas robots.txt demuestra buena fe.
• Use proxies residenciales: Datacenter IPs son fácilmente identificados y bloqueados por Amazon. Proxies residenciales compartir los mismos rangos IP como verdaderos compradores.
• Supervisar las tasas de éxito: Rastrea tu HTTP 200. Si baja por debajo del 90%, reduzca la concurrencia o ajuste su estrategia de rotación.
• Respuestas a los lugares: Nunca raspe la misma URL dos veces si los datos no han cambiado. Recuperar datos de producto y establecer intervalos de actualización basados en la frecuencia de los precios cambian.

Escalando su Amazon Scraper

Al pasar de cientos a millones de productos, la arquitectura importa.

Arquitectura basada en la cola

Utilice una cola de mensaje (Redis, RabbitMQ, o SQS) para gestionar su lista ASIN. Los procesos de trabajo sacan ASINs de la cola, los raspan y empujan los resultados a una tienda de datos. Este decouples programando desde el raspado y le permite escalar trabajadores de forma independiente.

Control de la moneda

Comience con 5-10 solicitudes simultáneas y aumente gradualmente mientras monitorice las tasas de éxito. Con la piscina residencial de ProxyHat, puede realizar sesiones simultáneas de 20-50 sin problemas. Vea nuestro página web de uso de la página de caso para configuraciones recomendadas.

Data Pipeline

Almacene HTML crudo en una tienda de objetos (S3) para reprocesamiento y datos analizados en PostgreSQL o en un almacén de datos. Esta separación le permite arreglar errores de parsing sin re-scraping.

Consejo Pro: Las páginas de productos Amazon cambian la estructura con frecuencia. Almacene HTML crudo para que pueda volver a extraer datos cuando los selectores cambian, sin golpear Amazon de nuevo.

Consideraciones jurídicas y éticas

El raspado web es legal en la mayoría de las jurisdicciones para los datos disponibles públicamente, pero las prácticas responsables importan. Sólo recopila datos que se muestra públicamente. No trate de acceder a páginas autenticadas, cuentas de vendedor o datos privados. Califique sus solicitudes para evitar degradar el servicio de Amazon para otros usuarios. Guarde sólo los datos que necesita y maneje en cumplimiento de las leyes de privacidad aplicables.

Key Takeaways

• El sistema antibot de Amazon requiere proxies residenciales con geo-targeting para coincidir con el mercado objetivo.
• Rotar IPs por solicitud de búsquedas a granel; utilizar sesiones pegajosas para navegar por paginados.
• Retrasos aleatorios, agentes de usuario y patrones de solicitud para evitar la detección.
• Construir una arquitectura basada en la cola para escalar más allá de unos pocos miles de productos.
• Almacene HTML crudo para la resiliencia contra los cambios selectores.
• Uso Los proxies residenciales de ProxyHat para altas tasas de éxito en todos los mercados de Amazon.

¿Listo para empezar a chatarrar datos de Amazon? Nuestra Guía de intercambio electrónico de datos cubre toda la estrategia, y usted puede explorar la infraestructura proxyHat en nuestra página de precios.