E-commerce et Veille Concurrentielle 9 min de lecture

Comment scraper les données produit Amazon avec des proxies

Découvrez comment gratter les données de produits Amazon, y compris les prix, les commentaires et les classements en utilisant les procurations résidentielles. Exemples complets de code Python et Node.js avec des stratégies anti-détection.

ProxyHat Team
Comment scraper les données produit Amazon avec des proxies

Pourquoi Scrape Amazon Données de produit?

Amazon accueille plus de 350 millions de produits sur des dizaines de marchés mondiaux. Pour les entreprises de commerce électronique, ces données sont inestimables : prix des concurrents, descriptions de produits, avis clients, classement des meilleures ventes et signaux d'inventaire peuvent tous conduire à des décisions plus intelligentes. Que vous construisiez une outil de suivi des prix, la réalisation d'études de marché, ou la formation d'un modèle d'IA, les données de produit Amazon est l'une des cibles de valeur la plus élevée sur le web.

Le défi est qu'Amazon investit massivement dans les défenses anti-bots. Sans la bonne stratégie de remplacement, vos racleurs frapperont les CAPTCHA, les blocs IP et les réponses trompeuses en quelques minutes. Ce guide vous accompagne dans l'architecture, le code et la configuration proxy nécessaires pour racler Amazon de façon fiable à l'échelle.

Les Protections Anti-Bot d'Amazon

Avant d'écrire une seule ligne de code, vous devez comprendre ce que vous êtes contre. Amazon utilise un système de détection en couches qui analyse chaque demande entrante.

Demande d'impression digitale

Amazon inspecte les en-têtes HTTP, les empreintes digitales TLS et demande de commande. Les demandes manquantes en-têtes standard du navigateur ou utilisant des signatures bot connues sont signalées immédiatement. Les Accept-Language, Accept-Encodinget User-Agent Les en-têtes doivent être cohérents et réalistes.

Analyse comportementale

Les demandes arrivant à un taux qu'aucun humain ne pourrait atteindre, ou suivant des modèles prévisibles (p. ex., des NASS séquentiels), limitent le taux de déclenchement. Amazon suit le comportement de session sur plusieurs requêtes, donc chaque IP doit se comporter comme un véritable shopper.

Défis de la CAPTCHA

Lorsque Amazon soupçonne un trafic automatisé, il dessert une page CAPTCHA au lieu de données produit. Les IP résidentielles reçoivent beaucoup moins de CAPTCHA que les IP datacenter parce qu'elles partagent les mêmes piscines IP que les véritables acheteurs Amazon. Pour un examen plus approfondi des méthodes de détection, voir notre guide sur comment les systèmes anti-bot détectent les proxies.

Takeaway clé: Les proxies résidentielles avec rotation appropriée sont essentielles pour le grattage soutenu d'Amazon. Les détecteurs de datacenter seront bloqués en quelques heures.

Données que vous pouvez extraire d'Amazon

Données que vous pouvez extraire d'Amazon
Point de donnéesPage sourceCas d'utilisation
Titre du produit, images, descriptionPage de détail du produitCatalogue, analyse de contenu
Prix courant, prix de vente, prix de catalogueDétail du produit / liste des offresContrôle des prix, révision
Avis et notes des clientsRévision des pagesAnalyse des sentiments, recherche de produits
Classement des meilleures ventes (BSR)Page de détail du produitEstimation de la demande du marché
Acheter Box seller, informations d'expéditionPage de détail du produitSuivi des concurrents
Classement des résultats de la recherchePages des résultats de la rechercheSEO et optimisation de la publicité
Hiérarchie des catégoriesParcourir les nœudsCartographie taxonomique

Configuration de votre mandataire

La passerelle proxyHat résidentielle fournit la diversité IP et la géo-ciblage nécessaires pour le grattage d'Amazon. Connectez-vous à travers notre passerelle et faites pivoter les IP automatiquement sur chaque demande ou maintenez des sessions collantes au besoin.

Connexion de 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

Pour le grattage d'Amazon, nous vous recommandons de cibler le pays correspondant au marché que vous raclez. Tu as fait des recherches sur Amazon.de ? Utiliser des IP allemands. Utilisez des IP japonaises. Vérifier lieux disponibles pour la liste complète.

Mise en œuvre de Python

Voici un racleur Python complet pour les données de produits Amazon Python SDK de ProxyHat avec les demandes et BeautifulSoup.

Grattoir de produit de base

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

Manipulation Pagination pour les résultats de recherche

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

Mise en œuvre de Node.js

Pour les projets Node.js, utiliser Le nœud SDK de ProxyHat avec glorio pour l'analyse.

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

Stratégies de rotation par procuration pour Amazon

La détection d'Amazon devient plus agressive, plus les demandes proviennent d'une seule IP. Voici les stratégies de rotation qui fonctionnent le mieux.

Rotation par demande

Pour les recherches de produits en vrac où chaque demande est indépendante, faites pivoter les IP sur chaque demande. Ceci est le comportement par défaut avec la passerelle de ProxyHat : chaque nouvelle connexion obtient une nouvelle IP résidentielle.

Rotation par session

Lors de la suppression des résultats de recherche sur plusieurs pages, maintenez la même IP pour toute la session. Changer d'IPs mi-pagination semble suspect pour Amazon. Utilisez les séances collantes de ProxyHat :

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

Rotation géographique

Correspondez à votre emplacement proxy au marché Amazon. L'accès amazon.de d'une IP américaine soulève des drapeaux. Pays cibles:

# 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

Pour en savoir plus sur les techniques de rotation, consultez notre guide détaillé sur les meilleurs proxies pour le grattage de toile en 2026.

Meilleures Pratiques pour le Scraping Amazon

  • randomiser les retards : Utiliser des intervalles aléatoires de 2 à 7 secondes entre les requêtes. Ne grattez jamais à un taux fixe.
  • Rotation des agents utilisateurs : Maintenez une réserve d'au moins 10 chaînes User-Agent de navigateur réalistes et faites-les tourner.
  • Poignez les CAPTCHA avec grâce : Si vous recevez une réponse CAPTCHA, reculez pendant 30-60 secondes et réessayez avec une nouvelle IP.
  • Respecter robots.txt: Bien qu'elles ne soient pas juridiquement contraignantes dans la plupart des pays, les directives Robots.txt démontrent la bonne foi.
  • Utiliser des procurations résidentielles : Les IP de Datacenter sont facilement identifiés et bloqués par Amazon. Proxies résidentielles partager les mêmes gammes IP que les vrais acheteurs.
  • Surveiller les taux de réussite : Suivez votre taux HTTP 200. Si elle tombe en dessous de 90 %, réduisez la concordance ou ajustez votre stratégie de rotation.
  • Réponses de cache : Ne grattez jamais la même URL deux fois si les données n'ont pas changé. Cache les données sur les produits et les intervalles de rafraîchissement en fonction de la fréquence des variations des prix.

Écailler votre gratte-ciel amazonien

En passant de centaines à des millions de produits, l'architecture compte.

Architecture en file d'attente

Utilisez une file d'attente de messages (Redis, RabbitMQ ou SQS) pour gérer votre liste ASIN. Les processus ouvriers tirent les ASINs de la file d'attente, les grattent et poussent les résultats vers un magasin de données. Cela découple l'horaire de la grattage et vous permet d'écheller les travailleurs indépendamment.

Contrôle des devises

Commencez par 5-10 demandes simultanées et augmentez graduellement tout en surveillant les taux de réussite. Avec la piscine résidentielle de ProxyHat, vous pouvez généralement exécuter 20-50 sessions simultanées sans problèmes. Voir notre page de cas d'utilisation de grattage web pour les configurations recommandées.

Pipeline de données

Stocker le HTML brut dans un magasin d'objets (S3) pour le retraitement, et les données analysées dans PostgreSQLTM ou un entrepôt de données. Cette séparation vous permet de corriger les bogues d'analyse sans re-scraping.

Conseil pro : Les pages de produits Amazon changent fréquemment de structure. Stockez le HTML brut afin que vous puissiez réextraire les données lorsque les sélecteurs changent, sans frapper Amazon à nouveau.

Considérations juridiques et éthiques

Dans la plupart des pays, le grattage du Web est légal pour les données accessibles au public, mais les pratiques responsables sont importantes. Recueillir uniquement les données qui sont affichées publiquement. Ne tentez pas d'accéder aux pages authentifiées, aux comptes de vendeurs ou aux données privées. Limitez vos demandes pour éviter de dégrader le service d'Amazon pour les autres utilisateurs. Conservez uniquement les données dont vous avez besoin et traitez-les conformément aux lois applicables en matière de confidentialité.

A emporter des clés

  • Le système anti-bot d'Amazon nécessite des procurations résidentielles avec géo-cible pour correspondre au marché cible.
  • Roter les IP par demande pour les recherches en vrac; utiliser des sessions collantes pour la navigation paginée.
  • Randomiser les retards, les utilisateurs-agents et les modèles de demande pour éviter la détection.
  • Construire une architecture basée sur la file d'attente pour l'échelle au-delà de quelques milliers de produits.
  • Stocker le HTML brut pour la résilience contre les changements de sélecteur.
  • Utilisation Proxies résidentielles de ProxyHat pour des taux de succès élevés sur tous les marchés amazoniens.

Prêt à commencer à gratter les données Amazon? Notre Guide de suppression des données sur le commerce électronique couvre la stratégie complète, et vous pouvez explorer l'infrastructure de proxyHat page de prix.

Prêt à commencer ?

Accédez à plus de 50M d'IPs résidentielles dans plus de 148 pays avec filtrage IA.

Voir les tarifsProxies résidentiels
← Retour au Blog