Direkte AntwortUm Google AI Mode im Jahr 2026 zu scrapen, sollten Sie Browserautomatisierung vermeiden und es stattdessen als Problem der Extraktion strukturierter Daten behandeln. Erstellen Sie eine Google-Such-URL mit dem Parameter udm=50 (AI-Modus) und senden Sie diese an die Crawlbase Crawling API Verwenden Sie ein reguläres Token mit dem Format „json“, optional mit dem Parameter „scraper=google-serp“, und parsen und normalisieren Sie die Antwort anschließend in stabile Felder wie „response_text“, „citations“ und „links“. Dieser Ansatz liefert zuverlässige, maschinenlesbare Ergebnisse, ohne dass Sie Headless-Browser, Proxys oder die Verarbeitung auf Benutzeroberflächenebene verwalten müssen.

Googles KI-Modus verändert die Darstellung von Suchergebnissen. Anstatt eine Liste von Links anzuzeigen, generiert er eine direkte Antwort, die durch mehrere Quellen gestützt wird und Zusammenfassungen mit Zitaten und verwandten Inhalten kombiniert.

Für Entwickler und SEO-Teams eröffnet dies eine ganz neue Art von Datensatz. Man sammelt nicht mehr nur Rankings, sondern tatsächliche Antworten auf Suchanfragen sowie die dazugehörigen Quellen.

Diese Anleitung führt Sie durch die Einrichtung einer Python-Pipeline mit Crawlbase Crawling API Ergebnisse des KI-Modus abrufen, analysieren und in JSON organisieren, das Sie speichern, vergleichen und in Analyse- oder Content-Workflows einbinden können.

Eine vollständige, produktionsreife Implementierung finden Sie im Projekt-Repository auf ScraperHub: ScraperHub/how-to-scrape-google-ai-mode-in-2026

Gehe zu:

Wie der Google AI-Modus beim Web Scraping funktioniert

Googles KI-Modus ist für echte Nutzer konzipiert, nicht für Web-Scraper. Die Benutzeroberfläche ist dynamisch: Inhalte werden schrittweise geladen und ändern sich je nach Interaktion. Der Versuch, Daten direkt über die Benutzeroberfläche zu extrahieren, erweist sich schnell als unzuverlässig.

Für das Scraping ist es stabiler, sich auf zwei Dinge zu konzentrieren: die URL, die den KI-Modus auslöst und der Daten, die im Hintergrund zurückgegeben werdenStatt sich mit Layoutänderungen oder Timing-Problemen auseinandersetzen zu müssen, arbeiten Sie mit einer vorhersehbaren Anfrage und einer strukturierten Antwort.

In dieser Anleitung wird das Beispielprojekt erstellt Google AI-Modus URLs verwenden udm=50, zusammen mit Standardparametern wie q, gl und hlund optional uule für standortbezogenes Targeting. Die Implementierung ist einfach, wie unten dargestellt.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
"Erstelle Google-Such-URLs für den KI-Modus (udm=50).""

ab __Zukunft__ importieren Anmerkungen

ab urllib.parse importieren quote_plus, urlencode


def build_google_ai_mode_search_url(
    Abfrage: str,
    *,
    gl: str = "uns",
    hl: str = "en",
    uule: str | Keine Präsentation = Keine Präsentation,
) -> str:
    "" "
    Gibt eine https://www.google.com/search-URL zurück, die den KI-Modus öffnet.

    ``uule`` ist ein optionaler kodierter Standort (siehe Googles uule-Parameter).
    "" "
    if kein Frontalunterricht. query or kein Frontalunterricht. query.strip():
        erhöhen WertFehler("Die Abfrage darf nicht leer sein.")
    Parameter: Liste[Tupel[str, str]] = [
        ("udm", "50"),
        ("Q", query.strip()),
        ("gl", gl),
        ("hl", hl),
    ]
    if uule:
        params.append(("uule", uule))
    qs = urlencode(params, quote_via=quote_plus, safe="")
    Rückkehr f"https://www.google.com/search?{qs}"

Quelle: google_ai_mode/google_ai_mode_url.py

Diese Funktion dient als Einstiegspunkt der Pipeline. Sie übergeben eine Abfrage und erhalten im Gegenzug eine konsistente AI-Mode-URL. Der restliche Workflow ist dann unkompliziert: Senden Sie die Anfrage über CrawlbaseNormalisieren Sie anschließend die Antwort in strukturierte Daten, die Ihr System verwenden kann.

Warum Sie das Scraping der Google AI Mode-Benutzeroberfläche vermeiden sollten

Man kann den AI-Modus durch die Automatisierung eines Browsers auslesen, aber das hat seinen Preis.

Sobald man diesen Weg einschlägt, muss man mit Darstellungsverzögerungen, Timing-Problemen und Selektoren klarkommen, die bei jedem Google-Update der Benutzeroberfläche nicht mehr funktionieren. Hinzu kommen die Bot-Erkennung und der Aufwand für den Betrieb und die Wartung zahlreicher Browserinstanzen.

Für kleine Setups funktioniert es, aber mit zunehmender Größe wird es anfällig und teuer.

Ein JSON-basierter Ansatz vereinfacht den gesamten Ablauf. Anstatt Benutzerinteraktionen nachzubilden, wird dieser reduziert auf:

Anfrage → Antwort → Analyse

Keine Browserschicht, keine UI-Abhängigkeiten, mit deutlich weniger Fehlerquellen.

Wie Crawlbase Hilft Ihnen beim Scrapen des Google-KI-Modus

Crawlbase Sie ist für die Datenerfassung zuständig. Es geht nicht nur um das Weiterleiten von Anfragen. Sie kümmert sich um das Abrufen der Seite, die Behandlung von Blockierungen und die Rückgabe einer strukturierten Antwort, mit der Sie weiterarbeiten können.

In dieser Konfiguration bleibt der HTTP-Client bewusst einfach. Sie senden eine GET-Anfrage an https://api.crawlbase.com/ mit wenigen Parametern: token, url und format=json. Sie können auch einbeziehen scraper=google-serp wenn du willst Crawlbase bewerben seitenbezogenes ParsenDie Beispiel-CLI verwendet dies standardmäßig, sofern Sie es nicht deaktivieren.

Die Implementierung aus dem Beispielprojekt sieht folgendermaßen aus:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
"""Minimal Crawlbase Crawling API Kunde.""
ab __Zukunft__ importieren Anmerkungen
ab Eingabe importieren Jedes
importieren Zugriffe
CRAWLBASE_API = "https://api.crawlbase.com/"

def fetch_crawlbase_json(
    Ziel-URL: str,
    *,
    Zeichen: str,
    Schaber: str | Keine Präsentation = Keine Präsentation,
    Antwortformat: str = "json",
    Auszeit: schweben = 90.0,
    zusätzliche Parameter: diktieren[str, Jedes] | Keine Präsentation = Keine Präsentation,
) -> diktieren[str, Jedes]:
    "" "
    STARTE Crawling API mit ``format=json``.
    Gibt das geparste JSON der obersten Ebene zurück (``original_status``, ``pc_status``, ``url``, ``body``, ...).
    "" "
    Parameter: diktieren[str, Jedes] = {
        "Zeichen": Token,
        "URL": target_url,
        "Format": Antwortformat,
    }
    if Schaber is kein Frontalunterricht. Keine Präsentation , Scraper != "":
        params["Schaber"] = Schaber
    if zusätzliche Parameter:
        für  k, v in extra_params.items():
            if v is Keine Präsentation:
                fortsetzen
            params[k] = "True" if v is richtig sonst ("False" if v is falsch sonst v)
    Header = {"Accept-Encoding": "gzip, deflate"}
    resp = requests.get(CRAWLBASE_API, params=params, headers=headers, timeout=timeout)
    resp.raise_for_status()
    Rückkehr resp.json()

Quelle: google_ai_mode/crawlbase_client.py

An diesem Punkt arbeiten Sie nicht mehr mit Browserstatus oder rohem HTML. Sie erhalten strukturiertes JSON, das den Seiteninhalt und Metadaten enthält und direkt in Ihren Parser übernommen werden kann.

Ein wichtiger Punkt, den Sie beachten sollten: Selbst wenn Sie eine URL für den KI-Modus anfordern, google-serp Der Scraper liefert möglicherweise ein eher traditionelles SERP-förmiges JSON-Objekt zurück. Das ist zu erwarten. Der Sample-Normalisierer ist so konzipiert, dass er beide Formate verarbeiten kann.

Genau das macht das Setup praktikabel. Man ist nicht an ein bestimmtes Antwortformat gebunden und muss nicht ständig Änderungen an der Benutzeroberfläche nachgehen.

Im Großen und Ganzen sieht die Pipeline folgendermaßen aus:

Sie beginnen mit einer Anfrage, wandeln diese in eine AI-Mode-URL um und senden sie durch CrawlbaseAnschließend wird das JSON in eine strukturierte Ausgabe normalisiert. Von dort aus können die Daten in eine Datei geschrieben, gespeichert oder an nachgelagerte Systeme weitergegeben werden.

Welche Daten lassen sich aus den Ergebnissen des Google AI-Modus extrahieren?

Sobald Sie die JSON-Antwort erhalten haben, gilt es im nächsten Schritt zu entscheiden, welche Daten tatsächlich relevant sind. Es geht nicht darum, alle Daten im Payload zu erfassen. Sie benötigen eine kleine Auswahl an stabilen und nützlichen Feldern.

In dieser Konfiguration wird die Ausgabe in drei Kernfelder normalisiert:

DatumFeld
Zusammenfassungstextresults[0].content.response_text
Zitate (URL + Snippet)results[0].content.citations
Referenzlinksresults[0].content.links

Diese Funktionen entsprechen direkt der Funktionsweise des KI-Modus. Sie erhalten eine generierte Antwort, eine Reihe von Quellen, die diese Antwort stützen, und eine umfassendere Sammlung von Links, die mit der Suchanfrage in Zusammenhang stehen.

Die Extraktionslogik wird im Normalisierer implementiert. Anstatt sich auf feste Schlüssel zu verlassen, sucht er nach mehreren möglichen Feldern und greift bei Bedarf auf alternative Methoden zurück. Dies ist wichtig, da die Form der Antwort je nach Art der Datenextraktion variieren kann. Crawlbase oder Google strukturiert die Nutzdaten.

Hier ist die Kernextraktionsfunktion:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
def extrahiere_Inhaltsfelder(geparster_Body: Jedes) -> diktieren[str, Jedes]:
    "" "
    Aus einem geparsten ``body`` (dict/list/str) extrahieren Sie ``prompt``, ``response_text``,
    ``citations``, ``links`` und optional ``parse_status_code``.
    "" "
    root = _parse_body_field(parsed_body)
    serp = _adapt_crawlbase_google_serp(root) if Instanz(Wurzel, diktieren) sonst Keine Präsentation

    prompt = _deep_find_first_str(root, ("prompt", "Abfrage", "Q", "Suchanfrage"))
    response_text = _deep_find_first_str(
        wurzel
        (
            "response_text",
            "result_text",
            "Antwort",
            "text",
            "ai_overview",
            „Ausschnitt“,
        ),
    )
    Zitate = _deep_find_list_of_linkish(root, ("Zitate", "Quellen", "Referenzen"))
    links = _deep_find_list_of_linkish(root, ("Links", "related_links", "organische_Links"))

    if kein Frontalunterricht. Links , Instanz(Wurzel, diktieren):
        alternativ: Liste[diktieren[str, str]] = []
        für  Haupt in ("Bio", "Ergebnisse", "Suchergebnisse", „peopleAlsoAsk“ (Die Leute fragen auch)):
            if Haupt in Wurzel:
                _collect_link_dicts(root[key], alt)
        if alternativ:
            links = alt[:200]

    if serp:
        if serp.get("Zitate"):
            Zitate = serp["Zitate"]
        if serp.get("Links"):
            links = serp["Links"]
        if kein Frontalunterricht. Antworttext , serp.get("response_text"):
            Antworttext = serp["response_text"]

    parse_code = Keine Präsentation
    if Instanz(Wurzel, diktieren) , "parse_status_code" in Wurzel:
        parse_code = root.get("parse_status_code")

    Rückkehr {
        "prompt": prompt or "",
        "response_text": Antworttext or "",
        "Zitate": Zitate,
        "Links": Links,
        "parse_status_code": parse_code,
    }

Quelle: google_ai_mode/normalize.py

Dieser Ansatz hält Ihren Parser flexibel. Er geht nicht von einem einzigen Antwortformat aus und funktioniert auch dann noch, wenn sich die Nutzdaten zwischen KI-artigen Antworten und traditionelleren SERP-Strukturen ändern.

  • response_text Dies ist die generierte Antwort, die Sie analysieren oder anzeigen können.
  • citations sind die Quellen, die diese Antwort stützen?
  • links Ihnen die umfassendere Menge verwandter Ergebnisse liefern

Wenn Sie Dashboards oder Pipelines erstellen, reicht diese Struktur für die meisten Anwendungsfälle aus, ohne Ihr Schema unnötig zu verkomplizieren.

Schritt-für-Schritt-Anleitung zum Scrapen des Google AI-Modus im Jahr 2026

Am schnellsten gelingt der Einstieg, indem Sie unser Beispielprojekt lokal ausführen. Es übernimmt die URL-Generierung, Crawlbase Anfragen und Normalisierung sind standardmäßig enthalten.

Sie benötigen die neueste Version von Python (3.10 oder höher) muss installiert sein, um dieses Projekt auszuführen, zusammen mit einem Crawlbase Konto und ein regelmäßiger Crawling API Zeichen.

Schritt 1: Klonen Sie das Repository

1
git klonen https://github.com/ScraperHub/google-ai-mode-scraper.git

Damit erhalten Sie die vollständige, funktionsfähige Implementierung inklusive CLI und Parsing-Logik.

Innerhalb des Repositorys befindet sich der eigentliche Code im Verzeichnis „code“. Wechseln Sie in dieses Verzeichnis:

1
cd google-ai-mode-scraper

Sie sollten nun Folgendes sehen:

  • requirements.txt
  • .env.example
  • google_ai_mode/

Alle verbleibenden Schritte sollten von diesem Verzeichnis aus ausgeführt werden.

Schritt 2: Eine virtuelle Umgebung einrichten

Richten Sie eine isolierte Python-Umgebung ein, damit Abhängigkeiten nicht mit Ihren Systempaketen in Konflikt geraten:

1
python -m venv .venv

Aktivieren Sie es:

  • Windows (PowerShell)
1
.venv\Scripts\Activate.ps1
  • macOS / Linux
1
Quelle .venv/bin/activate

Nach der Aktivierung sollte Ihr Terminal Folgendes anzeigen: (.venv) Dies bedeutet, dass Python und pip auf dieses Projekt beschränkt sind.

Schritt 3: Installieren Sie Abhängigkeiten

Installieren Sie die erforderlichen Python-Pakete:

1
pip install -r Anforderungen.txt

Dadurch wird alles Notwendige installiert für:

  • Ruf den Crawlbase Crawling API
  • Antworten analysieren
  • Führen Sie das CLI-Tool aus

Schritt 4: Konfigurieren Sie Ihr Crawlbase Zeichen

Umgebungsvorlage kopieren:

1
cp .env.example .env

Windows:

1
copy .env.example .env

Öffnen Sie den Microsoft Store auf Ihrem Windows-PC .env Datei und Token festlegen:

1
CRAWLBASE_REGULAR_TOKEN=Ihr_Token_hier

Stellen Sie sicher:

  • Sie verwenden die reguläres Token (Nicht browserfähiger API-Schlüssel), nicht das JavaScript-Token (browserfähiger API-Schlüssel)
  • Die Datei wird im selben Verzeichnis gespeichert wie requirements.txt

Das Projekt verwendet python-dotenvDieser Wert wird also automatisch geladen, wenn Sie das Skript ausführen.

Schritt 5: Führen Sie den Scraper aus.

Nachdem alles eingerichtet ist, führen Sie die Befehlszeilenschnittstelle aus:

1
python -m google_ai_mode "Ihre Suchanfrage"

Ejemplo:

1
python -m google_ai_mode "Die besten KI-Tools für Entwickler"

Was hier passiert:

  • Die Anfrage wird in eine AI-Modus-URL umgewandelt.
  • Crawlbase Ruft die Daten ab
  • Die Antwort wird in strukturiertes JSON normalisiert.

Das Ergebnis wird direkt in Ihrem Terminal ausgegeben.

Schritt 6: Ausgabe in einer Datei speichern

Wenn Sie das Ergebnis speichern statt es nur auszugeben möchten:

1
python -m google_ai_mode "Ihre Anfrage" > output.json

Dies schreibt die vollständige JSON-Antwort an output.json, die Sie untersuchen oder in andere Tools laden können.

Schritt 7: Ohne Abfrage ausführen (optional)

Sie können eine Standardabfrage definieren in .env:

1
GOOGLE_AI_MODE_QUERY=Ihre Abfrage hier

Dann renne:

1
python -m google_ai_mode

Dies ist nützlich für Tests oder geplante Ausführungen, bei denen Sie nicht jedes Mal Argumente übergeben möchten.

Schritt 8: Parameter anpassen

Die CLI bietet einige Optionen zur Steuerung der Anfrage:

OptionWas sie tut,
--glLegt das Land fest (Standard: USA)
--hlLegt die Sprache fest (Standard: en)
--no-scraperDeaktiviert scraper=google-serp

Ejemplo:

1
python -m google_ai_mode "KI-SEO-Tools" --gl uk --hl en

Dies ermöglicht es Ihnen zu testen, wie sich die Ergebnisse in verschiedenen Regionen oder Konfigurationen verändern.

Die vollständigen Anweisungen finden Sie auf der README-Seite: https://github.com/ScraperHub/google-ai-mode-scraper

So integrieren Sie Google AI Mode Scraping in Ihre App

Falls Sie dies lieber in Ihren eigenen Code integrieren möchten, anstatt die CLI auszuführen, stellt das Projekt eine einzelne High-Level-Funktion bereit.

Die Orchestrierungslogik befindet sich in google_ai_mode/google_ai_mode_scrape.pySie müssen aber nur eine Funktion importieren:

1
2
ab google_ai_mode importieren scrape_google_ai_mode
data = scrape_google_ai_mode("Beispielabfrage", gl="uns", hl="en")

Dieser Aufruf verarbeitet die gesamte Pipeline:

  • erstellt die KI-Modus-URL
  • sendet die Anfrage durch Crawlbase
  • analysiert und normalisiert die Antwort

Die Funktion lädt automatisch CRAWLBASE_REGULAR_TOKEN ab .env Falls verfügbar, wird auf die Umgebungsvariablen zurückgegriffen.

Das Ergebnis ist dasselbe strukturierte JSON, das in diesem Leitfaden durchgehend verwendet wird, einschließlich response_text, citations und linksSie können es also ohne zusätzliches Parsen direkt in Ihre Anwendung einbinden.

Die JSON-Antwortstruktur des Google AI-Modus verstehen

Die Antwort folgt einer einheitlichen Struktur, mit einem results Ein Array, das ein einzelnes Element enthält. Die meisten benötigten Daten befinden sich innerhalb dieses Objekts.

Zu den wichtigsten Feldern gehören:

  • results[0].content → prompt, response_text, citations, links, parse_status_code
  • results[0].url → die angeforderte URL des KI-Modus
  • results[0].status_code, pc_status, crawl_url, token_used, scraper
  • results[0].raw_body_preview → eine kurze Vorschau der Rohdaten zur Fehlersuche

Sie werden den größten Teil Ihrer Zeit mit der Arbeit verbringen mit response_text, citations und links.

Wenn Sie Dashboards oder Pipelines erstellen, beachten Sie Folgendes: status_code , pc_status zusammen mit Ihren extrahierten Feldern. Dadurch lässt sich leichter feststellen, ob ein Problem von Ihrem Parser oder von der Fetch-Schicht stammt.

Häufige Probleme beim Web-Scraping im Google AI-Modus (und Lösungen)

Das Auslesen von Google-Oberflächen ist keine einmalige Angelegenheit. Die Nutzdaten ändern sich, die Antwortstrukturen variieren, und Ihr Parser muss flexibel genug sein, um damit umzugehen.

Die häufigsten Probleme, auf die Sie stoßen werden, sind unkompliziert:

  • Fehler mit fehlenden Token
    Stelle sicher CRAWLBASE_REGULAR_TOKEN ist eingestellt in .env oder Ihrer Umgebung, und dass Sie das Skript aus dem richtigen Verzeichnis ausführen, damit es ordnungsgemäß geladen werden kann.
  • 401 oder Crawlbase Anfragefehler
    Vergewissern Sie sich, dass Sie ein reguläres Gerät verwenden. Crawling API Prüfen Sie, ob Ihr Konto über verfügbares Guthaben verfügt. Crawlbase Antwortcodes um verschiedene API-Fehlercodes zu verstehen.
  • Unvollständige oder unerwartete Ausgabe
    If response_text sieht leer aus oder citations scheinen nicht in Ordnung zu sein, überprüfen Sie raw_body_preview und der vollständige Antworttext. Sowohl Google als auch Crawlbase Da sich die Nutzdaten weiterentwickeln, muss Ihr Parser möglicherweise angepasst werden in google_ai_mode/normalize.py

Wenn die Ergebnisse plötzlich sinken oder anders aussehen, vergleichen Sie die aktuellen Ergebnisse mit den vorherigen, insbesondere die raw_body_previewDas gibt Ihnen in der Regel Aufschluss darüber, ob das Problem in Ihrer Parsing-Logik oder in einer vorgelagerten Stelle der Antwort liegt.

Wichtigste Erkenntnisse zum Scraping des Google-KI-Modus

Der Google AI-Modus verlagert das Web-Scraping von der Extraktion von Links hin zur Verarbeitung strukturierter Antworten, Zitate und Kontextinformationen. Anstatt sich auf fehleranfällige UI-Automatisierung zu verlassen, können Sie AI-Modus-URLs erstellen und JSON abrufen. Crawlbaseund normalisieren Sie die Antwort in Felder, die Sie tatsächlich verwenden können.

Dieser Ansatz hält die Datenpipeline einfach und stabil. Außerdem ermöglicht er die sofortige Nutzung der Daten, um Antwortänderungen nachzuverfolgen, zitierte Quellen zu analysieren und sie in SEO- oder interne Arbeitsabläufe einzuspeisen.

Wenn Sie das selbst ausprobieren möchten, beginnen Sie mit dem Beispielprojekt und führen Sie es lokal aus. Erstellen Sie Crawlbase KontoHolen Sie sich Ihr reguläres Token oder Ihren API-Schlüssel und fügen Sie ihn Ihrem Konto hinzu. .envFühren Sie einige Abfragen aus. Innerhalb weniger Minuten verfügen Sie über strukturierte KI-Modus-Daten, die Sie speichern, vergleichen und weiterentwickeln können.

Häufige Fragen zum Großhandel mit Lebensmitteln und Getränken

Was bedeutet udm=50?

udm=50 ist ein Google-Suchparameter, der den KI-Modus in den Suchergebnissen aktiviert. Wenn er in die Suchanfrage-URL aufgenommen wird, liefert er die KI-generierte Antwortschicht anstelle der herkömmlichen Linkliste.

Beispielsweise:

1
https://www.google.com/search?q=web+scraping&udm=50&gl=us&hl=en

Durch Öffnen dieser URL in einem Browser wird die AI-Modus-Version der Ergebnisse für die Suchanfrage „Web Scraping“ geladen.

Beeinflusst die Crawlbase Unterstützt Google AI-Modus?

Ja. Crawlbase Die Ergebnisse des Google AI-Modus können abgerufen werden, indem die AI-Modus-URL angefordert und die Antwort als strukturiertes JSON zurückgegeben wird. google-serp Der Scraper liefert zwar manchmal eine herkömmliche SERP-förmige Nutzlast zurück, die Daten können aber dennoch in Felder wie … normalisiert werden. response_text, citations und links mit der in diesem Leitfaden beschriebenen Vorgehensweise.

Welchen Token-Typ benötige ich?

Du brauchst ein regulär Crawling API Zeichen (Nicht browserfähiger API-Schlüssel), kein JavaScript-Token (browserfähiger API-Schlüssel). Die Einrichtung in dieser Anleitung basiert auf Crawlbase Die Anfrage wird bearbeitet und JSON wird direkt zurückgegeben, sodass kein Browser-Rendering erforderlich ist.