Wie man Amazon-Produktdaten mit Proxies scrapt

Warum Scrape Amazon Produktdaten?

Amazon beherbergt über 350 Millionen Produkte auf Dutzenden von Marktplätzen weltweit. Für E-Commerce-Unternehmen sind diese Daten unschätzbar: Konkurrentenpreise, Produktbeschreibungen, Kundenrezensionen, Best Sellers Rank und Inventarsignale können alle intelligenteren Entscheidungen vorantreiben. Ob Sie ein Preisüberwachung Werkzeug, die Marktforschung durchführen oder ein KI-Modell trainieren, Amazon-Produktdaten sind eines der höchstwertigen Ziele im Internet.

Die Herausforderung ist, dass Amazon stark in Anti-Bot-Verteidigungen investiert. Ohne die richtige Proxy-Strategie werden Ihre Abstreifer CAPTCHAs, IP-Blöcke und irreführende Antworten innerhalb von Minuten treffen. Diese Anleitung führt Sie durch die Architektur, Code und Proxy-Konfiguration, die benötigt wird, um Amazon zuverlässig im Maßstab zu kratzen.

Amazons Anti-Bot-Schutz

Bevor Sie eine einzelne Zeile des Codes schreiben, müssen Sie verstehen, was Sie gegen. Amazon verwendet ein geschichtetes Erkennungssystem, das jede eingehende Anfrage analysiert.

Fingerprinting anfordern

Amazon inspiziert HTTP-Header, TLS Fingerabdrücke und fordert die Bestellung. Anfragen fehlender Standard-Browser-Header oder mit bekannten Bot-Signaturen werden sofort markiert. Die Accept-Language, Accept-Encoding, und User-Agent Kopfzeilen müssen konsequent und realistisch sein.

Verhaltensanalyse

Anfragen, die mit einer Rate ankommen, die kein Mensch erreichen könnte, oder nach vorhersehbaren Mustern (z.B. sequentiellen ASINs), Trigger-Ratenbegrenzung. Amazon verfolgt Sitzungsverhalten über mehrere Anfragen, so dass sich jede IP wie ein echter Shopper verhalten muss.

CAPTCHA Herausforderungen

Wenn Amazon den automatisierten Verkehr vermutet, dient es eine CAPTCHA Seite anstelle von Produktdaten. Residential IPs erhalten weit weniger CAPTCHAs als Datacenter IPs, weil sie dieselben IP-Pools als echte Amazon-Shopper teilen. Für einen tieferen Blick auf Erkennungsmethoden, siehe unsere Anleitung auf wie Anti-Bot-Systeme Proxis erkennen.

Schlüsselübernahme: Für das anhaltende Amazonas-Schrotten sind gebietsansässige Proxie mit entsprechender Rotation unerlässlich. Datacenter-Proxies werden innerhalb von Stunden blockiert.

Daten Sie können aus Amazon extrahieren

Einrichten Ihrer Proxy-Konfiguration

ProxyHats Wohn-Proxy-Gateway bietet die IP-Diversity und Geo-Targeting für Amazon-Schrott. Schließen Sie durch unser Gateway und drehen Sie IPs automatisch auf jeder Anfrage oder halten Sie klebrige Sitzungen bei Bedarf.

Einfache Verbindung

# 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

Für Amazon Scraping empfehlen wir, das Land an den Marktplatz anzupassen, den Sie schrotten. Schrott amazon.de? Verwenden Sie deutsche IPs. Scraping amazon.co.jp? Verwenden Sie japanische IPs. Überprüfung Standorte für die vollständige Liste.

Implementierung von Python

Hier ist ein kompletter Python Scraper für Amazon Produktdaten mit ProxyHat's Python SDK neben Anfragen und BeautifulSoup.

Basic Product 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

Umgang mit Pagination für Suchergebnisse

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 Implementierung

Für Node.js-Projekte verwenden ProxyHat's Node SDK mit cheerio für parsing.

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 Strategien für Amazon

Amazons Erkennung wird aggressiver, je mehr Anträge aus einem einzigen IP kommen. Hier sind die Rotationsstrategien, die am besten funktionieren.

Per-Request Rotation

Für Schüttgut-Lookups, bei denen jede Anfrage unabhängig ist, drehen Sie IPs auf jeder Anfrage. Dies ist das Standardverhalten mit ProxyHat's Gateway: jede neue Verbindung erhält eine neue Wohn-IP.

Sitzungsbasierte Rotation

Beim Abkratzen von Suchergebnissen auf mehreren Seiten, halten Sie die gleiche IP für die gesamte Sitzung. Das Schalten von IPs Mid-Pagination sieht für Amazon verdächtig aus. Verwenden Sie ProxyHats klebrige Sitzungen:

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

Gezielte Rotation

Passen Sie Ihren Proxy-Standort auf den Amazon-Marktplatz. Der Zugriff auf amazon.de aus einer US-IP erhöht Flaggen. Zielspezifische Länder:

# 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

Weitere Informationen zu Rotationstechniken finden Sie in unserer detaillierten Anleitung die besten Proxys für Web-Schrott in 2026.

Best Practices für Amazon Scraping

• Zufällige Verzögerungen: Verwenden Sie zufällige Intervalle von 2-7 Sekunden zwischen Anfragen. Nie mit einem festen Satz abkratzen.
• Benutzer-Agenten drehen: Behalten Sie einen Pool von mindestens 10 realistischen Browser-Benutzer-Agent-Strings und drehen Sie sie.
• Griff CAPTCHAs anmutig: Wenn Sie eine CAPTCHA Antwort erhalten, 30-60 Sekunden zurück und mit einer neuen IP wiederkehren.
• Respect robots.txt: Obwohl in den meisten Rechtsordnungen nicht rechtsverbindlich, nach robots.txt Richtlinien zeigt guten Glauben.
• Benutzen Sie Wohn-Proxies: Datacenter IPs werden leicht identifiziert und von Amazon blockiert. Wohngebiete die gleichen IP-Bereiche wie echte Shopper teilen.
• Erfolgsquoten überwachen: Verfolgen Sie Ihre HTTP 200 Rate. Wenn es unter 90% sinkt, reduzieren Sie die Konkurrenz oder passen Sie Ihre Rotationsstrategie.
• Cache Antworten: Scrape nie die gleiche URL zweimal, wenn die Daten nicht geändert haben. Cache-Produktdaten und setzen Aktualisierungsintervalle basierend auf, wie häufig die Preise ändern.

Scaling Ihr Amazon Scraper

Beim Umzug von Hunderten auf Millionen von Produkten zählt die Architektur.

Queue-Based Architecture

Verwenden Sie eine Nachrichtenwarteschlange (Redis, RabbitMQ oder SQS), um Ihre ASIN-Liste zu verwalten. Worker-Prozesse ziehen ASINs aus der Warteschlange, kratzen sie und drücken Ergebnisse in einen Datenspeicher. Diese Entkoppelung scheduling aus dem Schrott und lässt Sie Arbeiter selbständig skalieren.

Konkurskontrolle

Beginnen Sie mit 5-10 gleichzeitigen Anfragen und erhöhen Sie allmählich die Erfolgsquoten. Mit dem Wohnpool von ProxyHat können Sie in der Regel 20-50 gleichzeitige Sitzungen ohne Probleme ausführen. Sehen Sie uns Web Scraping Verwendung Fallseite für empfohlene Konfigurationen.

Datenpipeline

Speichern Sie rohes HTML in einem Objektspeicher (S3) zur Wiederaufarbeitung und parsierten Daten in PostgreSQL oder einem Datenlager. Diese Trennung lässt Sie Parsing-Bugs reparieren, ohne wieder zu kratzen.

Pro Tipp: Amazon Produktseiten ändern Struktur häufig. Speichern Sie rohes HTML, so dass Sie Daten beim Wechsel der Selektoren neu ausziehen können, ohne erneut auf Amazon zu treffen.

Rechtliche und ethische Überlegungen

Web Scraping ist in den meisten Gerichtsbarkeiten für öffentlich zugängliche Daten, aber verantwortungsvolle Praktiken sind wichtig. Nur Daten sammeln, die öffentlich angezeigt werden. Versuchen Sie nicht, auf authentifizierte Seiten, Verkäuferkonten oder private Daten zugreifen. Beschränken Sie Ihre Anfragen, um den Amazon-Service für andere Benutzer zu vermeiden. Speichern Sie nur die Daten, die Sie benötigen und behandeln sie in Übereinstimmung mit den geltenden Datenschutzgesetzen.

Schlüsselanhänger

• Amazons Anti-Bot-System erfordert Wohn-Proxies mit Geo-Targeting, um auf den Zielmarkt zu passen.
• Drehen Sie IPs pro Anfrage für Bulk-Lookups; verwenden Sie klebrige Sessions für paginated browsing.
• Zufällige Verzögerungen, Benutzer-Agenten und Anforderung Muster, um Erkennung zu vermeiden.
• Erstellen Sie eine queuebasierte Architektur für Skalierung über einige tausend Produkte.
• Speichern Sie rohes HTML für Resilienz gegen Selektoränderungen.
• Verwendung ProxyHat's Wohn-Proxies für hohe Erfolgsquoten auf allen Amazon-Marktplätzen.

Bereit zum Abkratzen von Amazon-Daten? Unsere e-Commerce Daten-Schrottführer deckt die volle Strategie ab und Sie können die ProxyHat-Infrastruktur auf unserer Seite.