Google People Also Ask scrapenvollständige PAA-Extraktionsanleitung

Googles "People Also Ask"-Box (PAA) erscheint in einem großen Teil der Suchanfragen, direkt unter oder zwischen den organischen Ergebnissen als Stapel ausklappbarer Frage-Antwort-Paare. Für jeden, der Inhalts- oder SEO-Recherchen betreibt, ist sie eines der direktesten Signale für echte Nutzerintention, das man von einer Ergebnisseite ablesen kann: die genaue Formulierung, die Menschen verwenden, die Folgefragen, die sie stellen, und die Lücken, die Wettbewerber noch nicht abgedeckt haben. Klicken Sie eine auf, und Google lädt weitere verwandte Fragen darunter, sodass eine einzelne Suchanfrage zu einem ganzen Baum von Intentionen verzweigen kann.

Dieser Leitfaden zeigt Ihnen, wie Sie Google People Also Ask mit Python auf zuverlässige, wiederholbare Weise scrapen. Sie bauen einen kleinen, ausführbaren Scraper, der eine gerenderte Google-SERP über die Crawling API abruft, die PAA-Fragen und -Antworten parst, die verschachtelten Elemente erweitert, damit Sie die tieferen Ebenen erfassen, die die meisten Scraper verpassen, und saubere Frage-Antwort-Paare als JSON exportiert. Die gesamte Anleitung bleibt auf öffentliche Suchergebnisdaten beschränkt, die jeder ohne ein Konto sehen kann. Den Abschnitt zur Rechtslage am Ende lohnt es sich zu lesen, bevor Sie dies in größerem Umfang einsetzen.

Was Sie bauen werden

Ein Python-Skript, das eine öffentliche Google-Suchanfrage entgegennimmt, das gerenderte HTML über die Crawling API abruft und für jeden PAA-Eintrag auf der Seite einen strukturierten Datensatz extrahiert, einschließlich der Fragen, die durch Erweitern der ersten Ebene aufgedeckt werden. Wir verwenden eine Beispielabfrage als laufendes Beispiel und ziehen diese Felder aus jedem PAA-Eintrag:

• Frage der PAA-Fragetext genau so, wie Google ihn formuliert, was Ihre Schlüsselwort- und Themenabdeckung erweitert.
• Antwort die Snippet-Antwort, die Google anzeigt, wenn das Element erweitert wird, nützlich für Featured-Snippet-Recherchen.
• Quell-URL die Seite, die Google für die Antwort zitiert, was die Wettbewerbsanalyse unterstützt.
• Unterelemente die verschachtelten Fragen, die beim Erweitern des Elements aufgedeckt werden, und tiefere Ebenen des Erweiterungsbaums erfassen.

Warum eine einfache Anfrage bei Google scheitert

Wenn Sie eine rohe HTTP-Anfrage an eine Google-Such-URL aus einem Skript senden, ist der PAA-Abschnitt normalerweise nicht vorhanden. Zwei Dinge arbeiten gegen Sie. Erstens wird die PAA-Box von JavaScript gerendert, nachdem die Seite initialisiert wird, und aktualisiert sich erneut, wenn eine Frage angeklickt wird. Das rohe HTML, das eine einfache Anfrage zurückgibt, lässt die Box entweder ganz weg oder enthält nur eine leere Hülle. Zweitens überwacht Google automatisierten Traffic: Anfragen, die nicht wie ein echter Browser aussehen, werden herausgefordert, einer Zustimmungs- oder Verifizierungsseite zugeführt oder blockiert, bevor sie die Ergebnisse erreichen.

Ein funktionierender PAA-Scraper benötigt also zwei Dinge in einer Anfrage: eine IP, die die Plattform als echten Besucher liest, und einen Browser, der die Seite tatsächlich rendert und ihre Skripte ausführt. Sie können das selbst mit einem Headless-Browser plus einem Pool rotierender privater Proxys zusammenstellen, aber diese am Laufen zu halten ist der Großteil der Arbeit. Die Crawling API faltet beides in einen einzigen Aufruf: Sie senden ihr die Such-URL, sie ruft von einer vertrauenswürdigen privaten IP ab und rendert die Seite in einem echten Browser, wartet auf das Laden des dynamischen Inhalts und gibt fertiges HTML zum Parsen zurück.

Voraussetzungen

Sie benötigen einige Dinge, bevor Sie Code schreiben. Keines davon nimmt viel Zeit in Anspruch.

Grundlegendes Python. Sie sollten in der Lage sein, ein Python-Skript zu schreiben und auszuführen und Pakete mit pip zu installieren. Wenn BeautifulSoup neu für Sie ist, behandelt unser Leitfaden zur Verwendung von BeautifulSoup in Python die Parsing-Grundlagen, auf die dieses Tutorial aufbaut.

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

Ein Crawlbase-Konto und ein JavaScript-Token. Registrieren Sie sich, öffnen Sie Ihr Dashboard und kopieren Sie Ihr Token von der Kontodokumentationsseite. Google SERPs benötigen Rendering, verwenden Sie also Ihr JavaScript-Token (auch Browser-aktivierter Schlüssel genannt) und nicht das normale. 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.

Das Projekt einrichten

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

python --version

python -m venv paa_env
source paa_env/bin/activate

pip install requests beautifulsoup4

Unter Windows aktivieren Sie die Umgebung mit paa_env\Scripts\activate anstelle der source-Zeile. Zwei Abhängigkeiten erledigen die Arbeit: requests sendet den HTTP-Aufruf an die Crawling API, und beautifulsoup4 parst das zurückgegebene HTML, sodass Sie einzelne Felder per CSS-Selektor herausziehen können.

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

Beginnen Sie damit, das gerenderte HTML zu erhalten. Schreiben Sie eine kleine crawl()-Funktion, die Ihre Google-Such-URL mit Ihrem JavaScript-Token an die Crawling API sendet, sie auffordert zu rendern und zu warten, prüft, dass die zugrunde liegende Seite mit einem 200-Status zurückgekommen ist, und den HTML-Body zurückgibt. Die Parameter gl und hl in der URL legen Land und Sprache fest, und page_wait gibt den PAA-Skripten Zeit, bevor das HTML erfasst wird.

import json
import requests
from urllib.parse import urlencode

JS_TOKEN = "YOUR_CRAWLBASE_TOKEN"  # use your JavaScript token
API_ENDPOINT = "https://api.crawlbase.com/"

def build_serp_url(query, gl="us", hl="en"):
    base = "https://www.google.com/search?"
    return base + urlencode({"q": query, "gl": gl, "hl": hl})

def crawl(url, page_wait=2000):
    params = {
        "token": JS_TOKEN,
        "url": url,
        "page_wait": page_wait,
    }
    response = requests.get(API_ENDPOINT, params=params, timeout=90)
    response.raise_for_status()

    data = json.loads(response.text)
    if data["original_status"] != 200:
        raise Exception(f"Unable to crawl '{url}'")

    return data["body"]

if __name__ == "__main__":
    url = build_serp_url("how to scrape google", gl="us", hl="en")
    html = crawl(url)
    print(html[:500])

Die API gibt einen JSON-Envelope zurück, also laden Sie die Antwort mit json.loads und lesen zwei Felder: original_status ist der Status, den Google selbst zurückgegeben hat, und body ist das gerenderte Seiten-HTML. Die Bewachung auf original_status bedeutet, dass ein Zustimmungsgate oder ein Block als Ausnahme auftaucht, anstatt Unsinn in den Parser zu speisen. Ein page_wait von etwa 2000 Millisekunden reicht normalerweise aus, damit die PAA-Box lädt. Ein 90-Sekunden-Request-Timeout gibt dem Render Raum zum Beenden, ohne dass der Aufruf ewig hängt. Führen Sie das Skript mit python crawling.py aus und Sie sollten echtes SERP-Markup in den ersten 500 Zeichen sehen, was bestätigt, dass Abruf und Rendering funktionieren, bevor Sie einen einzigen Selektor schreiben. Wenn der PAA-Abschnitt dünn aussieht, ist das Erhöhen von page_wait fast immer die erste Maßnahme.

Schritt 2: Die PAA-Fragen und -Antworten parsen

Mit dem gerenderten HTML laden Sie es in BeautifulSoup und ziehen jedes PAA-Element heraus. Google gibt der PAA-Box keinen einzigen stabilen Klassennamen, daher ist der zuverlässige Ansatz layered Fallback-Selektoren: Jedes PAA-Element trägt ein data-q-Attribut mit der Frage, und die sichtbare Antwort befindet sich im aufklappbaren Block daneben. Der folgende Parser liest die Frage aus data-q, die Antwort aus dem gerenderten Text und die zitierte Quelle aus dem ersten ausgehenden Anker im Element.

from bs4 import BeautifulSoup

# Layered fallbacks: Google rotates these class names, so try
# the stable data-q attribute first, then known container classes.
PAA_ITEM_SELECTORS = [
    "div[data-q]",
    "div.related-question-pair",
    "div[jsname='Cpkphb']",
]

def find_paa_items(soup):
    for selector in PAA_ITEM_SELECTORS:
        items = soup.select(selector)
        if items:
            return items
    return []

def parse_paa(html):
    soup = BeautifulSoup(html, "html.parser")
    questions = []

    for item in find_paa_items(soup):
        question = item.get("data-q")
        if not question:
            heading = item.select_one("div[role='heading'], span")
            question = heading.get_text(strip=True) if heading else None
        if not question:
            continue

        answer_el = item.select_one("div[data-attrid], div.wDYxhc, span.hgKElc")
        answer = answer_el.get_text(" ", strip=True) if answer_el else None

        link = item.select_one("a[href^='http']")
        source_url = link["href"] if link else None

        questions.append({
            "question": question,
            "answer": answer,
            "source_url": source_url,
            "children": [],
        })

    return questions

Die Datensatzform entspricht exakt der Legacystruktur: question erweitert die Schlüsselwortabdeckung, answer hilft bei Featured-Snippet-Arbeit, source_url unterstützt die Wettbewerbsanalyse, und children ist für die verschachtelten Erweiterungen reserviert, die Sie im nächsten Schritt erfassen. Das Lesen der Frage zuerst aus dem stabilen data-q-Attribut und dann das Zurückfallen auf den Überschriftentext hält den Parser am Laufen, wenn Google seine Klassennamen umstrukturiert. Die Wächter if not question: continue überspringen leere Hüllen, sodass nur echte PAA-Elemente Ihre Ausgabe erreichen.

Schritt 3: Die verschachtelten PAA-Elemente erweitern

Bis zu diesem Punkt extrahieren Sie nur den anfänglichen Satz von PAA-Fragen. Das allein ist nützlich, aber unvollständig: Der echte Wert liegt tiefer im Erweiterungsbaum. Wenn ein Benutzer auf eine PAA-Frage klickt, lädt Google dynamisch zwei bis vier weitere verwandte Fragen darunter, und jede kann weitere Erweiterungen auslösen. Um das zu erfassen, weisen Sie die Crawling API an, die Klicks zu simulieren, bevor sie das HTML erfasst, mithilfe des Parameters css_click_selector, damit die zusätzlichen Fragen in das DOM geladen werden, das Sie dann parsen.

def crawl_expanded(url, page_wait=3000):
    # css_click_selector clicks each PAA question so Google loads
    # the nested questions before the HTML is captured.
    params = {
        "token": JS_TOKEN,
        "url": url,
        "page_wait": page_wait,
        "css_click_selector": "div[data-q]",
    }
    response = requests.get(API_ENDPOINT, params=params, timeout=90)
    response.raise_for_status()
    data = json.loads(response.text)
    if data["original_status"] != 200:
        raise Exception(f"Unable to crawl '{url}'")
    return data["body"]

def scrape_with_expansions(query, gl="us", hl="en"):
    url = build_serp_url(query, gl, hl)

    # First pass: the visible PAA questions.
    base_items = parse_paa(crawl(url))
    seen = {item["question"] for item in base_items}

    # Second pass: click to load the nested questions, then diff.
    expanded_items = parse_paa(crawl_expanded(url))
    for item in expanded_items:
        if item["question"] not in seen:
            base_items[0]["children"].append(item)
            seen.add(item["question"])

    return base_items

Der Ablauf ist: Bauen Sie die SERP-URL mit Ihrer Abfrage und Geo-Parametern, rufen Sie den sichtbaren PAA-Satz einmal ab, dann rufen Sie erneut mit css_click_selector ab, der auf den PAA-Element-Selektor gesetzt ist, damit die API auf jede Frage klickt und die neuen in das DOM lädt. Das Parsen beider Durchläufe und das Behalten nur der noch nicht gesehenen Fragen gibt Ihnen die tiefere Ebene, ohne die Originale zu duplizieren. In der Praxis kann eine einzelne Abfrage nach ein paar Erweiterungsrunden von drei oder vier sichtbaren Fragen auf zwölf bis zwanzig insgesamt anwachsen. Dieser Schritt ist aus Implementierungssicht optional, aber hier liegt der Großteil des fehlenden Werts.

Schritt 4: Alles zusammenführen und die Frage-Antwort-Paare exportieren

Verbinden Sie jetzt Erstellen, Abrufen, Erweitern und Parsen in einem ausführbaren Skript, das die strukturierten PAA-Daten als JSON schreibt. Das Setzen von ensure_ascii=False hält Nicht-ASCII-Zeichen in der Datei lesbar, anstatt sie in \u-Sequenzen zu escapen, was wichtig wird, sobald Sie Abfragen in anderen Sprachen ausführen.

import sys

def main():
    query = sys.argv[1] if len(sys.argv) > 1 else "how to scrape google"
    country = sys.argv[2] if len(sys.argv) > 2 else "us"

    paa = scrape_with_expansions(query, gl=country)

    outfile = f"paa_{country}.json"
    with open(outfile, "w", encoding="utf-8") as f:
        json.dump(paa, f, ensure_ascii=False, indent=2)

    total = len(paa) + sum(len(q["children"]) for q in paa)
    print(f"Saved {total} PAA questions to {outfile}")

if __name__ == "__main__":
    main()

Führen Sie das vollständige Skript mit python main.py "content gap analysis" uk aus. Es baut die Google-SERP-URL für diese Abfrage im gewählten Land, ruft das gerenderte HTML ab, erweitert die PAA-Elemente und schreibt die Frage-Antwort-Paare in paa_uk.json. Dieselbe Handvoll Funktionen ist alles, was Sie benötigen: Tauschen Sie die Abfrage oder den Ländercode aus, und der Parser verarbeitet alles, was zurückkommt. Wenn die Ergebnisse unvollständig aussehen, erhöhen Sie page_wait als erste Maßnahme, da ein langsames Rendering die häufigste Ursache für eine kurze PAA-Liste ist.

Wie die Ausgabe aussieht

Sie erhalten eine saubere Liste von Frageobjekten, jedes mit seiner Antwort, der zitierten Quelle und allen verschachtelten Fragen, die während der Erweiterung erfasst wurden, bereit zum Schreiben als JSON, zum Einspeisen in ein Inhalts-Briefing oder zum Laden in eine Datenbank zum Clustering.

[
  {
    "question": "Is it legal to scrape Google?",
    "answer": "Scraping public search results is generally permitted, but it can conflict with Google's terms of service.",
    "source_url": "https://example.com/is-scraping-google-legal",
    "children": [
      {
        "question": "Can Google detect scraping?",
        "answer": "Yes, Google uses rate limits and behavioral signals to flag automated traffic.",
        "source_url": "https://example.com/google-bot-detection",
        "children": []
      }
    ]
  },
  {
    "question": "What is the best tool to scrape Google?",
    "answer": "A rendering API that handles proxies and JavaScript is the most reliable approach.",
    "source_url": "https://example.com/google-scraping-tools",
    "children": []
  }
]

Jede Frage wird zu einem Knoten, und jede Erweiterung fügt weitere Knoten darunter unter children hinzu. Von hier aus ist der Export in CSV für eine Tabelle oder das Abflachen des Baums in ein Inhalts-Briefing nur noch wenige Zeilen entfernt. Da jeder Datensatz seine Quell-URL trägt, können Sie die Fragen auch nach den Domains gruppieren, die Google zitiert, um zu sehen, wer bereits die Antworten besitzt.

PAA länderübergreifend vergleichen

PAA-Ergebnisse sind nicht universell: Sie variieren je nach Standort und Sprache, weil Google sie auf den Markt des Suchenden personalisiert. Zum Vergleich führen Sie dieselbe Abfrage mit verschiedenen gl-Werten aus und vergleichen die Ergebnisse.

import time

query = "best running shoes"
markets = ["us", "uk", "de"]

by_market = {}
for gl in markets:
    items = scrape_with_expansions(query, gl=gl)
    by_market[gl] = {q["question"] for q in items}
    time.sleep(3)

# Questions unique to the UK market.
uk_only = by_market["uk"] - by_market["us"]
print(f"UK-only PAA questions: {len(uk_only)}")

Das Vergleichen einzigartiger Fragen, überlappender Themen und Unterschiede in Antworten über Märkte hinweg ist besonders nützlich, wenn Sie in eine neue Region expandieren oder Inhalte lokalisieren. Das time.sleep zwischen Anfragen staffelt den Lauf, damit Sie nicht hintereinander feuern. Für die Skalierung weit über eine Handvoll Abfragen hinaus ermöglicht Ihnen der asynchrone Crawler, URLs in großen Mengen einzureichen und Ergebnisse per Webhook zu empfangen, anstatt auf jeden Aufruf zu warten.

Nicht gesperrt bleiben

Auch wenn Rendering und eine vertrauenswürdige IP für Sie verwaltet werden, beobachtet Google scraper-artigen Traffic. Einige Gewohnheiten halten einen Lauf gesund.

• Pacing der Anfragen. Die SERP in einer engen Schleife zu hämmern ist der schnellste Weg zu Herausforderungen. Verteilen Sie Anfragen und variieren Sie Ihre Abfragen, anstatt einen Begriff mit voller Geschwindigkeit zu paginieren.
• Auf Rotation setzen. Ein Pool privater IPs verteilt Anfragen über viele echte Benutzeradressen, sodass keine einzelne ein Limit auslöst. Die Crawling API erledigt das für Sie. Wenn Sie Ihren eigenen Stack verwenden, ist das der Teil, den Sie richtig machen müssen.
• Status und Anzahlen überwachen. Ein Lauf, der anfängt, Herausforderungen zurückzugeben, oder eine PAA-Anzahl, die auf null fällt, signalisiert Ihnen, dass Rate, IP-Tier oder Selektoren Aufmerksamkeit benötigen. Behandeln Sie das als Signal, nicht als Rauschen.
• Erneut prüfen, wenn Felder leer werden. Google überarbeitet sein Markup periodisch. Wenn der PAA-Parse aufhört, Elemente zurückzugeben, öffnen Sie eine Live-Seite in den Entwicklertools und aktualisieren Sie die Selektorliste.

Für das umfassendere Playbook lesen Sie wie man Websites scrapt, ohne gesperrt zu werden. Wenn Sie die breitere Sicht auf jede SERP-Funktion jenseits von PAA möchten, behandelt unser Leitfaden zum Scrapen von Google-Suchseiten organische Ergebnisse, Anzeigen und das Knowledge Panel, und die fokussierte Python-Anleitung für Google-Suchergebnisse ist das begleitende How-to zu dieser hier. Sobald Sie PAA-Daten zur Hand haben, zeigen Google-SEO-Daten extrahieren und analysieren und gescrapte Daten zur SEO-Verbesserung nutzen, was Sie damit anfangen können.

Ist es legal, Google PAA zu scrapen?

Ob das Scrapen von Googles "People Also Ask"-Daten erlaubt ist, hängt von Googles Nutzungsbedingungen, Ihrer Gerichtsbarkeit und dem ab, was Sie mit den Daten tun. Das Scrapen öffentlich sichtbarer Suchergebnisse befindet sich in einer rechtlichen Grauzone: Die Fragen und Antworten in der PAA-Box werden jedem ohne Konto angezeigt, aber Googles Bedingungen schränken den automatisierten Zugriff ein, sodass ein Scraper unabhängig von der Sorgfalt des Toolings gegen diese Bedingungen verstoßen kann. Kein Code hier ändert das. Er lässt nur den technischen Teil funktionieren. Lesen Sie Googles Bedingungen und seine robots.txt, und behandeln Sie beides als Grenze für das, was Sie sammeln.

Einige Grundsätze, die es wert sind, eingehalten zu werden. Sammeln Sie nur öffentliche PAA-Daten: die Fragen, Antworten und zitierten Quell-URLs, die auf einer Ergebnisseite ohne Login erscheinen. Halten Sie Ihr Anfragevolumen niedrig genug, dass Sie Googles Server nicht belasten, und staffeln Sie Ihren Crawl, anstatt ihn mit voller Geschwindigkeit zu betreiben. Sammeln Sie keine persönlichen Daten, redistribuieren Sie keinen urheberrechtlich geschützten Antworttext en gros, und berühren Sie nichts hinter einem Login. Die zitierten Quell-URLs verweisen auf Seiten anderer Personen, behandeln Sie den dortigen Inhalt also unter seiner eigenen Lizenz, nicht als Ihres zum Weiterveröffentlichen.

Wo ein offizieller Weg existiert, bevorzugen Sie ihn. Google bietet Programmable Search und andere offizielle APIs für sanktionierten Zugriff auf Suchdaten an, und für produktionsskaligen Bedarf ist eine offizielle Datenvereinbarung der richtige Weg, kein ausgefeilterer Scraper. Dieser Leitfaden ist bewusst auf öffentliche PAA-Seiten beschränkt, denn das ist die Grenze, die die Arbeit vertretbar macht: Frage-Antwort-Paare, die jeder sehen kann, für Recherche und Content-Planung verwendet, nichts weiter.

Häufig gestellte Fragen

Was ist eine "People Also Ask"-Box?

Eine PAA-Box ist eine Google-SERP-Funktion, die einen Stapel ausklappbarer Frage-Antwort-Paare zur Suchanfrage zeigt. Sie erscheint in einem großen Teil der Suchanfragen und erweitert sich dynamisch beim Klicken und lädt jedes Mal zwei bis vier weitere verwandte Fragen, was sie zu einer so ergiebigen Quelle für Nutzerintentionsdaten für SEO und Content-Recherche macht.

Warum verpasst eine einfache Anfrage den PAA-Abschnitt?

Die PAA-Box wird von JavaScript gerendert, nachdem das anfängliche HTML lädt und aktualisiert sich erneut bei Interaktion, sodass eine rohe HTTP-Anfrage eine leere Hülle oder gar nichts zurückgibt. Das Abrufen über die Crawling API mit einem JavaScript-Token rendert die Seite in einem echten Browser und wartet auf die Skripte, sodass der PAA-Inhalt im HTML vorhanden ist, das Sie parsen.

Wie erfasse ich die verschachtelten PAA-Fragen?

Verwenden Sie den Parameter css_click_selector, damit die API auf jede sichtbare PAA-Frage klickt, bevor sie das HTML erfasst, was Google dazu bringt, die verwandten Fragen in das DOM zu laden. Parsen Sie das erweiterte HTML und vergleichen Sie es mit dem ersten Durchlauf, um die neuen Fragen unter dem children-Element jedes Elements zu sammeln. Eine dreistufige Erweiterung ergibt typischerweise zwölf bis zwanzig Gesamtfragen pro Abfrage.

Kann ich Google PAA mit Python scrapen?

Ja. Mit requests und BeautifulSoup rufen Sie die gerenderte SERP ab und ziehen die Frage, Antwort, Quell-URL und verschachtelten Kinder aus jedem PAA-Element heraus. Die Crawling API ist die Brücke, die Ihre Anfrage mit Rendering an Google von einer vertrauenswürdigen IP bringt. Für eine breitere Einführung lesen Sie unseren Leitfaden zum Scrapen von Websites mit Python.

Warum variiert PAA je nach Land?

Google personalisiert PAA-Ergebnisse nach dem Land und der Sprache des Suchenden, sodass dieselbe Abfrage in den USA und in Großbritannien oft unterschiedliche Fragen zurückgibt, weil Nutzerverhalten, Sprachmuster und verfügbare Inhalte je nach Markt unterschiedlich sind. Führen Sie dieselbe Abfrage mit verschiedenen gl-Werten aus und vergleichen Sie die Fragensätze, um die Unterschiede zu sehen, was bei der Lokalisierung von Inhalten nützlich ist.

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

Höchstwahrscheinlich Googles Markup. Google rotiert die verschleierten Klassennamen in seiner SERP, sodass Selektoren, die letzten Monat funktionierten, brechen und der Parser still eine leere Liste zurückgeben kann. Lesen Sie die Frage zuerst aus dem stabilen data-q-Attribut, halten Sie eine Liste von Fallback-Selektoren, protokollieren Sie, welcher bei jedem Lauf ausgelöst hat, und untersuchen Sie eine Live-Seite in den Entwicklertools, wenn die Anzahl sinkt.

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.