Am 16. November 2026 kam eine Anfrage an die Google Trends Explore-Seite für web scraping mit HTTP 200 zurück. Crawlbase meldete cb_status=200, und Googles eigene Antwort war protokolliert als original_status=200. Der Body sagte "Oops! There was a problem displaying this page" und bat darum, es erneut zu versuchen. Eine Keyword-Historie enthielt er nicht.
Der Explore-Markdown-Pfad tat das bei allen zwanzig ersten Versuchen. Neunzehn Bodies trugen die Oops-Meldung, einer einen reCAPTCHA-Hinweis. Eine Prüfung, die nur den HTTP-Status liest, hätte jeden einzelnen davon akzeptiert. Eine Pipeline muss feststellen, dass die angeforderten Trends-Daten tatsächlich angekommen sind, bevor sie die Anfrage als nützliche Arbeit zählt.
Dieser Beitrag folgt dem Begleit-Repository: Aufbau der Anfragen, Verarbeitung der Antworten, Parser, Inhaltsprüfungen, ein begrenzter Retry und die Belege, die das Harness aufgezeichnet hat. Die Crawling API liefert die Beschaffung und die integrierten Extraktionspfade. Die Anwendung entscheidet, welche zurückgegebenen Bodies ihre Datenanforderungen erfüllen. Die Zahlen stammen aus einer Region an einem Kalendertag und werden als Beobachtungen berichtet, nicht als Benchmark.
- HTTP 200 und
cb_status=200beschreiben das Dokument, das angekommen ist. Bei Google Trends kann dieses Dokument ein Fehlerhinweis sein. Lesen Sie den Body, bevor Sie die Antwort akzeptieren. - Die integrierten Scraper bestanden am häufigsten: Trending Now 20/20 und Explore 18/20 mit dem JavaScript token. Explore als Markdown mit dem Normal token bestand 0/20.
- Retry nach dem Verdikt, niemals nach dem Statuscode. Ein Retry, beide Versuche bleiben erhalten, und ein bestandener 200er wird nie wiederholt.
Das Diagramm trennt den Empfang eines Dokuments vom Empfang der benötigten Daten. Es benennt nicht, welche Browser-Anfrage oder welches Widget innerhalb von Google Trends fehlgeschlagen ist, und der Lauf hat das ebenfalls nicht festgestellt.
Wählen Sie die Trends-Oberfläche vor dem Abrufpfad
Der Test umfasst drei URLs. Das Interesse nach Subregion ist Teil der Explore-Antwort, daher brauchen Keyword-Historie und regionales Interesse in dieser Implementierung keine separaten Zielseiten.
| Oberfläche | URL im Test | Daten, die das Projekt nutzt |
|---|---|---|
| Trending Now | https://trends.google.com/trending?geo=US |
Trendende Suchanfragen, Suchvolumen-Labels, Wachstum, Startzeit, Status und Aufschlüsselungsbegriffe |
| Explore | https://trends.google.com/trends/explore?q=web scraping&geo=US&date=today 12-m |
Interesse im zeitlichen Verlauf, Interesse nach Subregion und verwandte Suchanfragen |
| Trending RSS | https://trends.google.com/trending/rss?geo=US |
Titel des Eintrags, ungefährer Traffic und Veröffentlichungsdatum |
Trending Now beantwortet, welche Suchen in der gewählten Region gerade stark zunehmen; das gespeicherte Scraper-Sample spiegelt den Filter "Past 24 hours" der Seite wider. Explore beantwortet, wie sich das Interesse an einem Begriff über einen gewählten Zeitraum verändert. Googles Dokumentation zu Trending Now nennt RSS als Exportoption, und der Feed reicht aus, wenn sein kleinerer Feldsatz die Aufgabe abdeckt.
Googles offizielle Trends-API-Alpha ist eine separate Schnittstelle. Der Zugang war zum Zeitpunkt des Laufs auf ausgewählte Tester beschränkt, und die öffentliche Übersicht führte keine Trending-Now-Daten auf. Sie wurde in diesem Projekt nicht aufgerufen. Das Projekt verzichtet außerdem auf die inoffizielle pytrends-Bibliothek, deren Repository am 17. April 2025 archiviert wurde, mit einem letzten Push vom 10. August 2024. Dieser Wartungsstatus zählt, wenn eine neue Pipeline eine Abhängigkeit auswählt.
Machen Sie den Anfragepfad explizit
Das Abrufpfad-Modul definiert fünf Anfrageformen. Jeder Pfad läuft über den Crawling-API-Endpunkt unter https://api.crawlbase.com/, einschließlich der Anfrage für den RSS-Feed.
| Pfad | Unterscheidende Parameter | In der Matrix verwendeter Token |
|---|---|---|
| Gerendertes HTML |
page_wait und ajax_wait=true
|
JavaScript token |
| Integrierter Scraper |
scraper=google-trends oder scraper=google-trends-explore
|
Normal für Trending Now; JavaScript für Explore |
| Markdown | format=md |
Normal token |
| No-wait-HTML | Ziel-URL ohne Wait-Parameter | JavaScript token |
| RSS-Abruf | Die RSS-Ziel-URL | Normal token |
Die No-wait-Kontrolle rendert weiterhin JavaScript. Ihr einziger Unterschied zum gerenderten Pfad ist das Fehlen der beiden expliziten Wait-Parameter. Ebenso beschreiben die Markdown-Ergebnisse den tatsächlich getesteten Markdown-Pfad mit Normal token. Jeder Vergleich in diesem Beitrag nennt seinen Token und seine Anfrageeinstellungen.
Der Request-Builder hält Token-Werte aus der Parametervorbereitung heraus. Für Scraper-Anfragen gibt er keine bevorzugte Token-Art zurück; der Aufrufer liefert die Wahl aus probe-config.json. Der Client liest dann das passende Secret und übergibt die Parameter an requests.Session.get() mit einem Timeout von 180 Sekunden:
def prepare( path: str, url: str, *, page_wait: int | None = None, ajax_wait: bool | None = None, scraper: str | None = None, store: bool = False, ) -> tuple[str | None, dict]: """Return (token_kind, params) for a path. token_kind is "js", "normal", or None. None means the caller chooses the token (the built-in scrapers do not name one). """ params = {"url": url} if store: params["store"] = "true" if path == "rendered": params["page_wait"] = str(page_wait) params["ajax_wait"] = "true" if ajax_wait else "false" return "js", params if path == "scraper": params["scraper"] = scraper or "" return None, params if path == "markdown": params["format"] = "md" return "normal", params if path == "nowait": return "js", params if path == "rss": return "normal", params raise ValueError(f"unknown path {path}")
Gerendertes Trending Now verwendet page_wait=5000 und ajax_wait=true. Gerendertes Explore verwendet page_wait=8000 und ajax_wait=true. page_wait ist eine feste Verzögerung in Millisekunden nach dem Laden der Seite. ajax_wait=true wartet, bis sich die Netzwerkaktivität beruhigt hat, bevor die Seite erfasst wird, und fügt keine eigene feste Verzögerung hinzu.
Halten Sie die Token-Entscheidung des Probe-Laufs nachprüfbar
Der Probe-Lauf macht dreizehn Zielaufrufe. Er probiert beide Token-Arten für jeden integrierten Scraper, die HTML- und Markdown-Pfade, RSS, eine separate Vergleichsabfrage und eine RSS-Anfrage mit aktivierter Speicherung. Außerdem zeichnet er Kontozusammenfassungen vorher und nachher auf, mit mindestens fünf Minuten zwischen den beiden Kontoaufrufen.
Die Roh-Bodies des Probe-Laufs sind nicht eingecheckt, daher lebt der Befund in der Konfiguration, die die Matrix liest: leere Chart-Objekte mit dem Normal token und 53 Zeitreihenpunkte mit dem JavaScript token. Die Matrix verwendet für Explore deshalb den JavaScript token:
{ "probed_on": "2026-11-16", "trending_scraper_token": "normal", "explore_scraper_token": "js", "trending_page_wait": 5000, "trending_ajax_wait": true, "explore_page_wait": 8000, "explore_ajax_wait": true, "store": false, "store_reason": "re-crawling the same URL with store=true replaces the stored copy, so it cannot keep 20 runs", "explore_scraper_token_reason": "On the 16 Nov 2026 probe the normal token returned empty chart objects. The JS token returned 53 timeline points."
Das Probe-Log enthält noch Verdikte, die vor der Korrektur der Envelope-Verarbeitung und der Inhaltsprüfungen erzeugt wurden, daher spiegeln diese ursprünglichen Verdikte nicht die endgültigen Regeln wider. Die Konfiguration ist Teil des reproduzierbaren Experiments. Ein frischer Probe-Lauf kann sie ersetzen. Prüfen Sie die Token-Auswahl, bevor Sie eine Matrix starten, denn die Matrix wechselt nach einer fehlgeschlagenen Antwort nie den Token und wählt keinen anderen Abrufpfad.
Lesen Sie die Antwortschichten, bevor Sie die Daten parsen
Der Fetch-Executor zeichnet den äußeren Status, den Crawlbase-Status, den Zielstatus, die finale URL, die verstrichene Zeit, die Body-Größe und die Domain-Komplexität auf. Eine Transport-Exception wird zu einem Ergebnis ohne HTTP-Antwort und mit leerem Body, wobei Token-Werte aus dem Exception-Text entfernt werden.
| Signal | Was es in diesem Projekt belegt |
|---|---|
| Äußerer HTTP-Status | Ob eine Antwort von Crawlbase angekommen ist, und mit welchem Status |
cb_status |
Crawlbases Crawl-Ergebnis; die Anwendung verlangt 200, bevor sie Inhalte akzeptiert |
original_status |
Googles gemeldeter HTTP-Status, in der CSV festgehalten |
| Anwendungsverdikt | Ob der Body die Prüfungen für die angeforderte Oberfläche und den Pfad erfüllt |
Scraper-Antworten brauchen einen zusätzlichen Schritt. Im beobachteten JSON-Envelope umgeben cb_status, original_status, domain_complexity und url ein inneres Objekt namens body mit den eigentlichen Daten. Der Executor entpackt diesen Envelope vor der Validierung. Wer nur auf Header schaut, würde die darin enthaltenen Metadaten übersehen, und genau das ging im ersten Probe-Lauf schief:
def unwrap_envelope(body: str): """Scrapers return a JSON envelope. The fields we check are under body.""" text = (body or "").lstrip("\ufeff").strip() if not text.startswith("{"): return body, None, None, None, None try: data = json.loads(text) except json.JSONDecodeError: return body, None, None, None, None if not isinstance(data, dict) or "body" not in data or "cb_status" not in data: return body, None, None, None, None inner = data.get("body") if isinstance(inner, (dict, list)): inner_text = json.dumps(inner) elif inner is None: inner_text = "" else: inner_text = str(inner) return ( inner_text, data.get("cb_status"), data.get("original_status"), data.get("domain_complexity"), data.get("url"), )
Der Executor misst body_bytes am ursprünglichen, als UTF-8 kodierten Antworttext vor dem Entpacken, daher enthält die Zahl bei Scraper-JSON den Envelope. Es ist keine komprimierte Übertragungsgröße. Die verstrichenen Millisekunden decken den Transportaufruf ab; der 180-Sekunden-Wert folgt der Timeout-Semantik von Requests und nicht einer strikten Wanduhr-Frist.
Das erste Akzeptanz-Gate liegt in assertions.py. Es entfernt Script- und Style-Blöcke sowie Tags und durchsucht dann den sichtbaren Text nach den konfigurierten Markern: der Oops-Meldung, reCAPTCHA, unusual traffic, /sorry/ und g-recaptcha. Das vorherige Entfernen der Scripts verhindert, dass der reCAPTCHA-Bibliotheksverweis einer normalen Seite als Challenge gelesen wird, und der Regressionstest test_recaptcha_script_on_a_data_page_is_not_a_challenge hält dieses Verhalten fest:
def _visible_text(body: str) -> str: """Drop scripts and tags so a library URL is not mistaken for a challenge.""" text = re.sub(r"(?is)<script\b[^>]*>.*?</script>", " ", body) text = re.sub(r"(?is)<style\b[^>]*>.*?</style>", " ", text) text = re.sub(r"(?is)<[^>]+>", " ", text) return text def challenge_reason(body: str) -> str | None: if not body: return None lowered = _visible_text(body).lower() for marker in CHALLENGE_MARKERS: if marker.lower() in lowered: return f"challenge marker: {marker}" return None def gate(body: str | None, cb_status: int | None) -> Verdict | None: """Return a failing verdict, or None when the body may be parsed.""" text = body or "" challenge = challenge_reason(text) if cb_status != 200: if challenge: return Verdict(False, f"cb_status {cb_status}, {challenge}") return Verdict(False, f"cb_status {cb_status}") if text.strip() == "": return Verdict(False, "empty body") if challenge: return Verdict(False, challenge) return None
Die Marker-Kategorie fasst Hinweise zusammen, die die Anwendung nicht verwenden kann. Eine Oops-Meldung allein sagt nicht, warum Google die Seite nicht anzeigen konnte. Und sobald das Gate einen Body zum Parser durchlässt, müssen die benötigten Daten noch ihre eigenen Prüfungen bestehen.
Parsen Sie die Felder, die die Aufgabe tatsächlich braucht
Die Parser wandeln jedes Antwortformat in die Werte um, die die Assertions erwarten. Der Check-Dispatcher wählt die Regeln für Oberfläche und Pfad aus und ergänzt die Behandlung von Transport, Sprache und Geografie.
Bei Trending-Now-Scraper-JSON liest der Parser das strukturierte Array trends aus. Bei HTML und Markdown sucht er zuerst nach sichtbaren englischen Volumenzeilen wie 20K+ searches und den Titeln davor, und er liest außerdem HTML-Tabellenzeilen und Markdown-Tabellen. Die Formatunterschiede sind explizit: Der strukturierte Scraper-Pfad prüft mehr Felder als die Markup-Pfade.
Das Explore-Parsing sucht zuerst nach strukturierten Chart-Daten, einschließlich eines im Dokument eingebetteten JSON-Objekts. Fehlen diese Felder, liest es sichtbare Zeilen unter englischen Abschnittsüberschriften. Die Zeitreihen-Extraktion aus sichtbarem Text erwartet ein Datums-Label wie Nov 16, 2026 gefolgt von einer Ganzzahl, sodass lokalisierte Überschriften oder Datumsangaben den Parser ohne Zeitreihe zurücklassen können, selbst wenn eine vollständige lokalisierte Seite angekommen ist.
| Antwort | Akzeptanzregeln, die die Anwendung implementiert |
|---|---|
| Trending-Now-Scraper-JSON | Mindestens zehn Datensätze; jeder Datensatz hat position, title, searchVolume, increasePercentage, started und status; trendsCount entspricht der Array-Länge |
| Trending Now HTML oder Markdown | Mindestens zehn extrahierte Zeilen, jede mit Titel und einem Volumen-Label, das dem erwarteten Muster entspricht |
| Explore | Mindestens 40 Zeitreihenwerte; jeder ganzzahlig und im Bereich 0 bis 100; das Maximum ist 100; die extrahierte Subregionsliste ist nicht leer |
| Explore-Scraper-Geografie | Ein erkanntes United-States-Label oder das Literal geo=US in der zurückgegebenen URL |
| RSS | Mindestens fünf Einträge, jeder mit Titel, ungefährem Traffic und Veröffentlichungsdatum |
Die Zeitreihen-Assertion akzeptiert Ganzzahlen, ganzzahlige Floats und Ganzzahl-Strings und lehnt Booleans ab. Sie validiert weder Datumsangaben noch chronologische Kontinuität, den angeforderten Begriff oder jeden regionalen Wert:
def assert_timeline(values) -> Verdict: if not isinstance(values, list) or len(values) < TIMELINE_FLOOR: count = len(values) if isinstance(values, list) else 0 return Verdict( False, f"timeline length {count} below {TIMELINE_FLOOR}", timeline_passed=False, ) numbers = [] for value in values: number = _as_int(value) if number is None: return Verdict( False, f"timeline value {value!r} is not an integer", timeline_passed=False, ) if number < 0 or number > 100: return Verdict( False, f"timeline value {number} outside 0 to 100", timeline_passed=False, ) numbers.append(number) if max(numbers) != 100: return Verdict(False, "timeline max is not 100", timeline_passed=False) return Verdict(True, "ok", timeline_passed=True)
Diese Schwellenwerte gehören zur US-Abfrage dieses Experiments über today 12-m. Vierzig Punkte sind eine Mindestabdeckungsregel, keine Definition eines vollständigen Jahres. Die Anforderung eines Spitzenwerts von 100 passt zum Einzelserien-Chart, das dieses Harness erwartet, und sollte nicht zur Behauptung werden, jede Trends-Antwort ohne eine 100 sei ein kaputter Parse. Die Geografie-Anforderung gilt nur für den Explore-Scraper-Pfad; die HTML- und Markdown-Pfade erzwingen sie nicht.
Bewahren Sie die Bedeutung der Zahlen
Die Zeitreihenwerte von Explore sind normalisierte Interessenswerte. Googles Erklärung der Trends-Normalisierung beschreibt das relative Suchinteresse für eine Zeit und einen Ort, skaliert auf 0 bis 100. Ein Wert von 50 sind nicht fünfzig Suchen. Eine Null kann geringes Suchvolumen bedeuten; sie ist nicht automatisch eine fehlende Beobachtung. In diesem Projekt ist eine leere Zeitreihe eine fehlgeschlagene Extraktion, während eine Zeitreihe mit Nullen als Wertereihe geprüft wird.
Das searchVolume von Trending Now ist eine andere Messgröße. Labels wie 1M+ sind in Klassen eingeteilter Suchtraffic, und increasePercentage ist das Wachstum gegenüber einer vorhergesagten Basislinie. Die Implementierung belässt diese Strings, wie sie sind. Sie macht aus 1M+ keine exakte Zahl, wandelt die relativen Labels von started nicht in Zeitstempel um und leitet keine absoluten Suchzahlen aus Explore-Werten ab.
Der Subregions-Parser behält die Regionsnamen für die Prüfung auf eine nicht leere Liste. Das Bestehen dieser Prüfung verifiziert weder jeden regionalen Wert noch ruft es jede Seite der Regionen ab. Der Scraper lieferte die ersten fünf Subregionen, die die getestete Seite anzeigt, zusammen mit einer Gesamtzahl und Paginierungstext, und das Projekt hat den Rest nicht durchgeblättert.
Das Diagramm gruppiert die Prüfungen nach Zweck. Die oben verlinkten Funktionen legen die tatsächliche Reihenfolge fest und welche Prüfungen für jedes Antwortformat gelten.
Wiederholen Sie ein fehlgeschlagenes Verdikt und behalten Sie beide Versuche
Das Harness erhält drei Callables: fetch, check und sleep. Seine Retry-Entscheidung folgt dem Verdikt, und jeder Versuch in einem abgeschlossenen Batch wird zu einem eigenen Datensatz mit Statuswerten, Timing, Body-Größe, Verdikt, Begründung und Diagnostik:
def run_with_retry(fetch, check, sleep, *, surface, path, run, date=""): """Fetch and check. Sleep and try once more only if the check fails.""" attempts = [] for attempt in (1, 2): result = fetch() verdict = check(result) attempts.append( Attempt( surface=surface, path=path, run=run, attempt=attempt, date=date, latency_ms=result.latency_ms, body_bytes=result.body_bytes, credits=getattr(result, "credits", None), passed=verdict.passed, reason=verdict.reason, related_flagged=getattr(verdict, "related_flagged", None), related_share=getattr(verdict, "related_share", None), timeline_passed=getattr(verdict, "timeline_passed", None), http_status=getattr(result, "http_status", None), cb_status=getattr(result, "cb_status", None), original_status=getattr(result, "original_status", None), target_url=getattr(result, "target_url", ""), final_url=getattr(result, "final_url", None), my_location=getattr(verdict, "my_location", None), classic_banner=getattr(verdict, "classic_banner", None), selected_geo=getattr(verdict, "selected_geo", None), domain_complexity=getattr(result, "domain_complexity", None), ) ) if verdict.passed: break if attempt == 1: sleep(10) return attempts
Ein bestandener erster Versuch beendet die Schleife. Ein fehlgeschlagener erster Versuch erhält nach zehn Sekunden einen Retry derselben konfigurierten Anfrage. Abgeschlossene Batches behalten separate CSV-Zeilen für den ersten Versuch und seinen Retry, auch wenn der Retry besteht.
Der Matrix-Runner besucht in jeder Runde die neun anwendbaren Zellen mit jeweils einer laufenden Anfrage und wartet nach dem Batch jeder Zelle drei Sekunden. Braucht eine Zelle einen Retry, findet die Zehn-Sekunden-Wartezeit innerhalb dieses Batches statt, daher behaupten die Abstände nicht exakt drei Sekunden zwischen jedem Aufrufpaar.
Die Matrix vom 16. November machte 221 Zielaufrufe: 180 erste Versuche und 41 Retries. Die Retries folgten den während dieses Laufs geltenden Regeln. Das spätere Anwenden korrigierter Prüfungen änderte die Bewertung der gespeicherten Antworten; es änderte nicht, welche Anfragen wiederholt worden waren.
Die Zusammenfassung gruppiert Datensätze nach Oberfläche und Pfad und zählt nur attempt == 1 für Bestanden-Zahlen, Median-Latenz und Median-Body-Größe. Diese Mediane umfassen bestandene wie fehlgeschlagene erste Versuche, sodass die Ergebnistabelle anfängliche Zuverlässigkeit nicht mit Wiederherstellung vermischt:
def summarise(attempts): """First-attempt pass rate, median latency, median body size, credit sum.""" keys = sorted({(item.surface, item.path) for item in attempts}) rows = [] for surface, path in keys: first = [ item for item in attempts if item.surface == surface and item.path == path and item.attempt == 1 ] runs = len(first) passes = sum(1 for item in first if item.passed) known = [item.credits for item in first if item.credits is not None] rows.append( { "surface": surface, "path": path, "runs": runs, "passes": passes, "pass_rate": (passes / runs) if runs else None, "median_latency_ms": median([item.latency_ms for item in first]), "median_body_bytes": median([item.body_bytes for item in first]), "credits": sum(known) if known else None, } ) return rows
Was zurückkam
Die Tabelle berichtet den Lauf vom 16. November 2026 mit den korrigierten Prüfungen, angewandt auf seine gespeicherten Antworten. Jede Zeile enthält zwanzig erste Versuche. Explore verwendete die feste Abfrage web scraping, geo=US und date=today 12-m; Trending Now und RSS verwendeten geo=US ohne Keyword.
| Oberfläche | Pfad | Bestanden, erster Versuch | Bestanden, englische Seiten | Median-Latenz (ms) | Median-Body (Bytes) |
|---|---|---|---|---|---|
| Trending Now | Integrierter Scraper | 20/20 | 20/20 | 10.607 | 6.864 |
| Trending Now | Markdown | 20/20 | n/a, kein Sprach-Tag | 11.151 | 5.110 |
| Trending Now | Gerendertes HTML | 18/20 | 18/18 | 26.077 | 2.351.950 |
| Trending Now | No-wait-HTML | 15/20 | 15/15 | 19.735 | 2.323.239 |
| Explore | Integrierter Scraper | 18/20 | 14/16 | 26.029 | 4.075 |
| Explore | Markdown | 0/20 | n/a, kein Sprach-Tag | 44.669 | 475 |
| Explore | Gerendertes HTML | 17/20 | 17/17 | 27.493 | 705.602 |
| Explore | No-wait-HTML | 15/20 | 15/16 | 34.444 | 686.376 |
| Trending RSS | RSS-Abruf | 20/20 | n/a, XML | 2.850 | 22.028 |
Die Spalte der englischen Seiten nutzt bei HTML-Antworten das HTML-Sprach-Tag und bei Scraper-JSON die Sprache des Geografie-Labels. Sie schließt identifizierte nicht-englische Seiten und den Transportfehler aus. Für Markdown und RSS wurde keine Sprachklassifikation aufgezeichnet, daher steht in diesen Zellen n/a. Die Spalte der ersten Versuche zählt alle zwanzig Versuche pro Pfad, einschließlich der Fehlschläge auf lokalisierten Seiten.
Die ursprüngliche CSV behält die während des Live-Laufs verwendeten Verdikte. Die korrigierten Bestanden-Zahlen sowie die Zeit- und Größenangaben lassen sich neu berechnen aus der neu bewerteten CSV. Mediane sind auf ganze Millisekunden und Bytes gerundet. Credits wurden nicht gemessen.
Trending Now: strukturierte Datensätze bei einem Bruchteil der Größe
Der integrierte Trending-Now-Scraper bestand 20 von 20 ersten Versuchen, mit einer Median-Latenz von 10.607 Millisekunden und einer Median-Antwort von 6.864 Bytes. Dies ist der erste Datensatz aus dem gekürzten Zwei-Trend-Sample:
{ "position": 1, "title": "steelers vs bengals", "searchVolume": "1M+", "searchVolumeText": "1M+ searches", "increasePercentage": "1,000%", "started": "19 hours ago", "status": "Active", "trendBreakdown": [ "bengals vs steelers", "joe burrow", "ja'marr chase" ], "trendBreakdownMoreCount": 78 },
Das Sample behält das ursprüngliche trendsCount=25 und die Paginierungs-Metadaten, enthält zur Veranschaulichung aber nur zwei Datensätze. Es ist ein gekürztes Live-Sample, kein vollständiger Body für die Zehn-Datensätze-Assertion.
Gerendertes Trending-Now-HTML bestand 18 von 20, mit einem Median-Body von 2.351.950 Bytes. Die neu bewertete CSV identifiziert beide Fehlschläge als portugiesische Seiten, die der englische Parser nicht lesen konnte; Französisch taucht unter den No-wait-Fehlschlägen von Trending Now auf. Die rein englische gerenderte Teilmenge bestand 18 von 18.
Trending Now Markdown bestand ebenfalls 20 von 20, mit einem Median-Body von 5.110 Bytes, indem es die geforderten englischen Titel-und-Volumen-Muster traf. Das Bestehen dieser Prüfung bedeutet nicht, dass die sechs bei Scraper-JSON validierten Felder auch bei Markdown validiert wurden.
Explore: ein 200er, der an jeder Inhaltsprüfung scheitert
Explore Markdown bestand 0 von 20 ersten Versuchen. Alle zwanzig verzeichneten HTTP 200, cb_status=200 und original_status=200. Neunzehn enthielten die Oops-Meldung und einer den reCAPTCHA-Hinweis. Über erste Versuche und Retries hinweg erschien die Oops-Meldung in 36 der vierzig gespeicherten Explore-Markdown-Bodies. Dies ist das gespeicherte Fehler-Sample, mit entfernter Cookie-Banner-Zeile:
Oops! There was a problem displaying this page. Please try again Google apps Please upgrade to a [supported browser](https://support.google.com/recaptcha/?hl=en#6223828) to get a reCAPTCHA challenge. [Why is this happening to me?](https://support.google.com/recaptcha#6262736)
Der Pfad lieferte ein kleines, parsbares Dokument mit einem Median-Body von 475 Bytes und nichts von den benötigten Keyword-Daten.
Gerendertes Explore-HTML bestand 17 von 20, mit einer Median-Latenz von 27.493 Millisekunden und einem Median-Body von 705.602 Bytes. Seine drei Fehlschläge waren nicht-englische Seiten; die rein englische Teilmenge bestand 17 von 17. Die No-wait-Kontrolle für Explore bestand 15 von 20: drei nicht-englische Seiten, ein Transportfehler ohne Antwort-Body und eine englische Seite mit leerer extrahierter Zeitreihe. Der Vergleich stützt die aufgezeichnete Wait-Konfiguration für diesen Fall. Zwanzig Versuche pro Pfad belegen nicht, dass ein Wait jedes leere Chart behebt.
Explore-Scraper: die ursprüngliche und die korrigierte Bewertung
Der Explore-Scraper bestand ursprünglich 14 von 20 ersten Versuchen. Vier weitere Antworten hatten Zeitreihen und Subregionen, scheiterten aber an der ursprünglichen Geografie-Regel, weil das United-States-Label lokalisiert war: Spanisch oder Portugiesisch, Russisch oder Niederländisch. Die korrigierten Prüfungen akzeptieren erkannte lokalisierte Labels und greifen für den Scraper-Pfad auf geo=US in der Antwort-URL zurück.
Die Neubewertung derselben Bodies hob die Zahl der ersten Versuche auf 18 von 20, und ein Retry mit polnischem Label wechselte von Fehlschlag zu Bestanden. Der Neubewertungsbericht verzeichnet insgesamt 23 geänderte Verdikte: fünf Wechsel zwischen Bestanden und Fehlschlag und achtzehn geänderte Begründungen, wobei vier der fünf Bestanden/Fehlschlag-Wechsel auf erste Versuche entfallen.
Die beiden verbliebenen Fehlschläge des korrigierten Scrapers bei ersten Versuchen waren leere Zeitreihen auf englischen Seiten. Seine Teilmenge mit englischem Label lag unter beiden Regelversionen bei 14 von 16. Seine Median-Antwort betrug 4.075 Bytes gegenüber 705.602 Bytes für gerendertes Explore-HTML. Der Scraper verkleinerte die Antwort, die die Anwendung verarbeiten musste, um zwei Größenordnungen und behielt dabei die Zeitreihe und die angezeigten Subregionen.
Sprache erklärt einen Großteil der Lücke zwischen roh und gefiltert
Siebzehn erste Versuche wurden als lokalisierte Seiten oder lokalisierte Scraper-Labels identifiziert. Dreizehn scheiterten am englischen Parser, verteilt über russische, türkische, slowakische, hebräische, ukrainische, französische, portugiesische, chinesische und persische Seiten. Die anderen vier waren die Explore-Scraper-Antworten, die nach der Geografie-Korrektur akzeptiert wurden. Der Dispatcher kennzeichnet diese Parse-Fehler, damit eine lokalisierte vollständige Seite nicht als leeres Widget gemeldet wird:
def check_result(surface: str, path: str, result, term: str = TERM): verdict = _check(surface, path, result, term) if verdict.passed: return verdict lang = page_lang(result.body or "") if ( lang and not lang.lower().startswith("en") and surface in ("trending", "explore") and verdict.reason.startswith(LOCALE_SENSITIVE) ): return dataclasses.replace( verdict, reason=f"non-English page ({lang}), localized labels not read: {verdict.reason}", ) return verdict
Dieses Label ist eine Parser-Einschränkung, die an lokalisiertem Inhalt beobachtet wurde. Es belegt nicht, dass Googles Widgets leer waren, und es macht diese Antworten für die aktuelle Anwendung nicht nutzbar, daher bleiben sie in der rohen Bestanden-Zahl Fehlschläge.
Es wurde keine Spracheinstellung gesendet. Variation mit der Anfrageroute ist eine plausible Erklärung für die wechselnde Seitensprache, aber der Lauf beweist diesen Mechanismus nicht. Das Hinzufügen von hl=en-US ist ein sinnvolles nächstes Experiment, keine in diesen Ergebnissen enthaltene Kontrolle. Der Beitrag berichtet eine Region und einen Kalendertag, ohne Matrix für einen zweiten Tag oder mit festgelegter Sprache.
Prüfen Sie Diagnostik, die eine bestandene Zeitreihe verbergen kann
Die strukturelle Validierung fängt in diesem Lauf die Fehlerseiten und die leeren Zeitreihen ab. Sie lässt außerdem Raum, verdächtige Felder festzuhalten, ohne einen nutzbaren Teil der Antwort zu verwerfen.
Verwandte Suchanfragen passten nicht zum angeforderten Begriff
Von den 59 ersten Versuchen, die das Flag für verwandte Suchanfragen aufzeichneten, teilte in keinem ein verwandter Begriff ein Token mit web scraping, und diese Zahl umfasst Antworten, deren Liste verwandter Suchanfragen leer war. Der Bericht schreibt den Begriff klein, extrahiert alphanumerische Tokens von mindestens drei Zeichen, ergänzt einen einfachen Stamm für passende Wörter auf -ing und sucht diese Tokens als Teilstrings in den verwandten Namen:
def term_tokens(term: str) -> list[str]: tokens = [] for word in re.findall(r"[a-z0-9]+", term.lower()): if len(word) < 3: continue tokens.append(word) if word.endswith("ing") and len(word) > 5: stem = word[:-3] if len(stem) >= 3: tokens.append(stem) return tokens def related_report(term: str, names) -> tuple[bool, float]: """Return (flagged, share). Flagged when no query shares a term token.""" queries = [name for name in (names or []) if name] if not queries: return True, 0.0 tokens = term_tokens(term) hits = 0 for name in queries: lowered = str(name).lower() if any(token in lowered for token in tokens): hits += 1 share = hits / len(queries) return hits == 0, share
Eine leere Liste wird ebenfalls geflaggt, daher ist related_flagged=True allein kein Beweis, dass eine nicht leere Liste angekommen ist. Dies ist eine diagnostische Heuristik, kein semantisches Relevanzmodell, und die Anwendung lässt das Zeitreihen-Verdikt bewusst unangetastet, wenn die Liste verwandter Suchanfragen geflaggt ist. Die beobachteten unzusammenhängenden Begriffe rechtfertigen eine Prüfung der Query-Bindung, bevor verwandte Suchanfragen weiterverarbeitet werden; dieser Lauf hat ihre Ursache nicht festgestellt.
"My location" unterschied sich von der gewählten Suchregion
Trending-Now-HTML zeigte über 33 Zeilen erster Versuche fünfzehn verschiedene Länder in seinem Label "My location". Indien erschien achtmal; Vietnam, Indonesien und Libanon je dreimal. Die gewählte Trend-Region blieb in allen 33 Zeilen United States. Der Parser speichert my_location separat von selected_geo. Nutzen Sie die gewählte Trends-Geografie, um den Umfang der Daten zu bestimmen. Dass "My location" der Anfrageroute folgt, ist eine Schlussfolgerung aus diesen Beobachtungen, keine dokumentierte Garantie von Google.
Classic Explore zeigte ein Ablauf-Banner an
Das Banner "Classic Explore is expiring soon" erschien auf siebzehn von zwanzig gerenderten Explore-Seiten und sechzehn von zwanzig No-wait-Seiten. Das JSON des integrierten Scrapers enthielt es nicht. classic_banner hält sein Vorhandensein fest, ohne es als Bestehensbedingung zu nutzen. Das Banner nennt kein Migrationsdatum, ist aber ein operativer Grund, repräsentative Prüfungen erneut auszuführen, wenn sich die Explore-Oberfläche ändert, besonders bei Parsern, die an sichtbare Überschriften und Datumsformate gebunden sind.
Passen Sie die Methode an die Aufgabe an
Der aufgezeichnete Lauf stützt diese Ausgangspunkte:
| Aufgabe | Zu verwendender Pfad | Belege, 16. November 2026 |
|---|---|---|
| Täglicher Trend-Feed | Integrierter Trending-Now-Scraper, oder RSS, wenn Titel, ungefährer Traffic und Veröffentlichungsdatum ausreichen | Scraper 20/20, Median 10.607 ms; RSS 20/20, Median 2.850 ms |
| Keyword-Historie | Integrierter Explore-Scraper mit dem JavaScript token | 18/20 unter der korrigierten Geografie-Regel; zwei leere Zeitreihen |
| Regionale Aufschlüsselung | Subregionsliste des integrierten Explore-Scrapers | In derselben Antwort zurückgegeben; die ersten fünf angezeigten Subregionen, nicht die vollständige Liste |
| Agent-Tool-Aufruf | Integrierter Trending-Now-Scraper als JSON | 20/20; strukturierte Felder lassen sich prüfen, bevor Daten an den Aufrufer zurückgehen |
Das 0/20-Ergebnis von Explore Markdown gilt für den getesteten Pfad mit Normal token. Diese Ergebnisse sind eine Grundlage, um eine Konfiguration zu wählen, die Sie an Ihrer eigenen Zielabfrage verifizieren, kein Ersatz für diese Verifikation.
Führen Sie die Implementierung aus und verifizieren Sie, was sich geändert hat
Das vollständige Paket importiert die drei Schrittmodule über load_steps.py, sodass die oben zitierten Anfrageformen, Assertions und die Retry-Funktion der Code sind, den die CLI ausführt. Die finale Suite hat dreißig Tests, die Assertions, Parser-Verhalten, Envelope-Verarbeitung, Token-Schwärzung, Retries, die Obergrenze abrechenbarer Antworten, Statistik und CLI-Ausführung abdecken. Ihr Paritätstest übt die gemeinsame Harness-Zusammenfassung aus; er validiert die Live-Antworten von Google nicht erneut.
Die Requirements deklarieren requests>=2.32 und pytest>=8 ohne feste Versionen. Der aufgezeichnete Lauf nutzte Python 3.13. Kopieren Sie die Umgebungsvorlage nach .env innerhalb von final/ und setzen Sie CRAWLBASE_TOKEN und CRAWLBASE_JS_TOKEN aus Ihrem Crawlbase-Konto. Die Datei ist gitignored. Der Client fügt das Secret nur an der HTTP-Grenze hinzu, sein Log hält die Token-Art fest, und gespeicherte Bodies sowie Exception-Meldungen werden um die konfigurierten Secrets bereinigt. Vom Repository-Root aus:
cd final cp .env.example .env # add CRAWLBASE_TOKEN and CRAWLBASE_JS_TOKEN python -m pytest -q python -m trends_probe --offline --date 2026-11-16 python -m trends_probe --matrix --runs 20 --max-billable 400 --date 2026-11-16 --geo US
Die pytest- und Offline-Befehle machen keine Live-Zielaufrufe. Der Matrix-Befehl macht Live-Aufrufe und verbraucht Credits. Sein Argument --date beschriftet die Ausgabe; es fordert keinen historischen Snapshot an, und today 12-m wird aufgelöst, wenn Google die Anfrage bedient. Die README deckt die Einrichtung unter Windows, Linux und macOS ab.
Halten Sie Fixtures und Live-Belege getrennt
Der Offline-Befehl nutzt synthetische Fixtures: eine minimale Zeitreihe, Beispiel-Trends, RSS-Einträge, einen Oops-Body und eine leere Antwort. Seine Zusammenfassung weist sich selbst als Fixture-Lauf aus. Diese Ergebnisse zeigen das Programmverhalten und dürfen nicht als zusätzliche Live-Versuche gezählt werden.
Für Live-Läufe speichert die CLI für jeden Aufruf einen bereinigten Body unter results/raw/matrix/ und sichert abgeschlossene Batches als Checkpoints in CSV. Das öffentliche Repository enthält sowohl die aufgezeichneten CSVs als auch die gekürzten Live-Samples; das vollständige Roh-Body-Verzeichnis ist gitignored.
--report baut die Zusammenfassung aus aufgezeichneten Verdikten neu auf. --rescore braucht die passenden lokalen Roh-Bodies, wendet die aktuellen Prüfungen erneut an und schreibt eine separate CSV und einen Markdown-Bericht mit dem Suffix -rescored ohne neue Zielanfragen. Bewahren Sie das Roh-Verzeichnis jedes Laufs mit seiner CSV auf, bevor Sie eine weitere Matrix starten: Body-Dateinamen beginnen ihren Aufrufzähler neu, und die Neubewertung paart Zeilen mit Dateien in Aufrufreihenfolge, nachdem sie deren Oberfläche und Pfad geprüft hat.
Die Matrix verwendet store=False und nutzt nie einen früheren erfolgreichen Body als Fallback. Eine Probe-Anfrage testete store=true mit Crawlbase Cloud Storage. Ihr Log verzeichnete den Header storage_url und keine separate rid; der Bezeichner erscheint nur im Query-String dieser URL. Die eingecheckte Konfiguration vermerkt, dass das erneute Speichern derselben URL die gespeicherte Kopie ersetzt. Der Lauf behielt deshalb einzelne lokale Bodies zum Vergleich. Die Crawling-API-Referenz dokumentiert eine rid für gespeicherte Anfragen; diese Implementierung hängt nicht von diesem Bezeichner ab.
Halten Sie Anfragezahlen und Credit-Verbrauch getrennt
Die Matrix zählte 220 abrechenbare Antworten gegen ihre konfigurierte Obergrenze von 400. Die Obergrenze zählt Antworten, nicht Credits. Der lokale Klassifikator schaut hauptsächlich auf cb_status:
BILLABLE = {200, 207} class BudgetStop(Exception): """The billable cap was reached before the matrix finished.""" def is_billable(result) -> bool: if result.cb_status in BILLABLE: return True if result.cb_status is None and result.http_status == 200 and not result.error: return True return False
Crawlbases dokumentierte Abrechnungsregel berücksichtigt auch original_status. In dieser aufgezeichneten Matrix hatten alle 220 empfangenen Antworten cb_status=200 und original_status=200, und der verbleibende Aufruf war der Transportfehler, daher stimmen die beiden Regeln auf diesen Daten überein. Ein Body kann die Prüfungen dieser Anwendung nicht bestehen und trotzdem die Abrechnungsstatus erfüllen. Die unbrauchbaren Explore-Markdown-Antworten taten genau das. Die Bestanden-Zahl der Anwendung und ihre Zahl abrechenbarer Antworten beantworten unterschiedliche Fragen.
Credits wurden nicht gemessen. Es wurde kein Credit-Header aufgezeichnet, und die Kontozusammenfassungen des Probe-Laufs kamen mit null-Nutzungsfeldern zurück. Das ist ein Lesefehler im Helfer, kein leeres Konto: Die Account API verschachtelt die Monatssummen unter currentMonth, und der Helfer liest totalSuccess und die anderen Felder auf oberster Ebene, daher sind sie immer null. Diese Zusammenfassungen belegen kein gemessenes Nutzungsdelta:
def account(self): token = self._token("normal") try: response = self._session.get( "https://api.crawlbase.com/account", params={"token": token, "product": "crawling-api"}, timeout=60, ) except Exception as exc: return {"error": self._fetch.scrub(str(exc), self._secrets())} try: payload = response.json() except ValueError: return {"error": "account response was not JSON", "http_status": response.status_code} return { "http_status": response.status_code, "totalSuccess": payload.get("totalSuccess"), "totalFailed": payload.get("totalFailed"), "totalDue": payload.get("totalDue"), "remainingCredits": payload.get("remainingCredits"), }
Alle 220 empfangenen Matrix-Antworten verzeichneten complex als Stufe. Gelten die dokumentierten Credit-Multiplikatoren, verbraucht eine Complex-Anfrage zwei Credits, und JavaScript-Rendering verdoppelt das. Die Matrix enthielt 100 empfangene Antworten mit Normal token und 120 empfangene Antworten mit JavaScript token:
Geschätzter Matrix-Verbrauch: (100 × 2) + (120 × 4) = 680 Credits.
Das ist eine Schätzung aus dem aufgezeichneten Token-Mix, kein Kontowert, und sie schließt den Probe-Lauf aus. Die Produktseite des Google-Scrapers wirbt mit bis zu 5.000 kostenlosen Anfragen; prüfen Sie den tatsächlichen Credit-Stand und die geltenden Multiplikatoren, bevor Sie ein Kontingent als Anzahl von Explore-Aufrufen lesen.
Der Runner ist seriell, nutzt die oben beschriebenen Wartezeiten und stoppt vor einer weiteren Anfrage, sobald seine Obergrenze abrechenbarer Antworten erreicht ist. Unterbricht eine niedrigere Obergrenze einen Batch zwischen einem fehlgeschlagenen ersten Versuch und seinem Retry, kann der aktuelle Runner diesen Teil-Batch aus der CSV auslassen; im aufgezeichneten Lauf kam das nicht vor. Innerhalb der Obergrenze erhält ein Challenge-Hinweis denselben einzelnen Retry wie jedes andere fehlgeschlagene Verdikt, und die Anwendung ergänzt keine CAPTCHA-Lösungslogik. Lesen Sie Googles Nutzungsbedingungen zur vorgesehenen Nutzung und wählen Sie einen Zeitplan, der zur Aktualität passt, die Ihre Aufgabe braucht. Das Web benotet jetzt seine Crawler behandelt den weiteren Kontext zu Pacing und Crawler-Verhalten.
Fazit
Der Lauf vom 16. November zeigte, warum nutzbare Google-Trends-Daten eine eigene Akzeptanzprüfung brauchen. Jede empfangene Matrix-Antwort meldete erfolgreiche HTTP- und Crawl-Status, dennoch lieferte Explore Markdown keine nutzbaren Zeitreihen, einige englische Explore-Antworten hatten leere Charts, und lokalisierte Seiten zeigten die Grenzen des Markup-Parsers auf.
Die integrierten Scraper von Crawlbase lieferten kompakte strukturierte Antworten: Trending Now bestand 20/20, und der Explore-Scraper mit JavaScript token bestand 18/20 nach der Geografie-Korrektur. Die Anwendung machte diese Ergebnisse nachprüfbar, indem sie Status bewahrte, die benötigten Felder prüfte, Diagnostik von Akzeptanz trennte und jeden Retry als eigenen Versuch behielt.
Beginnen Sie mit dem dokumentierten Google Trends Scraper oder Google Trends Explore Scraper, wenden Sie Prüfungen an, die zu den angeforderten Daten passen, und bewahren Sie repräsentative Bodies auf, wann immer sich ein Verdikt ändert. Das gibt der Pipeline eine Definition von Erfolg, die über den Empfang eines 200ers hinausgeht.
Holen Sie Google Trends als gerendertes HTML, Markdown oder strukturiertes JSON aus den integrierten Trending-Now- und Explore-Scrapern, mit cb_status und original_status in jeder Antwort, damit Ihre eigenen Prüfungen entscheiden, was zählt. Starten Sie mit bis zu 5.000 kostenlosen Anfragen, ohne Karte.
Häufig gestellte Fragen (FAQ)
Können HTTP 200 und cb_status=200 beweisen, dass Google-Trends-Daten nutzbar sind?
Sie belegen die gemeldeten Beschaffungsstatus. Dieser Lauf lieferte unter diesen Status trotzdem Oops-Seiten, einen reCAPTCHA-Hinweis und leere Zeitreihen. Verlangen Sie die Felder und die Abdeckung, die Ihre Anwendung braucht, bevor Sie die Daten akzeptieren. Ein fehlgeschlagenes Anwendungsverdikt macht eine empfangene Antwort auch nicht nicht-abrechenbar.
Erfordert das Scraping von Google Trends immer den JavaScript token?
Die Token-Wahl hängt von Oberfläche und Pfad ab. Trending-Now-Scraper-JSON, Trending Now Markdown und RSS bestanden in dieser Matrix mit dem Normal token. Der Explore-Scraper nutzte den JavaScript token, nachdem die Normal-token-Antwort des Probe-Laufs mit leeren Chart-Objekten zurückkam. Gerendertes und No-wait-HTML nutzten beide JavaScript tokens. Das Harness wiederholt die konfigurierte Anfrage, ohne eigenständig den Token zu wechseln.
Sind Explore-Werte und Trending-Now-Suchvolumen-Labels dieselbe Messgröße?
Nein. Explore-Werte sind normalisierte Interessenswerte für die gewählte Zeit und Geografie. Trending-Now-Labels wie 1M+ sind in Klassen eingeteilter Traffic für den gewählten Trendzeitraum. Bewahren Sie die Bedeutung jedes Felds: Weder ein Explore-Wert von 100 noch ein Label 1M+ ist eine exakte Zahl von Suchen, die diese Anwendung rekonstruieren kann.
Lassen sich dieselben Prüfungen für ein anderes Land oder einen kürzeren Zeitraum nutzen?
Passen Sie sie zuerst an. Die Option --geo der CLI ändert die angeforderten URLs, aber die Akzeptanzregel des Explore-Scrapers erwartet weiterhin die United States. Das 40-Punkte-Minimum und die Prüfung auf einen Spitzenwert von 100 wurden für ein festes Experiment mit einem Begriff über zwölf Monate gewählt, und lokalisiertes Markup kann Parser-Änderungen erfordern. Testen Sie die vorgesehene Geografie, Sprache und das Zeitfenster mit passenden Assertions, bevor Sie deren Bestehensquote mit diesem Lauf vergleichen.
Crawlen Sie jede Website im großen Maßstab, ohne gegen die Infrastruktur zu kämpfen.
Crawlbase übernimmt Proxys, Fingerprints und CAPTCHAs, damit Ihr Team Daten-Pipelines liefert, statt Crawl-Infrastruktur zu warten. Bis zu 5.000 Requests kostenlos, keine Karte erforderlich.

