Google AI Mode scrapendie Antwort, ihre Zitate und Links als JSON

Google AI Mode hat verändert, wie ein Suchergebnis aussieht. Statt zehn blauer Links liefert die KI-Antwortfläche eine ausformulierte Antwort auf deine Anfrage, darunter eine Reihe zitierter Quellen und seitlich ein breiteres Band verwandter Links. Für jeden, der verfolgt, was Google zu einem Thema sagt, ist das ein neuer und wertvoller Datensatz: nicht nur wer rankt, sondern die tatsächliche Antwort, die an eine Anfrage gebunden ist, und die Seiten, die Google ausgewählt hat, um sie zu belegen.

Diese Anleitung zeigt dir, wie du Google AI Mode auf zuverlässige Weise scrapst. Du baust ein kleines, lauffähiges Python-Skript, das das öffentliche AI-Mode-Ergebnis über die Crawling API abruft, die die JavaScript-lastige Seite hinter einer vertrauenswürdigen IP rendert, und anschließend die KI-Antwort, ihre Zitate und die verwandten Links in sauberes, strukturiertes JSON extrahiert. Das Abrufen und die Rotation werden dir abgenommen, sodass du deine Zeit für die Daten verwendest und nicht dafür, einen Headless-Browser und einen Proxy-Pool am Leben zu halten.

Was Google AI Mode ist und warum man es scrapen sollte

AI Mode ist die generative Antwortebene innerhalb der Google-Suche. Du erreichst sie, indem du den Parameter udm=50 an eine normale Such-URL anhängst, was Google anweist, seine KI-geschriebene Antwort statt der klassischen Ergebnisseite zurückzugeben. Die Antwort besteht aus drei Teilen, die für das Scraping wichtig sind: dem Antworttext selbst, den Zitaten, die Google an diese Antwort anhängt, und einer breiteren Reihe von Referenzlinks, die mit der Anfrage zusammenhängen.

Genau diese Struktur macht das Sammeln lohnenswert. Du kannst verfolgen, wie sich Googles Antwort auf eine Anfrage im Lauf der Zeit verschiebt, sehen, welche Domains sie zitiert und wie oft, und das in SEO-Recherche oder Content-Workflows einfließen lassen. Es ist dieselbe Art von Problem wie der Aufbau eines beliebigen Datentools für Suchmaschinen, nur dass die Nutzlast eine Antwort samt ihrer Quellen ist statt einer gerankten Liste.

Was du bauen wirst

Ein kurzes Python-Skript, das eine Suchanfrage entgegennimmt, die AI-Mode-URL baut, sie mit aktiviertem JavaScript-Rendering durch die Crawling API schickt und das gerenderte Ergebnis in ein JSON-Objekt mit drei Feldern parst: dem Antworttext, einer Liste von Zitaten und einer Liste verwandter Links. Jeder Codeausschnitt läuft sofort, sobald du deinen Token einsetzt, und derselbe Code funktioniert, egal ob du ihn auf eine Anfrage richtest oder über Hunderte schleifst.

Warum ein einfacher Abruf hier scheitert

Wenn du eine AI-Mode-URL mit einem nackten HTTP-Client anforderst, bekommst du eine Antwort mit Status 200 und keinen Teil der Antwort im Body. Zwei Dinge arbeiten gegen dich. Erstens wird AI Mode im Browser gerendert: Die Antwort und ihre Zitate strömen ein, nachdem das JavaScript der Seite läuft, sodass das anfängliche HTML eine leere Hülle ist. Zweitens fordert Google automatisierten Traffic schnell heraus. Datacenter-IPs und Anfragemuster, die nicht wie ein echter Besucher aussehen, bekommen ein CAPTCHA oder eine Sperre, bevor sie die gerenderte Antwort überhaupt zu sehen bekommen.

Ein funktionierender AI-Mode-Scraper braucht also zwei Dinge in einer Anfrage: einen Browser, der die Seite tatsächlich rendert, und eine IP, die Google als echten Besucher liest. Das kannst du selbst mit einem Headless-Browser plus einem Pool rotierender Residential-Proxys zusammenbauen, aber diese zusammenzufügen und gesund zu halten ist der Großteil der Arbeit. Die Crawling API faltet beides in einen einzigen Aufruf: Schick ihr die URL mit einem JavaScript-Token, sie rendert die Seite hinter einer vertrauenswürdigen IP und gibt dir das fertige HTML zum Parsen zurück.

Schritt 1: Die AI-Mode-URL bauen

Der Einstiegspunkt der Pipeline ist eine Funktion, die eine Anfrage in eine gültige AI-Mode-URL verwandelt. Du setzt udm=50, um AI Mode auszuwählen, übergibst die Anfrage in q und fügst gl und hl hinzu, um Land und Sprache zu steuern, damit die Ergebnisse von Lauf zu Lauf konsistent sind.

from urllib.parse import urlencode, quote_plus

def build_ai_mode_url(query, gl="us", hl="en"):
    if not query or not query.strip():
        raise ValueError("query must be non-empty")
    params = {
        "udm": "50",
        "q": query.strip(),
        "gl": gl,
        "hl": hl,
    }
    query_string = urlencode(params, quote_via=quote_plus)
    return f"https://www.google.com/search?{query_string}"

print(build_ai_mode_url("best ai tools for developers"))

Übergib eine Anfrage und du bekommst eine konsistente AI-Mode-URL zurück. Von hier aus ist der Rest des Workflows eine gerade Linie: Schick die URL durch die Crawling API und normalisiere dann das gerenderte Ergebnis in strukturierte Felder, die dein System nutzen kann.

Schritt 2: Die gerenderte Seite mit der Crawling API abrufen

Mit der gebauten URL rufst du die gerenderte Seite ab. Du übergibst zwei Optionen, die für eine KI-Fläche wichtig sind: ajax_wait weist die API an, auf das vollständige Laden asynchroner Inhalte zu warten, und page_wait hält für eine feste Anzahl Millisekunden nach dem Laden, damit die gestreamte Antwort und die Zitate Zeit haben zu erscheinen, bevor die Seite erfasst wird. Fünf Sekunden sind ein sinnvoller Ausgangspunkt; erhöhe sie, falls die Antwort dünn zurückkommt.

from crawlbase import CrawlingAPI

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_JS_TOKEN"})

def fetch_html(target_url):
    options = {"ajax_wait": "true", "page_wait": 5000}
    response = api.get(target_url, options)
    return response["body"].decode("utf-8")

url = build_ai_mode_url("best ai tools for developers")
html = fetch_html(url)
print(html[:500])

Führe das aus und du solltest echtes Markup mit dem KI-Antwortblock darin sehen, nicht die leere Hülle, die ein einfacher Abruf zurückgibt. Das bestätigt, dass das Rendering funktioniert, bevor du auch nur einen Selektor schreibst. Du hast es nicht mehr mit Browserzustand oder Anti-Bot-Herausforderungen zu tun; du hast fertiges HTML bereit für den Parser.

Schritt 3: Antwort, Zitate und Links extrahieren

Mit dem gerenderten HTML in der Hand lädst du es in einen Parser und ziehst die drei Felder heraus, die zählen. Nutze BeautifulSoup, um den Antworttext zu lesen, und durchlaufe dann die Zitat- und Linkblöcke, um ihre URLs und Titel zu sammeln. Das AI-Mode-Markup ist kein öffentlicher Vertrag, behandle die Selektoren unten also als Ausgangsvorlage: Inspiziere eine Live-AI-Mode-Seite in den Entwicklertools deines Browsers und gleiche sie mit dem aktuellen Layout ab.

from bs4 import BeautifulSoup

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

    answer_block = soup.select_one('div[data-rl="ai-mode"], div.ai-response')
    response_text = answer_block.get_text(" ", strip=True) if answer_block else ""

    citations = []
    for cite in soup.select('a.ai-citation, div.citation a[href]'):
        href = cite.get("href", "")
        if href.startswith("http"):
            citations.append({
                "url": href,
                "title": cite.get_text(strip=True),
            })

    links = []
    for link in soup.select('div.related-links a[href^="http"]'):
        links.append({
            "url": link["href"],
            "title": link.get_text(strip=True),
        })

    return {
        "response_text": response_text,
        "citations": citations,
        "links": links,
    }

Jedes Feld bildet direkt ab, wie AI Mode eine Antwort präsentiert. response_text ist die generierte Antwort, die du speichern, vergleichen oder anzeigen kannst. citations sind die Quellen, die Google angehängt hat, um diese Antwort zu belegen, jede mit ihrer URL und ihrem Titel. links sind die breitere Reihe verwandter Ergebnisse rund um die Anfrage. Das Schema so klein zu halten ist bewusst gewählt: drei stabile Felder decken die meisten Dashboards und Pipelines ab, ohne dich an ein Markup zu binden, das sich verschiebt.

Schritt 4: Alles verdrahten und das Ergebnis speichern

Kombiniere jetzt die drei Schritte zu einem lauffähigen Skript. Es baut die URL, ruft die gerenderte Seite ab, extrahiert die Felder und schreibt das strukturierte Ergebnis in eine JSON-Datei, die du inspizieren oder nachgelagert laden kannst.

import json
from urllib.parse import urlencode, quote_plus
from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_JS_TOKEN"})

def build_ai_mode_url(query, gl="us", hl="en"):
    params = {"udm": "50", "q": query.strip(), "gl": gl, "hl": hl}
    return f"https://www.google.com/search?{urlencode(params, quote_via=quote_plus)}"

def fetch_html(target_url):
    options = {"ajax_wait": "true", "page_wait": 5000}
    response = api.get(target_url, options)
    return response["body"].decode("utf-8")

def extract_ai_mode(html):
    soup = BeautifulSoup(html, "html.parser")
    answer_block = soup.select_one('div[data-rl="ai-mode"], div.ai-response')
    response_text = answer_block.get_text(" ", strip=True) if answer_block else ""
    citations = [
        {"url": c["href"], "title": c.get_text(strip=True)}
        for c in soup.select('a.ai-citation, div.citation a[href^="http"]')
    ]
    links = [
        {"url": l["href"], "title": l.get_text(strip=True)}
        for l in soup.select('div.related-links a[href^="http"]')
    ]
    return {"response_text": response_text, "citations": citations, "links": links}

def scrape_ai_mode(query, gl="us", hl="en"):
    url = build_ai_mode_url(query, gl, hl)
    html = fetch_html(url)
    data = extract_ai_mode(html)
    data["query"] = query
    return data

if __name__ == "__main__":
    result = scrape_ai_mode("best ai tools for developers")
    with open("ai_mode.json", "w") as f:
        json.dump(result, f, indent=2)
    print(json.dumps(result, indent=2))

Führe es mit python scraper.py aus und du bekommst die strukturierte Antwort in ai_mode.json geschrieben und auf der Konsole ausgegeben. Die Funktion scrape_ai_mode ist auch die eine Stelle zum Importieren, wenn du das in deine eigene App einbauen willst: Rufe sie mit einer Anfrage auf und du bekommst dasselbe strukturierte Dict zurück, ohne zusätzliches Parsen.

Wie die Ausgabe aussieht

Das Ergebnis ist ein einzelnes Objekt mit dem Antworttext und zwei Listen. Eine gekürzte Probe:

{
  "query": "best ai tools for developers",
  "response_text": "Popular AI tools for developers include code assistants, ...",
  "citations": [
    { "url": "https://example.com/ai-dev-tools", "title": "10 AI Tools for Developers" },
    { "url": "https://example.org/coding-assistants", "title": "Best Coding Assistants" }
  ],
  "links": [
    { "url": "https://example.net/dev-productivity", "title": "Developer Productivity Guide" }
  ]
}

Diese Form reicht aus, um eine Antwort im Lauf der Zeit zu verfolgen, zu zählen, welche Domains Google am häufigsten zitiert, oder Antworten über Regionen hinweg zu vergleichen, indem du gl und hl variierst. Speichere den Antworttext zusammen mit einem Zeitstempel und du hast eine einfache Historie, wie sich Googles Antwort auf eine Anfrage verändert.

Skalierung auf viele Anfragen

Eine Anfrage ist eine Demo; ein echter Job läuft über eine Liste. Die Form bleibt dieselbe: Schleife die Anfragen, scrape jede einzelne und sammle die Zeilen ein. Worauf es bei Volumen ankommt, ist ungesperrt zu bleiben, da Google auf scraper-förmigen Traffic achtet. Die Crawling API rotiert die IPs bei jedem Aufruf für dich, sodass die Schleife unten keine Proxys verwalten muss.

queries = [
    "best ai tools for developers",
    "how does web scraping work",
    "python vs javascript for automation",
]

results = []
for q in queries:
    try:
        results.append(scrape_ai_mode(q))
    except Exception as err:
        print(f"Skipped {q}: {err}")

with open("ai_mode_batch.json", "w") as f:
    json.dump(results, f, indent=2)

Wenn du deinen eigenen Traffic lieber durch einen rotierenden Pool leiten willst, statt die Crawling API durchgängig zu nutzen, gibt dir der Smart AI Proxy (auch AI Proxy genannt) dieselbe Residential-IP-Rotation als nahtlos einsetzbaren Proxy-Endpunkt. Für das umfassendere Vorgehen, jeden Google-Scrape gesund zu halten, siehe wie man Proxys für das Scrapen von Google-Suchergebnissen rotiert und wie man Websites scrapt, ohne gesperrt zu werden.

Häufige Probleme und Lösungen

Eine Google-Fläche zu scrapen ist keine Aufgabe nach dem Prinzip einmal einrichten und vergessen. Nutzlasten ändern sich und dein Parser braucht Spielraum, um sich anzupassen. Die Probleme, auf die du am häufigsten stößt, sind unkompliziert:

• Leerer Antworttext. Wenn response_text leer zurückkommt, hatte die Seite das Rendern wahrscheinlich nicht beendet. Erhöhe page_wait, vergewissere dich, dass du den JS-Token verwendest, und inspiziere den Selektor für den Antwortblock neu gegen eine Live-Seite.
• Auth- oder Guthabenfehler. Eine Anfrage, die vor dem Rendern fehlschlägt, bedeutet meist einen falschen Token oder ein leeres Guthaben. Prüfe, ob dein JS-Token korrekt ist und dein Konto Guthaben hat, und sieh dir das Antwortverhalten der API, wenn Google Traffic herausfordert, an.
• Fehlende Zitate oder Links. Google verschiebt diese Blöcke. Wenn sie nicht mehr passen, aktualisiere die Zitat- und Linkselektoren und bewahre eine Roh-HTML-Probe auf, damit du genau siehst, was sich verschoben hat.

Wenn Ergebnisse plötzlich wegbrechen oder anders aussehen, vergleiche eine aktuelle Roh-HTML-Probe mit einer älteren. Das sagt dir meist auf Anhieb, ob die Änderung in deiner Parsing-Logik liegt oder vorgelagert in der gerenderten Seite.

Ist es legal, Google AI Mode zu scrapen?

Ob das Scrapen von Google AI Mode erlaubt ist, hängt von Googles Nutzungsbedingungen, deiner Gerichtsbarkeit und davon ab, was du mit den Daten machst. Googles Bedingungen beschränken den automatisierten Zugriff auf seine Dienste, sodass Scraping gegen diese Bedingungen verstoßen kann, egal wie sorgfältig dein Tooling ist. Nichts vom Code hier ändert daran etwas; er bringt nur den technischen Teil zum Laufen. Lies Googles Nutzungsbedingungen und seine robots.txt, bevor du das auf Produktionsvolumen richtest, und entscheide entsprechend.

Ein paar Leitlinien, an die man sich halten sollte. Sammle nur öffentliche AI-Mode-Ergebnisse, die Antwort und die Quellen, die jeder ohne Anmeldung sehen kann. Halte deine Anfragerate niedrig genug, dass du Googles Systeme nicht belastest, und respektiere die Ratenvorgaben, die seine robots.txt signalisiert. Sammle niemals persönliche oder private Daten und versuche nicht, etwas hinter einer Anmeldung zu erreichen. Wenn du planst, die Daten kommerziell wiederzuverwenden, hol dir eine Erlaubnis oder eine offizielle Datenvereinbarung, statt anzunehmen, dass Schweigen Zustimmung bedeutet.

Diese Anleitung ist bewusst auf öffentliche AI-Mode-Ergebnisse beschränkt, weil das die Linie ist, die die Arbeit vertretbar hält. Sie behandelt keine durch Anmeldung geschützten oder privaten Daten, keine Konto- oder Profilinformationen und keinen Versuch, die Authentifizierung zu umgehen. Wenn dein Projekt mehr als die öffentliche Antwortfläche braucht, ist der richtige Schritt eine offizielle Google-Datenvereinbarung, nicht ein cleverer Scraper.

Häufig gestellte Fragen

Was ist udm=50 in einer Google-Such-URL?

udm=50 ist der Suchparameter, der Google AI Mode auslöst. Der udm-Wert wählt eine Suchkategorie aus, und 50 ist der Wert, der die KI-Antwortfläche statt der klassischen Liste von Links zurückgibt. Hänge ihn zusammen mit deiner Anfrage, deinem Land und deiner Sprache an eine standardmäßige google.com/search-URL an, und Google liefert das AI-Mode-Ergebnis für diese Anfrage.

Warum liefert ein einfacher Abruf keine Antwort von Google AI Mode?

Weil AI Mode clientseitig gerendert wird. Die Antwort und ihre Zitate strömen ein, nachdem das JavaScript der Seite läuft, sodass eine rohe HTTP-Anfrage Status 200 mit einer leeren Hülle zurückgibt. Google fordert automatisierten Traffic außerdem schnell heraus. Um die echte Antwort zu bekommen, musst du die Seite hinter einer vertrauenswürdigen IP rendern, und genau das übernimmt der JS-Token der Crawling API für dich.

Brauche ich den normalen Token oder den JS-Token?

Den JS-Token. Der normale Token ruft statisches HTML ab, was bei AI Mode dieselbe leere Hülle ist, die ein einfacher Abruf zurückgibt. Der JS-Token rendert die Seite zuerst in einem echten Browser, sodass die Antwort, die Zitate und die Links vorhanden sind, wenn dein Parser sie liest.

Welche Daten kann ich aus einem Google-AI-Mode-Ergebnis extrahieren?

Drei stabile Felder decken die meisten Bedürfnisse ab: den generierten Antworttext, die Zitate, die Google an diese Antwort anhängt (jedes mit einer URL und einem Titel), und die breitere Reihe verwandter Links rund um die Anfrage. Das Schema klein zu halten macht die Pipeline widerstandsfähig, da du nicht an ein Markup gebunden bist, das Google ohne Vorankündigung ändert.

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

Mit ziemlicher Sicherheit Googles Markup. AI Mode hat keine veröffentlichten, stabilen Klassennamen, daher können Selektoren, die letzten Monat funktionierten, brechen. Inspiziere eine Live-AI-Mode-Seite in den Entwicklertools deines Browsers neu und aktualisiere die Selektoren für Antwort, Zitate und Links. Eine kurze Roh-HTML-Probe neben deiner Ausgabe aufzubewahren macht es leicht zu sehen, was sich bewegt hat.

Ist es legal, Google AI Mode zu scrapen?

Es hängt von Googles Nutzungsbedingungen, deiner Gerichtsbarkeit und deinem Zweck ab, und Googles Bedingungen beschränken den automatisierten Zugriff. Halte dich strikt an öffentliche AI-Mode-Ergebnisse, respektiere robots.txt und Ratenvorgaben und rühre niemals durch Anmeldung geschützte Inhalte, persönliche Daten oder Authentifizierung an. Für kommerzielle Wiederverwendung hol dir eine Erlaubnis oder eine offizielle Datenvereinbarung, statt dich auf einen Scraper zu verlassen.

IK

Ian Kalvin

Technical Support Engineer · Crawlbase

Technical Support Engineer bei Crawlbase, der von der Front darüber schreibt, was beim Scraping und bei Proxy-Setups im Produktivbetrieb tatsächlich kaputtgeht.

NZ

Neil Zamora

Senior Architect · Crawlbase

Senior Architect bei Crawlbase mit Fokus auf den Systemen hinter großflächigem Crawling: Proxy-Rotation, Anti-Bot-Resilienz und den APIs, die diese Komplexität verbergen.