Come Scrape Amazon Product Data con Proxies

Perché Scrape Amazon Product Data?

Amazon ospita oltre 350 milioni di prodotti attraverso decine di mercati in tutto il mondo. Per le aziende di e-commerce, questi dati sono inestimabili: prezzi concorrenti, descrizioni dei prodotti, recensioni dei clienti, Best Sellers Rank, e segnali di inventario possono tutti guidare decisioni più intelligenti. Se stai costruendo un strumento di monitoraggio dei prezzi, conducendo ricerche di mercato, o formazione di un modello AI, i dati di prodotto Amazon sono uno dei target di maggior valore sul web.

La sfida è che Amazon investe fortemente nelle difese anti-bot. Senza la giusta strategia di proxy, i raschiatori colpiranno CAPTCHA, blocchi IP e risposte fuorvianti in pochi minuti. Questa guida ti accompagna attraverso l'architettura, il codice e la configurazione del proxy necessario per raschiare Amazon in modo affidabile in scala.

Anti-Bot Protections di Amazon

Prima di scrivere una singola riga di codice, è necessario capire ciò che si sta contro. Amazon utilizza un sistema di rilevamento a strati che analizza ogni richiesta in arrivo.

Richiesta di stampaggio

Amazon ispeziona intestazioni HTTP, impronte TLS e richiede l'ordine. Le richieste di intestazioni del browser standard mancanti o utilizzando note firme del bot sono immediatamente contrassegnate. The Accept-Language♪ Accept-Encodinge User-Agent le intestazioni devono essere coerenti e realistiche.

Analisi comportamentale

Richieste che arrivano ad un tasso nessun umano potrebbe raggiungere, o seguendo modelli prevedibili (ad esempio, ASIN sequenziali), limite di velocità di attivazione. Amazon traccia il comportamento di sessione attraverso più richieste, quindi ogni IP deve comportarsi come un vero e proprio shopper.

CAPTCHA Sfide

Quando Amazon sospetta traffico automatizzato, serve una pagina CAPTCHA invece di dati di prodotto. Gli IP residenziali ricevono molto meno CAPTCHA rispetto agli IP datacenter perché condividono gli stessi pool IP come veri acquirenti Amazon. Per uno sguardo più approfondito ai metodi di rilevamento, vedere la nostra guida come i sistemi anti-bot rilevano i proxy.

Asporto chiave: I proxy residenziali con una corretta rotazione sono essenziali per il raschiamento Amazon sostenuto. I proxy Datacenter saranno bloccati entro ore.

Dati che puoi estrarre da Amazon

Impostazione della configurazione del proxy

Il gateway proxy residenziale di ProxyHat offre la diversità IP e la geo-targeting necessari per la raschiatura Amazon. Collegare il nostro gateway e ruotare gli IP automaticamente su ogni richiesta o mantenere sessioni appiccicose quando necessario.

Connessione di base

# 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

Per la raschiatura Amazon, si consiglia di indirizzare il paese corrispondente al mercato si sta raschiando. Scraping amazon.de? Utilizzare IP tedeschi. Scraping amazon.co.jp? Usa gli IP giapponesi. Check luoghi disponibili per la lista completa.

Attuazione di Python

Ecco un raschietto Python completo per i dati dei prodotti Amazon utilizzando ProxyHat Python SDK accanto alle richieste e BeautifulSoup.

Graffio di base del prodotto

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

Handling Pagination per i risultati della ricerca

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 Attuazione

Per i progetti Node.js, utilizzare SDK del nodo di ProxyHat con cheerio per la parata.

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

Proxy Rotation Strategies per Amazon

Il rilevamento di Amazon diventa più aggressivo le richieste vengono da un unico IP. Ecco le strategie di rotazione che funzionano meglio.

Per-Richiesta Rotazione

Per ricerche di prodotti di massa in cui ogni richiesta è indipendente, ruotare IP su ogni richiesta. Questo è il comportamento predefinito con il gateway di ProxyHat: ogni nuova connessione ottiene un IP residenziale fresco.

Rotazione basata su sessione

Quando si raschiano i risultati di ricerca su più pagine, mantenere lo stesso IP per l'intera sessione. Interruttore IPs mid-pagination sembra sospetto per Amazon. Utilizzare le sessioni appiccicose di ProxyHat:

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

Rotazione geometrica

Abbina la tua posizione proxy al mercato Amazon. Accedere a amazon.de da un IP americano solleva bandiere. Paesi specifici di destinazione:

# 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

Per ulteriori informazioni sulle tecniche di rotazione, leggere la nostra guida dettagliata i migliori proxy per la raschiatura web nel 2026.

Migliori Pratiche per Amazon Scraping

• Randomize ritardi: Utilizzare intervalli casuali di 2-7 secondi tra le richieste. Mai raschiare ad un tasso fisso.
• Rotate User-Agents: Mantenere una piscina di almeno 10 realistico browser User-Agent strings e ruotarli.
• Manigliare CAPTCHAs con grazia: Se ricevi una risposta CAPTCHA, richiudi per 30-60 secondi e richiedi un nuovo IP.
• Rispettare robot.txt: Sebbene non giuridicamente vincolante nella maggior parte delle giurisdizioni, seguendo le direttive robots.txt dimostra buona fede.
• Utilizzare i proxy residenziali: Gli IP del Datacenter sono facilmente identificati e bloccati da Amazon. Processi residenziali condividere gli stessi intervalli IP come veri acquirenti.
• Monitorare i tassi di successo: Traccia la tua frequenza HTTP 200. Se scende al di sotto del 90%, ridurre la convalutazione o regolare la strategia di rotazione.
• Risposte di cache: Non raschiare mai lo stesso URL due volte se i dati non sono cambiati. Cache dati di prodotto e impostare intervalli di aggiornamento in base a come i prezzi di frequenza cambiano.

Scala il tuo grattacielo Amazon

Quando si sposta da centinaia a milioni di prodotti, l'architettura conta.

Architettura basata su queue

Utilizzare una coda di messaggio (Redis, RabbitMQ o SQS) per gestire la tua lista ASIN. I processi di lavoro tirano ASIN dalla coda, li raschiano e spingono i risultati in un data store. Questo decouples scheduling da scraping e consente di scalare i lavoratori indipendentemente.

Controllo della concorrenza

Iniziare con 5-10 richieste concomite e aumentare gradualmente, monitorando i tassi di successo. Con la piscina residenziale di ProxyHat, è in genere possibile eseguire 20-50 sessioni contemporaneamente senza problemi. Guarda la nostra web scraping uso caso pagina per configurazioni consigliate.

Data Pipeline

Conservare l'HTML grezzo in un negozio di oggetti (S3) per la rielaborazione e i dati analizzati in PostgreSQL o in un magazzino dati. Questa separazione ti permette di risolvere i bug di parsing senza ri-scraping.

Pro punta: Le pagine del prodotto Amazon cambiano la struttura frequentemente. Conservare HTML grezzo in modo da poter estrarre i dati quando i selettori cambiano, senza colpire nuovamente Amazon.

Considerazioni giuridiche ed etiche

La raschiatura del Web è legale nella maggior parte delle giurisdizioni per i dati pubblicamente disponibili, ma le pratiche responsabili sono importanti. Raccogli solo i dati che vengono visualizzati pubblicamente. Non tentare di accedere a pagine autenticate, account del venditore o dati privati. Rate-limit le vostre richieste per evitare di degradare il servizio di Amazon per altri utenti. Conservare solo i dati di cui hai bisogno e gestirli in conformità alle leggi sulla privacy applicabili.

Asporto chiave

• Il sistema anti-bot di Amazon richiede proxy residenziali con geo-targeting per abbinare il mercato target.
• Ruotare gli IP per richiesta per ricerche di massa; utilizzare sessioni appiccicose per la navigazione impaginata.
• Randomitare ritardi, Utente-Aggenti e richiedere modelli per evitare il rilevamento.
• Costruire un'architettura basata sulla coda per scalare oltre poche migliaia di prodotti.
• Conservare l'HTML grezzo per la resilienza contro le modifiche del selettore.
• Uso I proxy residenziali di ProxyHat per alti tassi di successo su tutti i mercati Amazon.

Pronto per iniziare a demolire i dati Amazon? Il nostro e-commerce dati scraping guida copre la strategia completa, e si può esplorare l'infrastruttura proxy di ProxyHat sulla nostra pagina dei prezzi.