Google-Shopping-Daten mit Proxies scrapen

Google Shopping zu scrapen bedeutet, strukturierte Produktdaten (Titel, Preise, Verkäufer, Bewertungen und Versandhinweise) aus den Shopping-Ergebnissen von Google in großem Umfang zu sammeln. Da diese Ergebnisse stark geschützt und lokalisiert sind, benötigen Sie für eine zuverlässige Erfassung rotierende IPs und korrektes Geo-Targeting statt eines einzelnen Scrapers über eine einzige Verbindung.

Dieser Leitfaden ist codebasiert. Er behandelt geografisch ausgerichtete Anfragen, die Weiterleitung über länderspezifische Proxies, das Parsen von Produktkarten, die Google gezielt verschleiert, Paginierung, Wiederholungen und Backoff bei Ratenbegrenzungen, eine Headless-Browser-Alternative mit Behandlung von Einwilligungsdialogen, ein sauberes Datenmodell mit CSV-Export, einen Preisverlaufs-Tracker und einen Überwachungsplan. Er beleuchtet außerdem realistisch die Anti-Bot-Situation, den Kompromiss zwischen einem selbst entwickelten Scraper und einer kostenpflichtigen SERP API sowie die rechtlichen Grenzen.

DataImpulse ist ein ethischer Proxy-Anbieter mit mehr als 90 Millionen Residential-, Mobile- und Datacenter-IP-Adressen in 195 Ländern. Das Unternehmen nutzt ein Pay-as-you-go-Modell ab 1 Dollar pro GB mit nicht ablaufendem Traffic und wird für Web Scraping, Anzeigenverifizierung, Preisüberwachung, Marktforschung und die Verwaltung mehrerer Konten eingesetzt.

Welche Daten können Sie aus Google Shopping scrapen?

Google Shopping stellt Produktlisten mit mehreren strukturierten Feldern bereit, die für Preis- und Marktforschung nützlich sind. Jedes Ergebnis enthält typischerweise einen konsistenten Satz an Attributen, die Sie extrahieren und in Zeilen normalisieren können.

• Produktdetails: Titel, Beschreibungsauszug, Marke, Modell und URL des Produktbilds.
• Preis: der angezeigte Preis, die Währung und mitunter eine Preisspanne verschiedener Verkäufer.
• Verkäufer: der Name des Händlers und auf der Produktdetailseite eine Liste konkurrierender Verkäufer, die denselben Artikel anbieten.
• Bewertungen und Rezensionen: zusammengefasste Sternebewertung und Anzahl der Rezensionen, sofern vorhanden.
• Verfügbarkeit und Versand: Lagerstatus und Versandhinweise, die regional variieren.

Die genauen Felder ändern sich, sobald Google sein Layout aktualisiert. Deshalb muss jeder Parser fehlende Werte und wechselndes Markup tolerieren. Behandeln Sie jedes Feld als optional und prüfen Sie die Typen nach der Extraktion, statt davon auszugehen, dass eine Bewertung oder ein Verkäufer immer vorhanden ist. Da dasselbe Produkt in verschiedenen Ländern zu unterschiedlichen Preisen erscheinen kann, sollten Sie Ihr Schema von Anfang an um einen Schlüssel aus (Produkt, Land, Zeitstempel) herum planen, anstatt Geografie später nachzurüsten.

Wie senden Sie eine geografisch ausgerichtete Anfrage an Google Shopping?

Sie senden eine geografisch ausgerichtete Anfrage, indem Sie den Suchendpunkt von Google mit dem Flag für den Shopping-Tab und den Gebietsschema-Parametern aufrufen und dabei dieselben IP- und Parametersignale nutzen wie ein echter Käufer. Die beiden wichtigsten Parameter sind gl (das Land, zum Beispiel gl=de für Deutschland) und hl (die Sprache der Benutzeroberfläche, zum Beispiel hl=de). Ein dritter nützlicher Parameter ist ein Begriff im Stil von location, den Sie in den Abfragekontext einbinden. Doch gl zusammen mit einer passenden Exit-IP erledigt den größten Teil der Arbeit.

Die Parameter allein zu setzen reicht nicht aus, denn Google liest auch die Anfrage-IP, um zu entscheiden, welche Preise und Verkäufer angezeigt werden. Die minimale Anfrage unten sendet realistische Header und das Gebietsschema-Paar. Sie nutzt bewusst keinen Proxy, damit Sie den Basisaufruf sehen, bevor Sie eine IP-Schicht hinzufügen.

import requests

def build_params(query, country="us", lang="en", start=0):
    return {
        "q": query,
        "tbm": "shop",   # shopping vertical
        "gl": country,    # country bias, e.g. de, gb, fr
        "hl": lang,       # interface language
        "num": 40,        # results per page (soft cap)
        "start": start,   # pagination offset
    }

HEADERS = {
    "User-Agent": (
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
        "AppleWebKit/537.36 (KHTML, like Gecko) "
        "Chrome/124.0 Safari/537.36"
    ),
    "Accept-Language": "en-US,en;q=0.9",
}

resp = requests.get(
    "https://www.google.com/search",
    params=build_params("wireless headphones", country="us", lang="en"),
    headers=HEADERS,
    timeout=30,
)
print(resp.status_code, len(resp.text))

Halten Sie den Header Accept-Language auf hl abgestimmt. Eine deutsche Preisseite, die mit einem englischen Sprach-Header angefragt wird, ist unstimmig, wirkt unnatürlich und kann die falsche Währung zurückgeben. Wenn Sie skalieren, wird diese Basisfunktion zur zentralen Stelle für die Wahl des Gebietsschemas und hält damit alle nachgelagerten Aufrufe konsistent.

Wie leiten Sie Anfragen über länderspezifische Proxies?

Sie leiten Anfragen über einen länderspezifischen Proxy, indem Sie requests auf ein einzelnes Gateway verweisen und das Zielland im Proxy-Benutzernamen kodieren. Bei DataImpulse lautet das Gateway gw.dataimpulse.com:823, und durch Anhängen von __cr.us or __cr.de an Ihren Benutzernamen wählen Sie das Exit-Land aus. Länder-Targeting ist im Grundpreis enthalten, während Targeting nach Bundesstaat, Stadt, Postleitzahl und ASN kostenpflichtige Zusatzoptionen sind. Falls Proxy-Authentifizierung für Sie neu ist, erklärt unser Leitfaden zur Proxy-Authentifizierung die Mechanik von Benutzername und Passwort ausführlich.

import requests

USER = "your_login"
PASS = "your_password"
GATEWAY = "gw.dataimpulse.com:823"

def proxy_for(country):
    # __cr. pins the exit IP to that country
    cred = f"{USER}__cr.{country}:{PASS}"
    url = f"http://{cred}@{GATEWAY}"
    return {"http": url, "https": url}

resp = requests.get(
    "https://www.google.com/search",
    params=build_params("wireless headphones", country="de", lang="de"),
    headers=HEADERS,
    proxies=proxy_for("de"),
    timeout=30,
)
print(resp.status_code, len(resp.text))

Wichtig ist, das Proxy-Land und das Paar aus gl/hl gemeinsam umzustellen. Für einen marktübergreifenden Preisvergleich durchlaufen Sie eine Länderliste und halten Exit-IP und Gebietsschema im Gleichschritt, damit jede Antwort einen einzigen konsistenten Käuferstandort widerspiegelt.

MARKETS = [
    {"country": "us", "lang": "en"},
    {"country": "de", "lang": "de"},
    {"country": "gb", "lang": "en"},
    {"country": "fr", "lang": "fr"},
]

def fetch_market(query, market):
    c, lang = market["country"], market["lang"]
    return requests.get(
        "https://www.google.com/search",
        params=build_params(query, country=c, lang=lang),
        headers={**HEADERS, "Accept-Language": f"{lang};q=0.9"},
        proxies=proxy_for(c),
        timeout=30,
    )

for m in MARKETS:
    r = fetch_market("wireless headphones", m)
    print(m["country"], r.status_code, len(r.text))

DataImpulse stellt die IP-Schicht bereit, keinen verwalteten Scraping-Dienst. Den Scraper selbst verantworten Sie daher. Rotierende Residential-Proxies sind hier meist passend, da sie von echten Verbrauchergeräten stammen; Datacenter-Proxies sind günstiger, aber leichter zu erkennen, und Mobile-Proxies verfügen für die schwierigsten Ziele über IPs in Carrier-Qualität.

Wie parsen Sie Google-Shopping-Produktkarten?

Sie parsen Produktkarten mit einer toleranten HTML-Bibliothek und orientieren sich an stabilen Textmustern statt an fragilen, tiefen Selektoren, da die Klassennamen von Google verschleiert sind und häufig wechseln. Jeder Selektor, den Sie heute aus den Entwicklertools Ihres Browsers kopieren, kann innerhalb weniger Wochen brechen. Bauen Sie den Parser daher so, dass er bei Layoutänderungen kontrolliert nachlässt, statt abzustürzen.

Ein robuster Ansatz liest jede Kandidatenkarte, entnimmt Titel und Bild aus der Tag-Struktur und extrahiert den Preis mit einem währungssensiblen regulären Ausdruck. Die untenstehenden Selektoren sind realistische Beispiele, keine Garantien. Rechnen Sie damit, sie aktualisieren zu müssen, und behalten Sie den Regex als zuverlässigen Fallback.

from bs4 import BeautifulSoup
import re

# Currency-aware price matcher: symbol optional, thousands and decimals tolerated.
PRICE_RE = re.compile(r"(?:[$€£]|USD|EUR|GBP)\s?\d[\d.,]*")

def parse_cards(html):
    soup = BeautifulSoup(html, "html.parser")
    rows = []
    # These class names ROTATE; treat them as hints, keep the fallbacks.
    candidates = soup.select("div.sh-dgr__content, div.sh-dlr__list-result, div[data-docid]")
    if not candidates:
        candidates = soup.find_all("div")  # last-resort sweep
    for card in candidates:
        text = card.get_text(" ", strip=True)
        price_match = PRICE_RE.search(text)
        if not price_match or len(text) > 400:
            continue
        img = card.find("img")
        link = card.find("a", href=True)
        rows.append({
            "title": _first_text(card, ["h3", "h4"]),
            "price_raw": price_match.group(0),
            "image": img.get("src") if img else None,
            "url": link["href"] if link else None,
        })
    return rows

def _first_text(card, tags):
    for t in tags:
        el = card.find(t)
        if el and el.get_text(strip=True):
            return el.get_text(strip=True)
    return None

CURRENCY = {"$": "USD", "€": "EUR", "£": "GBP"}

def normalize_price(raw):
    if not raw:
        return None, None
    symbol = next((s for s in CURRENCY if s in raw), None)
    code = CURRENCY.get(symbol, "USD")
    digits = re.sub(r"[^\d.,]", "", raw).replace(",", "")
    try:
        return float(digits), code
    except ValueError:
        return None, code

Da verschleiertes Markup hier die Norm ist, setzen einige Teams stattdessen auf ein gerendertes DOM. Die umfassenderen Abwägungen zwischen dem Parsen statischen HTMLs und gerenderten Seiten erläutert unser Leitfaden zum Scrapen dynamischer Webseiten.

Wie paginieren Sie und fahren bei einer 429-Antwort von Google zurück?

Sie paginieren, indem Sie den Offset start in Schritten erhöhen, die Ihrer Seitengröße entsprechen, und überstehen Ratenbegrenzungen, indem Sie HTTP 429 (sowie leere oder CAPTCHA-Antworten) als Signal zum Warten und erneuten Versuch über eine frische IP behandeln. Google drosselt wiederholte automatisierte Anfragen aggressiv, daher gehören Paginierung und Backoff in dieselbe Schleife.

Gehen Sie die Seiten durch, bis eine Anfrage keine Karten zurückgibt oder Sie ein Seitenlimit erreichen. Rotieren Sie die Exit-IP zwischen den Seiten, indem Sie das Proxy-Dict erneut abrufen, und erkennen Sie weiche Sperren anhand von Einwilligungs- oder CAPTCHA-Markern im Body, statt sich allein auf den Statuscode zu verlassen.

BLOCK_MARKERS = ("unusual traffic", "/sorry/", "consent.google", "captcha")

def is_blocked(resp):
    if resp.status_code in (429, 503):
        return True
    body = resp.text.lower()
    return any(m in body for m in BLOCK_MARKERS)

def paginate(query, market, max_pages=5, page_size=40):
    all_rows = []
    for page in range(max_pages):
        params = build_params(query, market["country"], market["lang"],
                              start=page * page_size)
        resp = get_with_retry(
            "https://www.google.com/search",
            params=params, proxies=proxy_for(market["country"]),
        )
        if resp is None:
            break
        rows = parse_cards(resp.text)
        if not rows:
            break  # no more results
        all_rows.extend(rows)
    return all_rows

Die Wiederholungshilfe unten nutzt exponentiellen Backoff mit Jitter. Dadurch werden Wiederholungen verteilt, sodass eine Gruppe blockierter Worker nicht alle im selben Moment erneut versucht. Jeder Versuch ruft das Proxy-Dict neu ab, sodass ein rotierender Pool beim nächsten Versuch eine neue IP bereitstellt.

import time, random

def get_with_retry(url, params, proxies, max_attempts=4):
    for attempt in range(max_attempts):
        try:
            resp = requests.get(url, params=params, headers=HEADERS,
                                proxies=proxies, timeout=30)
        except requests.RequestException:
            resp = None
        if resp is not None and not is_blocked(resp):
            return resp
        # exponential backoff: 2, 4, 8 seconds, plus jitter
        wait = (2 ** (attempt + 1)) + random.uniform(0, 1.5)
        time.sleep(wait)
    return None  # exhausted; caller decides what to do

Halten Sie die Anfragerate auch bei erfolgreichen Wiederholungen angemessen. Eine respektvolle Grundverzögerung zwischen den Seiten sorgt zusammen mit Rotation stärker für langfristige Stabilität als massenhafte Anfragen und das Verlassen auf Wiederholungen. Unsere Hinweise zu Best Practices für Web Scraping behandeln Taktung und Header-Hygiene ausführlicher.

Wie rendern Sie blockierte Seiten mit einem Headless-Browser?

Wenn eine einfache HTTP-Anfrage immer wieder auf Einwilligungsbarrieren oder JavaScript-gerenderte Inhalte trifft, nutzen Sie einen Headless-Browser, der die Seite wie ein echter Client ausführt, und schließen Sie den Einwilligungsdialog, bevor Sie das DOM auslesen. Playwright eignet sich gut, weil es kontextbezogene Proxies und zuverlässiges Warten unterstützt.

Das folgende Skript startet Chromium über einen länderspezifischen DataImpulse-Proxy, behandelt den Cookie- oder Einwilligungsdialog, der in europäischen Gebietsschemata gewöhnlich erscheint, wartet auf Inhalte und gibt das gerenderte HTML zurück, damit Sie es derselben Funktion parse_cards zuführen können.

from playwright.sync_api import sync_playwright

def render_shopping(query, country="de", lang="de"):
    cred_user = f"{USER}__cr.{country}"
    params = f"?q={query.replace(' ', '+')}&tbm=shop&gl={country}&hl={lang}"
    url = "https://www.google.com/search" + params
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        context = browser.new_context(
            proxy={
                "server": "http://gw.dataimpulse.com:823",
                "username": cred_user,
                "password": PASS,
            },
            locale=f"{lang}-{country.upper()}",
            user_agent=HEADERS["User-Agent"],
        )
        page = context.new_page()
        page.goto(url, wait_until="domcontentloaded", timeout=45000)
        _dismiss_consent(page)
        page.wait_for_timeout(2000)
        html = page.content()
        browser.close()
        return html

def _dismiss_consent(page):
    # Consent dialogs vary by locale; try a few common accept buttons.
    for label in ("Accept all", "Alle akzeptieren", "Tout accepter",
                  "I agree", "Accept"):
        try:
            btn = page.get_by_role("button", name=label)
            if btn.count() > 0:
                btn.first.click(timeout=3000)
                page.wait_for_timeout(1000)
                return
        except Exception:
            continue

Ein Headless-Browser benötigt mehr CPU und Speicher als eine rohe Anfrage. Nutzen Sie ihn daher als gezielten Fallback für Seiten, die tatsächlich Rendering benötigen, statt als Standardweg. Viele Teams verwenden für die Geschwindigkeit direktes HTTP und wechseln erst zu Playwright, wenn is_blocked immer wieder ausgelöst wird. Wenn Ihr Stack JavaScript statt Python nutzt, gilt dasselbe Muster mit Puppeteer. Siehe Web Scraping mit JavaScript.

Wie strukturieren und exportieren Sie die gescrapten Daten?

Sie strukturieren die Daten um einen stabilen Datensatz, der immer den Markt und einen Erfassungszeitstempel enthält, und exportieren sie dann als CSV, sodass sich die Ausgabe einfach vergleichen, in eine Tabelle laden oder in ein Data Warehouse übertragen lässt. Eine Dataclass liefert Typhinweise und eine klare Definition einer Zeile.

from dataclasses import dataclass, asdict, field
from datetime import datetime, timezone
import csv

@dataclass
class Offer:
    query: str
    country: str
    title: str | None
    price: float | None
    currency: str | None
    seller: str | None = None
    url: str | None = None
    captured_at: str = field(
        default_factory=lambda: datetime.now(timezone.utc).isoformat()
    )

def to_offers(rows, query, country):
    offers = []
    for r in rows:
        price, currency = normalize_price(r.get("price_raw"))
        offers.append(Offer(
            query=query, country=country, title=r.get("title"),
            price=price, currency=currency, url=r.get("url"),
        ))
    return offers

Das Schreiben der CSV besteht dann darin, die Dataclass-Felder auszugeben. Der Anhängemodus zusammen mit einer Header-Prüfung lässt einen geplanten Job eine Datei im Lauf der Zeit erweitern, ohne sie neu zu schreiben.

import os

def export_csv(offers, path="google_shopping.csv"):
    if not offers:
        return
    fieldnames = list(asdict(offers[0]).keys())
    write_header = not os.path.exists(path)
    with open(path, "a", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=fieldnames)
        if write_header:
            writer.writeheader()
        for o in offers:
            writer.writerow(asdict(o))

Land und Zeitstempel in jeder Zeile ermöglichen später Antworten auf Fragen wie, welcher Markt heute für eine SKU am günstigsten ist oder wie sich ein Preis diese Woche verändert hat. Dieser Schlüssel aus Geografie und Zeit ist die Grundlage für den Preisverlaufs-Tracker im nächsten Abschnitt.

Wie verfolgen Sie den Google-Shopping-Preisverlauf im Zeitverlauf?

Sie verfolgen den Preisverlauf, indem Sie jede Beobachtung per Upsert in eine kleine Datenbank schreiben, deren Schlüssel aus Produkt, Land und Tag besteht. So aktualisiert ein erneuter Scraper-Lauf die heutige Zeile, statt sie zu duplizieren, während frühere Tage erhalten bleiben. SQLite reicht für Millionen von Zeilen und benötigt keinen Server, wodurch ein Überwachungsjob eigenständig bleibt.

Das folgende Schema verwendet einen zusammengesetzten eindeutigen Schlüssel und ein ON CONFLICT-Upsert. Wenn der Scraper an einem Tag zweimal läuft, überschreibt er den letzten Preis für dieses (Produkt, Land, Tag). Läuft er über mehrere Tage, entsteht die Zeitreihe, die Sie später grafisch darstellen können.

import sqlite3

DDL = """
CREATE TABLE IF NOT EXISTS price_history (
    product   TEXT NOT NULL,
    country   TEXT NOT NULL,
    day       TEXT NOT NULL,
    price     REAL,
    currency  TEXT,
    seller    TEXT,
    captured_at TEXT,
    PRIMARY KEY (product, country, day)
);
"""

def init_db(path="prices.db"):
    conn = sqlite3.connect(path)
    conn.execute(DDL)
    conn.commit()
    return conn

def upsert_offers(conn, offers):
    sql = """
    INSERT INTO price_history
        (product, country, day, price, currency, seller, captured_at)
    VALUES (?, ?, ?, ?, ?, ?, ?)
    ON CONFLICT(product, country, day) DO UPDATE SET
        price=excluded.price,
        currency=excluded.currency,
        seller=excluded.seller,
        captured_at=excluded.captured_at;
    """
    for o in offers:
        day = o.captured_at[:10]  # YYYY-MM-DD
        conn.execute(sql, (o.title, o.country, day, o.price,
                           o.currency, o.seller, o.captured_at))
    conn.commit()

def price_trend(conn, product, country, days=14):
    cur = conn.execute(
        """SELECT day, price, currency FROM price_history
           WHERE product = ? AND country = ?
           ORDER BY day DESC LIMIT ?""",
        (product, country, days),
    )
    return cur.fetchall()

In der Praxis ist der Abgleich von Titeln über mehrere Tage der schwierige Teil, weil die Titel von Google zwischen Erfassungen leicht variieren. Ordnen Sie für eine kleine Beobachtungsliste die Roh-Titel vor dem Upsert einer von Ihnen kontrollierten kanonischen Produkt-ID zu, statt dem gescrapten Titel als stabilem Schlüssel zu vertrauen.

Wie planen Sie die fortlaufende Preisüberwachung?

Sie planen die Überwachung, indem Sie die Schritte Abrufen, Parsen und Speichern in einem Einstiegspunkt bündeln und ihn mit cron in einem festen Rhythmus ausführen. So werden Preise ohne manuelle Läufe automatisch aktualisiert. Ein täglicher Lauf ist ein sinnvoller Standard für die Preisverfolgung; häufigere Läufe erhöhen bei den meisten Katalogen Kosten und Sperrrisiko, ohne viel zusätzlichen Erkenntnisgewinn zu liefern.

# run_monitor.py
def run_once(queries):
    conn = init_db()
    for query in queries:
        for market in MARKETS:
            rows = paginate(query, market, max_pages=3)
            offers = to_offers(rows, query, market["country"])
            export_csv(offers)
            upsert_offers(conn, offers)
            print(f"{query} / {market['country']}: {len(offers)} offers")
    conn.close()

if __name__ == "__main__":
    WATCHLIST = ["wireless headphones", "mechanical keyboard"]
    run_once(WATCHLIST)

Registrieren Sie ihn anschließend bei cron. Der Eintrag unten führt den Monitor täglich um 06:15 Uhr aus und protokolliert die Ausgabe zur Fehlersuche. Das ist wichtig, weil ein geplanter Scraper sonst unbemerkt fehlschlägt.

# crontab -e
# minute hour day month weekday  command
15 6 * * * cd /opt/shopping && /usr/bin/python3 run_monitor.py >> monitor.log 2>&1

Fügen Sie innerhalb des Jobs leichten Jitter hinzu, also zu Beginn eine zufällige Wartezeit von einigen Minuten, damit Anfragen Google nicht jeden Tag zur exakt gleichen Sekunde erreichen. Rotieren Sie Exit-Länder und takten Sie Anfragen wie zuvor beschrieben. Achten Sie außerdem im Log auf eine steigende Sperrrate, denn das ist das früheste Zeichen dafür, dass Google seine Schutzmechanismen geändert hat oder Ihre Muster zu regelmäßig geworden sind.

Welchen Erfassungsansatz sollten Sie wählen: DIY, versteckte Endpunkte, SERP API oder Headless?

Wählen Sie danach, wie viel Fragilität und Engineering Sie selbst verantworten wollen und wie viel Sie pro Anfrage zu zahlen bereit sind. Es gibt keine einzig richtige Antwort; die ehrliche Abwägung lautet Kontrolle und Kosten gegen Wartungsaufwand und Anti-Bot-Exposition.

Die Anti-Bot-Realität: Google schützt diese Ergebnisse aktiv mit Ratenbegrenzungen, CAPTCHAs, Einwilligungsbarrieren, rotierendem verschleiertem Markup und Verhaltenssignalen. Jeder selbst entwickelte Scraper wird regelmäßig ausfallen und fortlaufende Wartung benötigen. Proxies und Backoff reduzieren Sperren, beseitigen sie aber nicht. Wer einen dauerhaft unblockierbaren Google-Scraper verspricht, übertreibt.

SERP API gegenüber DIY: Eine externe SERP API gibt geparste Shopping-Ergebnisse als JSON zurück und übernimmt für Sie die Arbeit des Parsens und Entsperrens, allerdings zu einem Preis pro Anfrage sowie mit Anbieterbindung und weniger Kontrolle darüber, was genau abgerufen wird. Ein selbst entwickelter Scraper auf Proxies kostet pro Anfrage deutlich weniger und gibt Ihnen volle Kontrolle, doch Sie verantworten Parser, Wiederholungen und Wartung bei Google-Änderungen. Zur Einordnung von DataImpulse: Es ist die Proxy-Schicht unter diesen DIY-Ansätzen, keine SERP API und kein verwalteter Scraping-Dienst. Wenn Sie gar keinen Parsing-Aufwand wollen, ist eine SERP API die ehrliche Empfehlung. Wenn Sie geringe Kosten und Kontrolle wünschen und einen Scraper warten können, ist DIY mit rotierenden Proxies wirtschaftlicher. Versteckte JSON-Endpunkte können noch günstiger sein, sind aber am fragilsten, weil Google sie ohne Vorankündigung ändern oder entfernen kann.

Ist es legal und ethisch, Google Shopping zu scrapen?

Das Scrapen öffentlich sichtbarer Produktdaten gilt im Allgemeinen als risikoärmer als der Zugriff auf private oder geschützte Inhalte, ist jedoch nicht regelfrei und stellt keine Rechtsberatung dar. Preise und Angebote bei Google Shopping sind öffentlich, aber die Art ihrer Erhebung und Nutzung ist dennoch relevant. Klären Sie Ihren konkreten Fall mit qualifizierter Rechtsberatung.

• Nutzungsbedingungen: automatisierter Zugriff kann mit den Nutzungsbedingungen von Google kollidieren. Das ist eine vertragliche Frage, getrennt von Urheberrecht oder Gesetzen zum Computerzugriff.
• Personenbezogene Daten: Produktangebote sind normalerweise keine personenbezogenen Daten, doch vermeiden Sie das Sammeln von Rezensentennamen oder anderen Identifikatoren und befolgen Sie die DSGVO, wo sie gilt.
• Rate und Last: Halten Sie das Anfragevolumen angemessen, damit Sie den abgefragten Dienst nicht beeinträchtigen.
• Datennutzung: Die umfassende Wiederverwendung urheberrechtlich geschützter Bilder oder Beschreibungen birgt mehr Risiko als die Analyse von Preisen als Tatsachen.

Bei der Erfassung beginnt Ethik mit den verwendeten IPs. DataImpulse bezieht seine IPs von Nutzern, die einwilligen und vergütet werden, richtet sich nach der DSGVO und bietet einen Auftragsverarbeitungsvertrag, was eine gut vertretbare Pipeline unterstützt. Unser Leitfaden zum ethischen Web Scraping. Kombinieren Sie eine ethische IP-Quelle mit respektvoller Taktung und einer eng gefassten, sachlichen Datennutzung, halten Sie sowohl das rechtliche als auch das Reputationsrisiko niedrig.

Häufig gestellte Fragen

Weiterführende Leitfäden

• Google Trends scrapen
• Hotelangebote scrapen
• Dynamische Webseiten scrapen

Beginnen Sie mit dem Scrapen von Google Shopping mit zuverlässigen Proxies

Wenn Sie bereit sind, Google-Shopping-Daten über mehrere Märkte hinweg zu erfassen, bietet Ihnen DataImpulse rotierende und Sticky Residential-, Mobile- und Datacenter-IPs inklusive Länder-Targeting, ab einem Dollar pro GB. Konto erstellen und leiten Sie Ihren ersten Scraper über einen sauberen IP-Pool.