Google-Suchergebnisse mit Python scrapenein fokussiertes, lauffähiges Tutorial

Google verarbeitet täglich Milliarden von Suchanfragen, und die Ergebnisseite hinter jeder Abfrage ist ein strukturierter Schnappschuss dessen, was für einen Begriff rankt: die organischen Titel, die Links, auf die sie verweisen, und der Snippet-Text unter jedem Eintrag. Das macht die öffentliche Google SERP zu einem nützlichen Signal für Keyword-Recherche, Rank-Tracking und Wettbewerbsanalyse. Die Daten sind auf der Ergebnisseite sichtbar; die Herausforderung besteht darin, zuverlässig darauf zuzugreifen.

Dies ist die fokussierte, lauffähige Version dieser Aufgabe. Sie richten Python ein, rufen eine gerenderte Google-Ergebnisseite über die Crawling API ab, parsen jedes organische Ergebnis in Titel, Link und Snippet, navigieren durch tiefere Ergebnisse und exportieren in JSON und CSV. Der Walkthrough beschränkt sich auf öffentliche Suchergebnisdaten, die jeder ohne Konto einsehen kann. Den breiteren Tour der SERP-Struktur, mehrere Ansätze und Skalierung finden Sie im übergeordneten Artikel Wie man Google-Suchergebnisseiten scrapt; dieser Beitrag konzentriert sich und liefert einen funktionierenden Scraper.

Was Sie erstellen werden

Ein Python-Skript, das eine Suchanfrage entgegennimmt, die gerenderte Google-Ergebnisseite über die Crawling API abruft und einen sauberen Datensatz für jedes organische Ergebnis auf der Seite zurückgibt. Wir verwenden eine Beispielabfrage als durchgängiges Beispiel und extrahieren diese Felder aus jedem Ergebnis:

• Position der Rang des Ergebnisses auf der Seite, von oben gezählt.
• Title der Überschriftentext des Ergebnisses, wie im Inserat angezeigt.
• Link die Ziel-URL, auf die das Ergebnis verweist.
• Snippet die angezeigte Beschreibung oder Zusammenfassung unter dem Titel.
• Related searches die vorgeschlagenen Folgeanfragen, die Google am Seitenende auflistet.

Warum eine einfache Anfrage bei Google scheitert

Senden Sie eine einfache HTTP-Anfrage von einem Skript an google.com/search und Sie erhalten fast nie die Seite, die Sie in Ihrem eigenen Browser sehen. Zwei Dinge wirken gegen Sie. Erstens setzt Google nun JavaScript ein, um die Ergebnisseite zu rendern: Ab 2025 erfordert die SERP aktivierte Skripte, sodass ein einfacher Abruf, der kein JavaScript ausführt, eine leere Hülle statt der Inserate zurückgibt. Zweitens überwacht Google automatisierten Traffic. Zu viele Anfragen von einer IP, zu schnelle Anfragen oder Anfragen, die nicht wie ein echter Browser aussehen, werden mit einem CAPTCHA, einem Rate-Limit oder einer Blockierung beantwortet.

Ein funktionierender Google-Scraper benötigt also zwei Dinge in einer einzigen Anfrage: eine IP, die die Suchmaschine als gewöhnlichen Besucher erkennt, und einen Browser, der die Seite rendert. Sie können das selbst mit einem Headless-Browser und einem Pool rotierender residentieller Proxys zusammenstellen, aber die Pflege dieser Flotte gesund zu halten ist der größte Aufwand. Die Crawling API vereint beides in einem einzigen Aufruf. Sie wird auch mit einem eingebauten google-serp-Scraper geliefert, der die gerenderte Seite von einer vertrauenswürdigen rotierenden IP abruft und die organischen Ergebnisse bereits in JSON geparst zurückgibt, sodass Sie das Schreiben von spröden Selektoren gegen Googles sich häufig änderndes Markup überspringen können.

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 Sie generell neu beim Scrapen sind, behandelt unser Leitfaden zum Scrapen von Websites mit Python die 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. Jeder Editor funktioniert; VS Code, PyCharm und Jupyter sind alle für dieses Projekt geeignet.

Ein Crawlbase-Konto und ein Token. Registrieren Sie sich, öffnen Sie Ihr Dashboard und kopieren Sie Ihr Anfrage-Token. Sie erhalten bis zu 20.000 kostenlose Anfragen, keine Kreditkarte erforderlich, und der eingebaute google-serp-Scraper funktioniert mit dem normalen Token. 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 Crawlbase Python-Bibliothek, die die Crawling API in einem kleinen Client kapselt.

python --version

python -m venv google_env
source google_env/bin/activate

pip install crawlbase

Unter Windows aktivieren Sie die Umgebung mit google_env\Scripts\activate statt der source-Zeile. Das crawlbase-Paket gibt Ihnen einen CrawlingAPI-Client, sodass Sie die Anfrage-URL nicht von Hand aufbauen müssen. Da der google-serp-Scraper geparste JSON zurückgibt, benötigen Sie in diesem Tutorial nicht einmal eine HTML-Parsing-Bibliothek für die organischen Ergebnisse.

Schritt 1: Die gerenderte SERP über die Crawling API abrufen

Beginnen Sie damit, die Daten zu holen. Schreiben Sie eine kleine scrape_google_results()-Funktion, die die Such-URL aufbaut, sie mit aktiviertem google-serp-Scraper an die Crawling API sendet, den Status überprüft und den geparsten Body zurückgibt. Google paginiert in Zehnergruppen, daher nimmt die Funktion eine Seitenzahl und übersetzt sie in den start-Offset, den Google in der URL erwartet.

import json
from urllib.parse import quote_plus
from crawlbase import CrawlingAPI

# Replace with your token from the Crawlbase dashboard
crawling_api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})

def scrape_google_results(query, page=0):
    encoded = quote_plus(query)
    url = f"https://www.google.com/search?q={encoded}&start={page * 10}"
    options = {"scraper": "google-serp"}
    response = crawling_api.get(url, options)

    if response["headers"]["cb_status"] == "200":
        data = json.loads(response["body"].decode("latin1"))
        return data.get("body", {})

    print(f"Failed to fetch results for '{query}' (page {page}).")
    return {}

if __name__ == "__main__":
    results = scrape_google_results("web scraping tools", page=0)
    print(json.dumps(results.get("searchResults", [])[:2], indent=2))

Das options-Dict ist der eigentliche Trick: Das Übergeben von {"scraper": "google-serp"} weist die Crawling API an, die Seite zu rendern, die Bot-Checks zu umgehen und die geparste SERP zurückzugeben. Der Client gibt eine Antwort zurück, deren headers["cb_status"] Crawlbase's eigener Status für den Crawl ist, daher verhindert das Abfangen auf "200" vor dem Parsen, dass eine Blockierung oder ein fehlgeschlagenes Rendering still durchgeht. Der Body kommt als Bytes zurück, die Sie mit latin1 dekodieren und als JSON laden und dann die geparste SERP aus ihrem body-Schlüssel lesen. Führen Sie das Skript aus und Sie sollten die ersten zwei organischen Ergebnisse als JSON ausgegeben sehen, was bestätigt, dass Abruf und Parse funktionieren, bevor Sie etwas darauf aufbauen.

Schritt 2: Organische Ergebnisse in saubere Datensätze parsen

Der google-serp-Scraper gibt die SERP bereits strukturiert zurück, daher besteht das Parsen darin, die gewünschten Felder zu lesen statt CSS-Selektoren zu schreiben. Die organischen Inserate befinden sich unter dem searchResults-Schlüssel, jedes mit seiner position, seinem title, seiner url und seiner description. Die Seite gibt Ihnen auch relatedSearches, und der Scraper zeigt ads, peopleAlsoAsk und ein lokales snackPack, wenn die Abfrage sie auslöst. Schreiben Sie eine kleine Funktion, die die gewünschten Felder auswählt und den Snippet-Feldnamen normalisiert.

def parse_results(serp):
    organic = []
    for item in serp.get("searchResults", []):
        organic.append({
            "position": item.get("position"),
            "title": item.get("title"),
            "link": item.get("url"),
            "snippet": item.get("description"),
        })

    related = [r.get("title") for r in serp.get("relatedSearches", [])]

    return {"organic": organic, "relatedSearches": related}

Das behält die vier Felder, die die meisten Rank-Tracking- und Recherche-Jobs benötigen: die position direkt von Google, den title, den Ziel-link (aus dem url-Feld des Ergebnisses gelesen) und das snippet (aus description gelesen). Das gleichzeitige Extrahieren von relatedSearches gibt Ihnen die vorgeschlagenen Folgeanfragen kostenlos dazu, was für die Keyword-Erweiterung praktisch ist. Da der Scraper die Feldextraktion übernimmt, sind Sie von Googles Markup-Änderungen abgeschirmt; Sie berühren nur diese stabilen JSON-Schlüssel.

Schritt 3: Paginierung handhaben

Eine Seite ist eine Demo; ein echter Job geht tiefer in die Ergebnisse. Google paginiert in Zehnergruppen über den start-Parameter, daher ist Seite zwei start=10, Seite drei start=20 usw., was die Seite-zu-Offset-Mathematik in scrape_google_results bereits übernimmt. Durchlaufen Sie einen Seitenbereich, hören Sie früh auf, wenn eine Seite leer zurückkommt, und sammeln Sie alle organischen Datensätze in einer Liste. Die Dosierung der Schleife mit einem kurzen Sleep hält einen langen Durchlauf gesund.

import time

def scrape_all_pages(query, max_pages=3):
    all_organic = []
    for page in range(max_pages):
        print(f"Scraping page {page + 1}...")
        serp = scrape_google_results(query, page)
        parsed = parse_results(serp)

        if not parsed["organic"]:
            print("No more results, stopping.")
            break

        all_organic.extend(parsed["organic"])
        time.sleep(2)

    return all_organic

Die Schleife läuft von Seite 0 bis max_pages, ruft jede Seite ab, parst sie und erweitert die laufende Liste. Das if not parsed["organic"]: break-Guard stoppt in dem Moment, in dem eine Seite keine organischen Ergebnisse hat, damit Sie nicht weiterhin für leere Seiten nach dem Ende der Inserate zahlen. Das time.sleep(2) zwischen Seiten verteilt die Anfragen statt sie in einer engen Schleife abzufeuern, was die beste einzelne Gewohnheit ist, um über einen langen Durchlauf unblockiert zu bleiben.

Schritt 4: Das vollständige Skript zusammenstellen und exportieren

Verbinden Sie nun den Abruf, das Parsen und die Paginierung in einem lauffähigen Skript und schreiben Sie die Ausgabe sowohl in JSON als auch CSV. JSON behält die vollständige verschachtelte Form; CSV gibt Ihnen eine flache Tabelle, die Sie in einer Tabellenkalkulation für schnelle Rang-Überprüfungen öffnen können.

import csv
import json
import time
from urllib.parse import quote_plus
from crawlbase import CrawlingAPI

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

def scrape_google_results(query, page=0):
    encoded = quote_plus(query)
    url = f"https://www.google.com/search?q={encoded}&start={page * 10}"
    options = {"scraper": "google-serp"}
    response = crawling_api.get(url, options)
    if response["headers"]["cb_status"] == "200":
        data = json.loads(response["body"].decode("latin1"))
        return data.get("body", {})
    print(f"Failed to fetch results for '{query}' (page {page}).")
    return {}

def parse_results(serp):
    organic = []
    for item in serp.get("searchResults", []):
        organic.append({
            "position": item.get("position"),
            "title": item.get("title"),
            "link": item.get("url"),
            "snippet": item.get("description"),
        })
    return organic

def scrape_all_pages(query, max_pages=3):
    all_organic = []
    for page in range(max_pages):
        print(f"Scraping page {page + 1}...")
        organic = parse_results(scrape_google_results(query, page))
        if not organic:
            print("No more results, stopping.")
            break
        all_organic.extend(organic)
        time.sleep(2)
    return all_organic

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

def save_csv(rows, filename):
    fields = ["position", "title", "link", "snippet"]
    with open(filename, "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=fields)
        writer.writeheader()
        writer.writerows(rows)

if __name__ == "__main__":
    query = "web scraping tools"
    rows = scrape_all_pages(query, max_pages=2)
    save_json(rows, "google_results.json")
    save_csv(rows, "google_results.csv")
    print(f"Saved {len(rows)} results to JSON and CSV")

Führen Sie es mit python main.py aus. Es scrapt zwei Seiten für "web scraping tools", flacht jedes organische Ergebnis in eine Liste, und schreibt sowohl google_results.json als auch google_results.csv. Um einen anderen Begriff zu scrapen, ändern Sie den query-String; um tiefer zu gehen, erhöhen Sie max_pages. Das Setzen von ensure_ascii=False hält nicht-lateinische Titel in der JSON-Datei lesbar statt sie in \u-Sequenzen zu escapen.

Wie die Ausgabe aussieht

Die JSON-Datei ist eine geordnete Liste organischer Datensätze, jeder mit seiner Position, seinem Titel, Link und Snippet, bereit für eine Datenbank oder ein Rank-Tracking-Blatt.

[
  {
    "position": 1,
    "title": "Web Scraper - The #1 web scraping extension",
    "link": "https://webscraper.io/",
    "snippet": "The most popular web scraping extension. Start scraping in minutes."
  },
  {
    "position": 2,
    "title": "ParseHub | Free web scraping - The most powerful web scraper",
    "link": "https://www.parsehub.com/",
    "snippet": "ParseHub is a free web scraping tool. Turn any site into a spreadsheet or API."
  }
]

Die CSV enthält dieselben Datensätze als flache Tabelle mit einer Zeile pro Ergebnis und den Spalten position, title, link und snippet, was das Format ist, das die meisten tabellenkalkulationsbasierenden Rank-Trackings erwarten.

Über Abfragen skalieren und unblockiert bleiben

Das obige Skript scrapt eine Abfrage über einige Seiten. Ein Produktions-Job führt in der Regel viele Abfragen aus und kann sie über die Zeit verfolgen, aber die Form ändert sich nicht: Durchlaufen Sie Ihre Abfrageliste, rufen Sie scrape_all_pages für jede auf und versehen Sie jeden Datensatz mit der Abfrage, aus der er stammt, bevor Sie speichern. Die Crawling API übernimmt das Rendering und die IP-Rotation pro Anfrage, daher geht es beim Skalieren hauptsächlich darum, sich selbst zu dosieren und den Status zu überwachen. Einige Gewohnheiten halten einen langen Durchlauf gesund.

• Dosieren Sie Ihre Anfragen. Halten Sie das Sleep zwischen Seiten und Abfragen statt in einer engen Schleife zu feuern. Das Verteilen des Traffics ist die beste einzelne Verteidigung gegen Herausforderungen.
• Lesen Sie den Status. Beobachten Sie den cb_status bei jeder Antwort. Ein Durchlauf, der anfängt zu scheitern, signalisiert Ihnen zum Zurückziehen, kein Rauschen zum Ignorieren.
• Bei vorübergehenden Fehlern wiederholen. Jede 5XX der API ist kostenlos, daher kostet das Wiederholen eines fehlgeschlagenen Crawls nichts; ein kurzes Backoff vor dem Wiederholen löst es meist.
• Setzen Sie auf Rotation. Die eingebaute residentielle Rotation verteilt Anfragen auf viele echte Nutzeradressen. Wenn Sie Ihren eigenen Traffic lieber leiten möchten, bietet der Smart AI Proxy dieselbe Rotation als Drop-in-Endpunkt.

Das breitere Playbook finden Sie unter Wie Sie Websites scrapen, ohne blockiert zu werden. Wenn Sie auch die Fragefelder extrahieren möchten, die Google mitten auf der Seite zeigt, behandelt unser Fokus-Leitfaden zum Scrapen von Googles "People Also Ask" speziell diesen Block.

Ist es legal, Google-Suchergebnisse zu scrapen?

Ob das Scrapen von Google 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 Suchergebnisdaten: Titel, Links, Snippets und Positionen, die jeder auf einer Ergebnisseite ohne Konto sehen kann. Halten Sie Ihr Anfragevolumen bescheiden, damit Sie Googles Server nicht belasten, und dosieren Sie Ihr Crawling statt es mit voller Geschwindigkeit zu betreiben. Scrapen Sie keine personenbezogenen Daten, greifen Sie nicht auf Inhalte hinter einem Login zu und verteilen Sie kein urheberrechtlich geschütztes Medienmaterial, das Sie über die Ergebnislinks erreichen. Das sind die Leitlinien, die die Arbeit vertretbar halten.

Wenn Ihr Projekt sanktionierten Hochvolumenzugriff benötigt, bietet Google offizielle Produkte dafür an, einschließlich der Custom Search JSON API und der programmatischen Suche über Google Cloud, was der richtige Weg für diesen Maßstab ist statt eines ausgefeilteren Scrapers. Diese Anleitung beschränkt sich bewusst auf öffentliche SERP-Seiten, weil das die Linie ist, die die Arbeit sauber hält. Weitere Informationen zu den spezifischen Hindernissen, die Google Scrapers in den Weg legt, und wie man damit verantwortungsvoll umgeht, finden Sie in unserem Artikel zu den Herausforderungen beim Scrapen von Google-Suchergebnissen.

Häufig gestellte Fragen

Warum gibt eine einfache Anfrage eine leere Seite von Google zurück?

Ab 2025 erfordert Googles Ergebnisseite JavaScript zum Rendern, sodass eine einfache HTTP-Anfrage, die keine Skripte ausführt, als leere oder skelettartige Hülle zurückkommt. Google blockiert auch Traffic, der automatisiert aussieht. Das Abrufen über die Crawling API mit dem google-serp-Scraper rendert die Seite von einer vertrauenswürdigen rotierenden IP und gibt die Inserate als geparste JSON zurück, sodass Sie echte Ergebnisse statt einer leeren Seite erhalten.

Kann ich Google-Suchergebnisse mit Python scrapen?

Ja. Mit der Crawlbase Python-Bibliothek rufen Sie die Crawling API auf, aktivieren den eingebauten google-serp-Scraper und lesen Titel, Links, Snippets und Positionen direkt aus dem zurückgegebenen JSON. Die API fungiert als Brücke, die Ihre Anfrage von einer vertrauenswürdigen IP mit gerenderter Seite an Google sendet, sodass Anfragen reibungslos verarbeitet statt blockiert werden. Eine breitere Übersicht über die SERP und andere Ansätze finden Sie im übergeordneten Leitfaden zum Scrapen von Google-Suchergebnisseiten.

Wie unterscheidet sich dieser Artikel vom breiteren Google-Scraping-Leitfaden?

Dieser Beitrag ist das fokussierte, lauffähige Python-Tutorial: Einrichten, Abrufen, Parsen organischer Ergebnisse, Paginieren und Exportieren, mit kopierfähigem Code. Der übergeordnete Artikel Wie man Google-Suchergebnisseiten scrapt behandelt die vollständige SERP-Struktur (Anzeigen, "People Also Ask", Knowledge Panel, lokales Paket), mehrere Ansätze und Skalierungsstrategie. Beginnen Sie hier, wenn Sie sofort Code wollen; lesen Sie den übergeordneten Artikel für die breitere Übersicht.

Wie paginiere ich durch mehr Google-Ergebnisse?

Google paginiert in Zehnergruppen über den start-Query-Parameter: Seite zwei ist start=10, Seite drei ist start=20 usw. Die scrape_google_results-Funktion wandelt eine Seitenzahl in diesen Offset um, und scrape_all_pages durchläuft einen Seitenbereich und stoppt, wenn eine Seite keine organischen Ergebnisse zurückgibt. Halten Sie ein kurzes Sleep zwischen Seiten, um das Crawling zu dosieren.

Muss ich JavaScript selbst verarbeiten, wenn ich Google scrapt?

Nein. Googles SERP benötigt JavaScript zum Rendern, aber der google-serp-Scraper rendert die Seite für Sie serverseitig, sodass Sie keinen Headless-Browser betreiben oder eine Render-Flotte verwalten müssen. Sie senden die Such-URL mit aktiviertem Scraper und erhalten vollständig gerenderte, geparste Ergebnisse zurück.

Wie speichere ich die gescrapten Google-Ergebnisse?

Jedes strukturierte Format funktioniert. Das vollständige Skript in dieser Anleitung schreibt sowohl eine JSON-Datei, die die verschachtelte Form behält, als auch eine CSV-Datei, die Ihnen eine flache Tabelle mit Position, Titel, Link und Snippet für Tabellenkalkulationen gibt. Von dort aus können Sie die Datensätze in eine Datenbank oder eine Rank-Tracking-Pipeline laden. Bleiben Sie bei öffentlichen Suchergebnisdaten und vermeiden Sie alles hinter einem Login.

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.