Google Shopping-Daten scrapenProdukte, Preise und Verkäufer

Google Shopping ist eine der dichtesten E-Commerce-Oberflächen im Web. Eine einzelne Ergebnisseite fasst Produkttitel, Preise, Verkäufer, Bewertungen und Links von Dutzenden von Einzelhändlern nebeneinander zusammen, was genau die Datenform ist, die ein Preismonitoring- oder Marktforschungs-Job benötigt. Wenn Sie online etwas verkaufen, zeigen Ihnen die öffentlichen Inserate, was Wettbewerber verlangen und wer ein bestimmtes Produkt gerade vorrätig hat.

Diese Anleitung zeigt Ihnen, wie Sie Google Shopping-Daten scrapen mit Python und dabei zuverlässig vorgehen. Sie erstellen einen kleinen, lauffähigen Scraper, der über die Crawling API eine gerenderte Shopping-Ergebnisseite abruft, jedes Inserat mit BeautifulSoup parst, die Paginierung handhabt und die Datensätze für das Preistracking in JSON und CSV exportiert. Der gesamte Walkthrough beschränkt sich auf öffentliche Shopping-Inserate, die jeder ohne Konto einsehen kann, und der Abschnitt zur Rechtslage am Ende ist kein Standardtext, also lesen Sie ihn, bevor Sie diesen Scraper auf größerem Volumen einsetzen.

Was Sie erstellen werden

Ein Python-Skript, das eine öffentliche Google Shopping-Such-URL entgegennimmt, das HTML über die Crawling API abruft und für jedes Produkt auf der Seite einen strukturierten Datensatz extrahiert. Wir verwenden die Abfrage "louis vuitton bags" als durchgängiges Beispiel und extrahieren diese Felder aus jedem Inserat:

• Title der Produktname wie im Inserat angezeigt.
• Price der angezeigte Preistext, als Kernsignal für das Preismonitoring nützlich.
• Seller der Händler oder Einzelhändler, der das Produkt anbietet.
• Rating die durchschnittliche Kundenbewertung, wenn eine angezeigt wird.
• Link die URL zur Google Shopping-Seite des Produkts.

Warum eine einfache Anfrage bei Google Shopping scheitert

Wenn Sie eine einfache HTTP-Anfrage von einem Skript an eine Google Shopping-URL senden, erhalten Sie selten die saubere Seite, die Sie in Ihrem eigenen Browser sehen. Zwei Dinge wirken gegen Sie. Erstens rendert Google einen Großteil des Shopping-Rasters mit JavaScript und passt das Zurückgegebene basierend auf der anfragenden IP und Region an, sodass eine ausländische Rechenzentrums-Adresse eine Consent-Seite, eine andere Währung oder teilweise Inhalte zurückbekommen kann. Zweitens überwacht Google automatisierten Traffic: Anfragen, die nicht wie ein echter Browser aussehen, werden herausgefordert, erhalten ein CAPTCHA oder werden blockiert, bevor sie die Inserate erreichen.

Ein funktionierender Google Shopping-Scraper benötigt also zwei Dinge in einer einzigen Anfrage: eine IP, die die Plattform als echten Besucher erkennt, und einen Browser, der die Seite rendert, wenn sie auf Skripte angewiesen ist. Sie können das selbst mit einem Headless-Browser und einem Pool rotierender residentieller Proxys zusammenstellen, aber die Pflege dieser Setups ist der größte Aufwand. Die Crawling API vereint beides in einem einzigen Aufruf: Sie senden die URL, sie ruft von einer vertrauenswürdigen residentiellen IP ab, rendert bei Bedarf und gibt fertiges HTML zum Parsen zurück.

Voraussetzungen

Bevor Sie Code schreiben, müssen einige Dinge vorhanden sein. Keines davon dauert lange.

Grundlegende Python-Kenntnisse. Sie sollten in der Lage sein, ein Python-Skript zu schreiben, auszuführen und Pakete mit pip zu installieren. Wenn BeautifulSoup neu für Sie ist, behandelt unsere Anleitung zur Verwendung von BeautifulSoup in Python die Parse-Grundlagen, die dieses Tutorial voraussetzt.

Python 3.8 oder höher. Bestätigen Sie Ihre Version mit python --version. Falls Sie es nicht haben, installieren Sie es von python.org oder über eine Distribution wie Anaconda.

Ein Crawlbase-Konto und ein Token. Registrieren Sie sich, öffnen Sie Ihr Dashboard und kopieren Sie Ihr Anfrage-Token. Crawlbase stellt zwei Token-Typen aus: ein normales Token für statische Seiten und ein JavaScript-Token für browser-gerenderte Seiten. Google Shopping funktioniert in den meisten Regionen mit dem normalen Token. Sie erhalten bis zu 20.000 kostenlose Anfragen: 1.000 bei der Anmeldung und mehr, während Sie die Onboarding-Schritte abschließen. Behandeln Sie das Token wie ein Passwort: Es authentifiziert Ihre Anfragen, halten Sie es also aus der Versionskontrolle heraus.

Projekt einrichten

Erstellen Sie eine virtuelle Umgebung, damit Projektabhängigkeiten isoliert bleiben, und installieren Sie dann die beiden Bibliotheken, die der Scraper benötigt.

python --version

python -m venv shopping_env
source shopping_env/bin/activate

pip install crawlbase beautifulsoup4

Unter Windows aktivieren Sie die Umgebung mit shopping_env\Scripts\activate statt der source-Zeile. Zwei Abhängigkeiten erledigen die Arbeit: crawlbase ist der offizielle Client, der die Anfrage an die Crawling API sendet und das gerenderte HTML zurückgibt, und beautifulsoup4 parst dieses HTML, damit Sie jedes Feld per CSS-Selektor extrahieren können.

Schritt 1: Die Seite über die Crawling API abrufen

Beginnen Sie damit, das HTML zu holen. Initialisieren Sie den CrawlingAPI-Client mit Ihrem Token und schreiben Sie dann eine kleine scrape_google_shopping()-Funktion, die Ihre Ziel-URL mit einem Satz von Optionen sendet, überprüft, ob die zugrunde liegende Seite mit einem 200-Status zurückgekommen ist, und das geparste HTML zurückgibt. Die Optionen legen das Land fest, setzen einen realistischen User-Agent und geben der Seite einige Sekunden zum Rendern, bevor das HTML erfasst wird.

from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup
import json

# Initialize CrawlingAPI with your access token
crawling_api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})

# Request options: pin the region, look like a real browser, let the page render
options = {
    "country": "US",
    "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36",
    "page_wait": 5000,
}

def fetch_html(url):
    response = crawling_api.get(url, options)
    if response["headers"]["cb_status"] != "200":
        print(f"Failed to fetch the page. Status: {response['headers']['cb_status']}")
        return None
    return response["body"].decode("utf-8")

if __name__ == "__main__":
    url = "https://www.google.com/search?q=louis+vuitton+bags&tbm=shop&num=20"
    html = fetch_html(url)
    if html:
        print(html[:500])

Der Client gibt eine Antwort zurück, deren headers["cb_status"] der Status ist, den Crawlbase beim Abrufen der Seite gesehen hat, daher bedeutet das Abfangen darauf, dass eine Blockierung oder Consent-Seite als klare Meldung auftaucht, statt den Parser mit Müll zu füttern. Die Such-URL trägt drei wichtige Dinge: q ist die Abfrage, tbm=shop schaltet Google in den Shopping-Modus und num=20 fordert zwanzig Ergebnisse pro Seite an. Führen Sie das Skript mit python shopping.py aus und Sie sollten echtes Shopping-Markup in den ersten 500 Zeichen sehen, was bestätigt, dass der Abruf funktioniert, bevor Sie einen einzigen Selektor schreiben.

Die Google Shopping-Ergebnisseite verstehen

Bevor Sie Selektoren schreiben, lohnt es sich zu wissen, wie die Ergebnisseite aufgebaut ist. Öffnen Sie eine Shopping-Suche in Ihrem Browser, klicken Sie mit der rechten Maustaste auf ein Produkt und wählen Sie Untersuchen, um die Struktur in den Entwicklertools zu sehen. Jedes Ergebnis besteht aus einigen beweglichen Teilen.

• Product listings. Jede Karte trägt einen Titel, ein Bild, einen Preis, einen Verkäufer- oder Einzelhändlernamen und eine Bewertung, wenn eine vorhanden ist. Das ist der Großteil dessen, was Sie scrapen.
• Pagination. Ergebnisse erstrecken sich über mehrere Seiten, die durch Ändern des start-Offsets in der URL erreicht werden.
• Filters and sorting. Preisbereich, Marken- und Kategoriefilter ändern, was die Seite zurückgibt, was wichtig ist, wenn Sie ein gezieltes Segment wollen.
• Sponsored listings. Einige Karten sind Anzeigen. Wenn Sie nur organische Inserate möchten, müssen Sie sie von gesponserten unterscheiden.

Schritt 2: Die Inserate mit BeautifulSoup parsen

Mit dem HTML laden Sie es in BeautifulSoup und extrahieren jedes Produkt anhand seines Selektors. Google umschließt jedes Raster-Ergebnis in einem .sh-dgr__grid-result-Container, und die einzelnen Felder befinden sich in verschachtelten Elementen darin. Überprüfen Sie die aktuellen Klassennamen in den Entwicklertools Ihres Browsers auf der Live-Seite; die folgenden Selektoren entsprechen dem Layout zum Zeitpunkt des Verfassens.

def parse_products(html):
    soup = BeautifulSoup(html, "html.parser")

    products = []
    for item in soup.select(".sh-dgr__grid-result"):
        title_el = item.select_one("h3.tAxDx")
        price_el = item.select_one("span.a8Pemb.OFFNJ")
        seller_el = item.select_one(".aULzUe.IuHnof")
        rating_el = item.select_one(".Rsc7Yb")
        link_el = item.select_one("a.Lq5OHe")

        products.append({
            "title": title_el.get_text(strip=True) if title_el else None,
            "price": price_el.get_text(strip=True) if price_el else None,
            "seller": seller_el.get_text(strip=True) if seller_el else None,
            "rating": rating_el.get_text(strip=True) if rating_el else None,
            "link": "https://www.google.com" + link_el["href"] if link_el else None,
        })

    return products

Jedes Feld wird aus seinem eigenen Selektor gelesen: h3.tAxDx enthält den Titel, span.a8Pemb.OFFNJ den Preis, .aULzUe.IuHnof den Verkäufer oder Einzelhändler, .Rsc7Yb die Bewertung, und der Anker a.Lq5OHe trägt den Produktlink. Das von Google gespeicherte href ist relativ, daher macht das Voranstellen von https://www.google.com daraus eine vollständige URL. Jedes Feld verwendet einen Guard, ... if el else None, sodass eine fehlende Bewertung oder ein fehlender Verkäufer None im Datensatz hinterlässt statt eine Ausnahme auszulösen und den gesamten Durchlauf zu beenden.

Schritt 3: Paginierung handhaben

Eine Seite mit zwanzig Produkten ist eine Demo; Preismonitoring benötigt den ganzen Satz. Google Shopping paginiert mit dem start-Query-Parameter, einem Offset in die Ergebnisse: start=0 ist die erste Seite, start=20 die zweite, start=40 die dritte und so weiter in Zwanzigerschritten. Die Form bleibt für jede Seite dieselbe, daher erstellen Sie jede URL, rufen sie über die Crawling API ab und parsen sie mit derselben Funktion. Die Dosierung der Schleife mit einer kurzen Pause zwischen Anfragen hält einen langen Durchlauf gesund.

import time

def scrape_multiple_pages(base_url, pages=3):
    all_products = []
    for page in range(pages):
        start_index = page * 20
        paginated_url = f"{base_url}&start={start_index}"
        html = fetch_html(paginated_url)
        if html:
            all_products.extend(parse_products(html))
        time.sleep(3)
    return all_products

Die Schleife multipliziert den Seitenindex mit zwanzig, um jeden start-Offset zu erhalten, hängt ihn an die Basis-URL an und sammelt die geparsten Produkte in einer flachen Liste. Das time.sleep(3) zwischen Seiten ist die nützlichste Gewohnheit für ein langes Crawling: Anfragen zu verteilen ist das, was Google dazu bringt, Sie als Käufer statt als Bot zu erkennen.

Schritt 4: Zusammenführen und JSON und CSV exportieren

Verbinden Sie nun den Abruf, das Parsen und die Paginierung in einem lauffähigen Skript und schreiben Sie die Ergebnisse sowohl in JSON als auch CSV. JSON behält die verschachtelte Struktur für Code, der sie verwendet; CSV lässt sich direkt in eine Tabellenkalkulation importieren, was das Format ist, das die meisten Preismonitoring-Workflows tatsächlich öffnen.

from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup
import json
import csv
import time

crawling_api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})

options = {
    "country": "US",
    "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36",
    "page_wait": 5000,
}

def fetch_html(url):
    response = crawling_api.get(url, options)
    if response["headers"]["cb_status"] != "200":
        print(f"Failed to fetch the page. Status: {response['headers']['cb_status']}")
        return None
    return response["body"].decode("utf-8")

def parse_products(html):
    soup = BeautifulSoup(html, "html.parser")
    products = []
    for item in soup.select(".sh-dgr__grid-result"):
        title_el = item.select_one("h3.tAxDx")
        price_el = item.select_one("span.a8Pemb.OFFNJ")
        seller_el = item.select_one(".aULzUe.IuHnof")
        rating_el = item.select_one(".Rsc7Yb")
        link_el = item.select_one("a.Lq5OHe")
        products.append({
            "title": title_el.get_text(strip=True) if title_el else None,
            "price": price_el.get_text(strip=True) if price_el else None,
            "seller": seller_el.get_text(strip=True) if seller_el else None,
            "rating": rating_el.get_text(strip=True) if rating_el else None,
            "link": "https://www.google.com" + link_el["href"] if link_el else None,
        })
    return products

def scrape_multiple_pages(base_url, pages=3):
    all_products = []
    for page in range(pages):
        paginated_url = f"{base_url}&start={page * 20}"
        html = fetch_html(paginated_url)
        if html:
            all_products.extend(parse_products(html))
        time.sleep(3)
    return all_products

def save_json(data, filename="products.json"):
    with open(filename, "w", encoding="utf-8") as f:
        json.dump(data, f, ensure_ascii=False, indent=4)

def save_csv(data, filename="products.csv"):
    if not data:
        return
    with open(filename, "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=data[0].keys())
        writer.writeheader()
        writer.writerows(data)

def main():
    base_url = "https://www.google.com/search?q=louis+vuitton+bags&tbm=shop&num=20"
    products = scrape_multiple_pages(base_url, pages=3)
    if products:
        save_json(products)
        save_csv(products)
        print(f"Saved {len(products)} products to products.json and products.csv")

if __name__ == "__main__":
    main()

Führen Sie das vollständige Skript mit python shopping.py aus. Es durchläuft drei Seiten der "louis vuitton bags"-Shopping-Ergebnisse, extrahiert für jedes Produkt einen Datensatz und schreibt alles in products.json und products.csv. Um ein anderes Produkt zu verfolgen, ändern Sie den q-Wert in base_url; der Rest der Pipeline verarbeitet alles, was zurückkommt. Führen Sie das Skript nach einem Zeitplan aus und vergleichen Sie die Preisspalte über alle Durchläufe und Sie haben den Kern eines Preismonitoring-Systems.

Wie die Ausgabe aussieht

Sie erhalten eine saubere Liste von Produktdatensätzen, jeder mit Titel, Preis, Verkäufer, Bewertung und Link, bereit zum Schreiben in JSON, CSV oder eine Datenbank.

[
    {
        "title": "Louis Vuitton Mini Pochette Accessoires Monogram",
        "price": "$760.00",
        "seller": "louisvuitton.com",
        "rating": "4.5",
        "link": "https://www.google.com/shopping/product/11460745201866483383"
    },
    {
        "title": "Louis Vuitton Onthego Empreinte PM Black",
        "price": "$3,568.00",
        "seller": "StockX",
        "rating": null,
        "link": "https://www.google.com/shopping/product/7199001631589324220"
    }
]

Die CSV-Entsprechung hat eine Zeile pro Produkt mit den Spalten title,price,seller,rating,link und einer Kopfzeile, sodass sie sich sauber in jedem Tabellenkalkulations-Tool öffnet. Ein fehlendes Feld erscheint als leere Zelle in CSV und null in JSON, was die Bewertung des zweiten Inserats im obigen Beispiel zeigt.

Im großen Maßstab unblockiert bleiben

Selbst wenn eine vertrauenswürdige IP für Sie übernommen wird, überwacht Google Scraper-artigen Traffic, und Shopping ist keine Ausnahme. Einige Gewohnheiten halten einen Durchlauf gesund.

• Dosieren Sie Ihre Anfragen. Ergebnisseiten in einer engen Schleife zu bombardieren ist der schnellste Weg, herausgefordert zu werden. Das time.sleep zwischen Seiten ist aus einem guten Grund dort; behalten Sie es bei und variieren Sie Ihre Abfragen statt einen Begriff mit voller Geschwindigkeit zu durchblättern.
• Setzen Sie auf Rotation. Ein Pool residentieller IPs verteilt Anfragen auf viele echte Nutzeradressen, sodass keine einzelne ein Limit auslöst. Die Crawling API übernimmt das für Sie; wenn Sie Ihren eigenen Stack aufbauen, ist das der Teil, den Sie richtig machen müssen.
• Legen Sie das richtige Land fest. Preise und Verkäufer unterscheiden sich je nach Region. Setzen Sie die country-Option auf den Markt, den Sie überwachen, damit die Daten dem entsprechen, was ein lokaler Käufer sieht.
• Überprüfen Sie die Selektoren, wenn Felder leer werden. Google ändert sein Markup regelmäßig. Wenn ein Feld nicht mehr geparst wird, öffnen Sie eine Live-Seite in den Entwicklertools und aktualisieren Sie den Selektor.

Das breitere Playbook finden Sie unter Wie Sie Websites scrapen, ohne blockiert zu werden. Wenn Sie das in einen wiederkehrenden Preistracking-Job einbauen, behandelt unser Leitfaden zum Web-Scraping für Preisintelligenz, wie Sie aus rohen Inseraten ein nutzbares Signal machen, und der übergeordnete Leitfaden zum E-Commerce-Web-Scraping erweitert denselben Ansatz auf andere Stores. Um reguläre Google-Suchergebnisse statt des Shopping-Tabs zu scrapen, lesen Sie Wie man Google-Suchergebnisseiten scrapt.

Ist es legal, Google Shopping zu scrapen?

Ob das Scrapen von Google Shopping erlaubt ist, hängt von Googles Nutzungsbedingungen, Ihrer Gerichtsbarkeit und dem ab, was Sie mit den Daten tun. Googles Bedingungen schränken den automatisierten Zugriff ein, sodass Scraping unabhängig von der Sorgfalt Ihres Vorgehens gegen diese Bedingungen verstoßen kann. Keiner der hier enthaltenen Code ändert das; er macht nur den technischen Teil funktionieren. Lesen Sie Googles Bedingungen und seine robots.txt und betrachten Sie beide als Grenze für das, was Sie erfassen.

Einige Leitlinien, an denen es sich lohnt festzuhalten. Erfassen Sie nur öffentliche Insertdaten: Produkttitel, Preise, Verkäufer, Bewertungen und Links, die jeder auf einer Shopping-Ergebnisseite ohne Konto sehen kann. Halten Sie Ihr Anfragevolumen niedrig genug, dass Sie Googles Server nicht belasten, dosieren Sie Ihr Crawling statt es mit voller Geschwindigkeit zu betreiben und legen Sie das Land auf den Markt fest, den Sie tatsächlich benötigen. Veröffentlichen Sie keine Produktbilder oder urheberrechtlich geschützten Medien von Google massenweise und bleiben Sie von allem hinter einem Login oder personenbezogenen Daten fern, was dieses Tutorial nicht berührt.

Wenn Sie Shopping-Daten in einem Umfang oder in einer Form benötigen, die öffentliches Scraping nicht vertretbar unterstützen kann, bietet Google offizielle Wege. Die Content API for Shopping und die Händler- und Anzeigen-APIs sind die sanktionierten Wege, um Produktdaten programmatisch zu verwalten und zu lesen, und eine offizielle Vereinbarung ist der richtige Weg, wenn ein Projekt über bescheidene, öffentliche, gut dosierte Sammlung hinauswächst. Ein ausgefeilterer Scraper ist kein Ersatz für eine Datenvereinbarung.

Häufig gestellte Fragen

Warum schlägt eine einfache Anfrage fehl oder gibt die falsche Seite bei Google Shopping zurück?

Google rendert einen Großteil des Shopping-Rasters mit JavaScript und passt das Zurückgegebene basierend auf der anfragenden IP und Region an, sodass ein Aufruf von einer ausländischen Rechenzentrums-Adresse eine Consent-Seite, die falsche Währung oder teilweise Inhalte statt der Inserate zurückbekommen kann, die Sie in Ihrem eigenen Browser sehen. Es markiert auch Traffic, der nicht wie ein echter Browser aussieht. Das Abrufen über die Crawling API, die rotierende residentielle IPs verwendet und die Seite rendert, lässt die Anfrage wie ein gewöhnlicher Käufer aussehen, sodass Sie die echten Ergebnisse erhalten.

Welche Felder kann ich aus Google Shopping extrahieren?

Dieses Tutorial extrahiert fünf Felder aus jeder Produktkarte: Titel, Preis, Verkäufer oder Einzelhändler, Bewertung wenn eine angezeigt wird und den Link zur Shopping-Seite des Produkts. Sie können den Parser erweitern, um Bilder oder Versandtext durch Hinzufügen weiterer Selektoren zu erfassen. Bleiben Sie bei öffentlichen Insertdaten und vermeiden Sie alles hinter einem Login.

Wie handhabe ich die Paginierung bei Google Shopping?

Verwenden Sie den start-Query-Parameter, einen Offset in die Ergebnisse: start=0 ist die erste Seite, start=20 die zweite, start=40 die dritte und so weiter in Zwanzigerschritten. Erstellen Sie jede Seiten-URL mit dem Offset, rufen Sie sie über die Crawling API ab, parsen Sie sie mit derselben Funktion und warten Sie einige Sekunden zwischen Anfragen, damit Sie das Crawling dosieren statt es zu überbeanspruchen.

Kann ich das für Preismonitoring verwenden?

Ja, das ist der Hauptanwendungsfall. Führen Sie das Skript nach einem Zeitplan aus, exportieren Sie die Ergebnisse in CSV und vergleichen Sie die Preisspalte über alle Durchläufe, um Erhöhungen, Senkungen und neue Verkäufer für die von Ihnen verfolgten Produkte zu erkennen. Das Festlegen der country-Option hält Preise vergleichbar mit dem Markt, den Sie interessiert. Unser Leitfaden zum Web-Scraping für Preisintelligenz geht tiefer darauf ein, wie man aus den Rohdaten ein Signal macht.

Meine Selektoren geben nichts zurück. Was hat sich geändert?

Fast sicher Googles Markup. Klassennamen wie tAxDx und a8Pemb werden generiert und ändern sich, wenn Google sein Frontend neu deployt, sodass Selektoren, die letzten Monat funktionierten, kaputt gehen können. Überprüfen Sie eine Live-Shopping-Seite in den Entwicklertools Ihres Browsers und aktualisieren Sie die Selektoren. Regelmäßige Selektor-Wartung ist bei jedem Produktions-Scraper normal.

Hat Google Shopping eine offizielle API?

Ja. Google bietet die Content API for Shopping zusammen mit Händler- und Anzeigen-APIs an, die Entwicklern ermöglichen, Produktinserate, Werbekampagnen und Leistungsdaten programmatisch zu verwalten. Wenn Ihr Projekt Shopping-Daten im großen Maßstab oder in sanktionierter Form benötigt, sind diese offiziellen Endpunkte der richtige Weg statt öffentlichem Scraping.

HR

Hassan Rehan

Softwareentwickler · Crawlbase

Softwareentwickler bei Crawlbase, der praxisnahe Anleitungen zu rotierenden Proxys, Scraping und den praktischen Details schreibt, Proxys in echten Code einzubinden.