Le 16 novembre 2026, une requête vers la page Google Trends Explore pour web scraping est revenue avec un HTTP 200. Crawlbase a rapporté cb_status=200, et la propre réponse de Google a été enregistrée comme original_status=200. Le corps disait "Oops! There was a problem displaying this page" et invitait le lecteur à réessayer. Il ne contenait aucun historique de mot-clé.
Le chemin Explore Markdown a fait cela sur les vingt premières tentatives. Dix-neuf corps portaient le message Oops et un portait un avis reCAPTCHA. Une vérification qui ne lit que le statut HTTP les aurait tous acceptés. Un pipeline doit établir que les données Trends demandées sont réellement arrivées avant de compter la requête comme du travail utile.
Cet article suit le dépôt compagnon: construction des requêtes, traitement des réponses, parseurs, vérifications de contenu, une nouvelle tentative bornée et les preuves enregistrées par le harnais. La Crawling API fournit l'acquisition et les chemins d'extraction intégrés. L'application décide quels corps renvoyés répondent à ses exigences de données. Les chiffres proviennent d'une région sur un jour calendaire et sont rapportés comme des observations, pas comme un benchmark.
- HTTP 200 et
cb_status=200décrivent le document qui est arrivé. Pour Google Trends, ce document peut être un avis d'erreur. Lisez le corps avant d'accepter la réponse. - Les scrapers intégrés ont réussi le plus souvent : Trending Now 20/20 et Explore 18/20 avec le JavaScript token. Explore en Markdown sur le Normal token a réussi 0/20.
- Réessayez sur le verdict, jamais sur le code de statut. Une seule nouvelle tentative, les deux essais conservés, et un 200 qui passe n'est jamais retenté.
Le diagramme sépare la réception d'un document de la réception des données requises. Il n'identifie pas quelle requête navigateur ou quel widget a échoué dans Google Trends, et le run ne l'a pas établi non plus.
Choisir la surface Trends avant de choisir le chemin de récupération
Le test couvre trois URL. L'intérêt par sous-région fait partie de la réponse Explore, donc l'historique de mot-clé et l'intérêt régional n'ont pas besoin de pages cibles séparées dans cette implémentation.
| Surface | URL dans le test | Données utilisées par le projet |
|---|---|---|
| Trending Now | https://trends.google.com/trending?geo=US |
Requêtes tendance, libellés de volume de recherche, croissance, heure de début, statut et termes de répartition |
| Explore | https://trends.google.com/trends/explore?q=web scraping&geo=US&date=today 12-m |
Intérêt au fil du temps, intérêt par sous-région et requêtes associées |
| Trending RSS | https://trends.google.com/trending/rss?geo=US |
Titre de l'élément, trafic approximatif et date de publication |
Trending Now répond à la question de savoir quelles recherches montent dans la région sélectionnée ; l'échantillon de scraper sauvegardé reflète le filtre "Past 24 hours" de la page. Explore répond à la façon dont l'intérêt pour un terme varie sur une période choisie. La documentation Trending Now de Google liste RSS comme option d'export, et le flux suffit quand son ensemble plus restreint de champs couvre la tâche.
La version alpha officielle de l'API Trends de Google est une interface distincte. L'accès était limité à des testeurs sélectionnés au moment du run, et la présentation publique ne mentionnait pas les données Trending Now. Elle n'a pas été appelée dans ce projet. Le projet évite aussi la bibliothèque non officielle pytrends, dont le dépôt a été archivé le 17 avril 2025, avec un dernier push enregistré le 10 août 2024. Ce statut de maintenance compte quand un nouveau pipeline choisit une dépendance.
Rendre le chemin de requête explicite
Le module des chemins de récupération définit cinq formes de requête. Chaque chemin passe par le point de terminaison de la Crawling API à https://api.crawlbase.com/, y compris la requête du flux RSS.
| Chemin | Paramètres qui le distinguent | Token utilisé dans la matrice |
|---|---|---|
| HTML rendu |
page_wait et ajax_wait=true
|
JavaScript token |
| Scraper intégré |
scraper=google-trends ou scraper=google-trends-explore
|
Normal pour Trending Now ; JavaScript pour Explore |
| Markdown | format=md |
Normal token |
| HTML sans attente | URL cible sans paramètres d'attente | JavaScript token |
| Récupération RSS | L'URL cible RSS | Normal token |
Le contrôle sans attente rend quand même le JavaScript. Sa seule différence avec le chemin rendu est l'absence des deux paramètres d'attente explicites. De la même façon, les résultats Markdown décrivent le chemin Markdown sur Normal token qui a réellement été testé. Chaque comparaison de cet article nomme son token et ses réglages de requête.
Le constructeur de requêtes garde les valeurs de token hors de la préparation des paramètres. Pour les requêtes scraper, il ne renvoie aucun type de token préféré ; l'appelant fournit le choix depuis probe-config.json. Le client lit ensuite le secret correspondant et passe les paramètres à requests.Session.get() avec un délai d'expiration de 180 secondes :
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}")
Trending Now rendu utilise page_wait=5000 et ajax_wait=true. Explore rendu utilise page_wait=8000 et ajax_wait=true. page_wait est un délai fixe en millisecondes après le chargement de la page. ajax_wait=true attend que l'activité réseau se stabilise avant la capture de la page, et n'ajoute aucun délai fixe propre.
Garder la décision de token de la sonde inspectable
La sonde effectue treize appels vers la cible. Elle essaie les deux types de token pour chaque scraper intégré, les chemins HTML et Markdown, RSS, une requête de comparaison distincte et une requête RSS avec le stockage activé. Elle enregistre aussi des résumés de compte avant et après, avec au moins cinq minutes entre les deux appels au compte.
Les corps bruts de la sonde ne sont pas versionnés, donc le constat vit dans la configuration que lit la matrice : des objets de graphique vides avec le Normal token et 53 points de série temporelle avec le JavaScript token. La matrice utilise donc le JavaScript token pour Explore :
{ "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."
Le journal de la sonde contient encore des verdicts générés avant la correction du traitement de l'enveloppe et des vérifications de contenu, donc ces verdicts d'origine ne reflètent pas les règles finales. La configuration fait partie de l'expérience reproductible. Une nouvelle sonde peut la remplacer. Inspectez les sélections de token avant de lancer une matrice, car la matrice ne change jamais de token et ne choisit jamais un autre chemin de récupération après une réponse en échec.
Lire les couches de la réponse avant de parser les données
Le module d'exécution des récupérations enregistre le statut externe, le statut Crawlbase, le statut de la cible, l'URL finale, le temps écoulé, la taille du corps et la complexité du domaine. Une exception de transport devient un résultat sans réponse HTTP et avec un corps vide, les valeurs de token étant effacées du texte de l'exception.
| Signal | Ce qu'il établit dans ce projet |
|---|---|
| Statut HTTP externe | Si une réponse est arrivée de Crawlbase, et avec quel statut |
cb_status |
Résultat du crawl Crawlbase ; l'application exige 200 avant d'accepter le contenu |
original_status |
Statut HTTP rapporté par Google, conservé dans le CSV |
| Verdict de l'application | Si le corps satisfait les vérifications pour la surface et le chemin demandés |
Les réponses des scrapers demandent une étape de plus. Dans l'enveloppe JSON observée, cb_status, original_status, domain_complexity, et url entourent un objet body interne. L'exécuteur déballe cette enveloppe avant la validation. Ne regarder que les en-têtes manquerait les métadonnées qu'elle porte, et c'est ce qui a mal tourné dans la première sonde :
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"), )
L'exécuteur mesure body_bytes à partir du texte de la réponse d'origine encodé en UTF-8, avant le déballage, donc pour le JSON des scrapers le chiffre inclut l'enveloppe. Ce n'est pas une taille de transfert compressée. Les millisecondes écoulées couvrent l'appel de transport ; la valeur de 180 secondes suit la sémantique de timeout de Requests plutôt qu'une échéance stricte en temps réel.
La première porte d'acceptation vit dans assertions.py. Elle retire les blocs script et style ainsi que les balises, puis cherche dans le texte visible les marqueurs configurés : le message Oops, reCAPTCHA, unusual traffic, /sorry/, et g-recaptcha. Retirer d'abord les scripts empêche la référence à la bibliothèque reCAPTCHA d'une page normale d'être lue comme un challenge, et le test de régression test_recaptcha_script_on_a_data_page_is_not_a_challenge fige ce comportement :
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
La catégorie des marqueurs regroupe les avis que l'application ne peut pas utiliser. Un message Oops à lui seul ne dit pas pourquoi Google n'a pas pu afficher la page. Et une fois que la porte laisse un corps passer au parseur, les données requises doivent encore passer leurs propres vérifications.
Parser les champs dont la tâche a réellement besoin
Les parseurs transforment chaque format de réponse en valeurs attendues par les assertions. Le répartiteur de vérifications choisit les règles pour la surface et le chemin et ajoute la gestion du transport, de la langue et de la géographie.
Pour le JSON du scraper Trending Now, le parseur lit le tableau structuré trends du document. Pour le HTML et le Markdown, il cherche d'abord des lignes de volume visibles en anglais telles que 20K+ searches et les titres qui les précèdent, et il lit aussi les lignes de tableau HTML et les tableaux Markdown. Les différences de format sont explicites : le chemin scraper structuré vérifie plus de champs que les chemins de balisage.
Le parsing d'Explore cherche d'abord des données de graphique structurées, y compris un objet JSON intégré au document. Quand ces champs sont absents, il lit les lignes visibles sous des titres de section en anglais. L'extraction de la série temporelle depuis le texte visible attend un libellé de date tel que Nov 16, 2026 suivi d'un entier, donc des titres ou des dates localisés peuvent laisser le parseur sans série temporelle même quand une page localisée complète est arrivée.
| Réponse | Règles d'acceptation implémentées par l'application |
|---|---|
| JSON du scraper Trending Now | Au moins dix enregistrements ; chaque enregistrement possède position, title, searchVolume, increasePercentage, started, et status; trendsCount est égal à la longueur du tableau |
| Trending Now HTML ou Markdown | Au moins dix lignes extraites, chacune avec un titre et un libellé de volume correspondant au motif attendu |
| Explore | Au moins 40 valeurs de série temporelle ; chacune équivalente à un entier et comprise entre 0 et 100 ; le maximum est 100 ; la liste de sous-régions extraite est non vide |
| Géographie du scraper Explore | Un libellé États-Unis reconnu, ou le littéral geo=US dans l'URL renvoyée |
| RSS | Au moins cinq éléments, chacun avec un titre, un trafic approximatif et une date de publication |
L'assertion de série temporelle accepte les entiers, les flottants à valeur entière et les chaînes entières, et rejette les booléens. Elle ne valide pas les dates, la continuité chronologique, le terme demandé ni chaque score régional :
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)
Ces seuils appartiennent à la requête US de cette expérience sur today 12-m. Quarante points est une règle de couverture minimale, pas une définition d'une année complète. L'exigence d'un pic à 100 convient au graphique à série unique attendu par ce harnais et ne doit pas devenir l'affirmation que toute réponse Trends sans 100 est un parse cassé. L'exigence géographique s'applique uniquement au chemin scraper Explore ; les chemins HTML et Markdown ne l'imposent pas.
Préserver le sens des nombres
Les valeurs de série temporelle d'Explore sont des scores d'intérêt normalisés. La documentation de Google sur la normalisation Trends décrit l'intérêt de recherche relatif pour un moment et un lieu, mis à l'échelle de 0 à 100. Une valeur de 50 n'est pas cinquante recherches. Un zéro peut signifier un faible volume de recherche ; ce n'est pas automatiquement une observation manquante. Dans ce projet, une série temporelle vide est une extraction en échec, tandis qu'une série temporelle contenant des zéros est vérifiée comme une suite de valeurs.
Le champ searchVolume de Trending Now est une mesure différente. Des libellés tels que 1M+ sont du trafic de recherche par tranches, et increasePercentage est une croissance par rapport à une base de référence prédite. L'implémentation conserve ces chaînes telles quelles. Elle ne transforme pas 1M+ en décompte exact, ne convertit pas les libellés relatifs started en horodatages et ne déduit pas de volumes de recherche absolus des scores Explore.
Le parseur de sous-régions conserve les noms de régions pour la vérification de liste non vide. Passer cette vérification ne confirme pas chaque valeur régionale et ne récupère pas chaque page de régions. Le scraper a renvoyé les cinq premières sous-régions affichées par la page testée, avec un total et un texte de pagination, et le projet n'a pas parcouru le reste.
Le diagramme regroupe les vérifications par objectif. Les fonctions liées ci-dessus définissent l'ordre réel et les vérifications qui s'appliquent à chaque format de réponse.
Retenter un verdict en échec et conserver les deux tentatives
Le harnais reçoit trois callables : fetch, check et sleep. Sa décision de nouvelle tentative suit le verdict, et chaque tentative d'un lot terminé devient son propre enregistrement avec les statuts, le temps, la taille du corps, le verdict, la raison et les diagnostics :
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
Une première tentative réussie termine la boucle. Une première tentative en échec vaut une nouvelle tentative de la même requête configurée après dix secondes. Les lots terminés gardent des lignes CSV séparées pour la première tentative et sa nouvelle tentative, même quand celle-ci réussit.
Le lanceur de matrice visite les neuf cellules applicables à chaque tour avec une seule requête en vol à la fois, et attend trois secondes après le lot de chaque cellule. Quand une cellule a besoin d'une nouvelle tentative, l'attente de dix secondes a lieu dans ce lot, donc les écarts ne prétendent pas à exactement trois secondes entre chaque paire d'appels.
La matrice du 16 novembre a effectué 221 appels vers la cible : 180 premières tentatives et 41 nouvelles tentatives. Les nouvelles tentatives ont suivi les règles en vigueur pendant ce run. Appliquer plus tard des vérifications corrigées a changé la façon dont les réponses sauvegardées ont été notées ; cela n'a pas changé quelles requêtes avaient été retentées.
Le résumé regroupe les enregistrements par surface et chemin et ne compte que attempt == 1 dans les réussites, la latence médiane et la taille médiane du corps. Ces médianes incluent les premières tentatives réussies comme échouées, donc le tableau des résultats ne mélange pas fiabilité initiale et récupération :
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
Ce qui est revenu
Le tableau rapporte le run du 16 novembre 2026 avec les vérifications corrigées appliquées à ses réponses sauvegardées. Chaque ligne contient vingt premières tentatives. Explore a utilisé la requête fixe web scraping, geo=US, et date=today 12-m; Trending Now et RSS ont utilisé geo=US sans mot-clé.
| Surface | Chemin | Réussites, première tentative | Réussites, pages en anglais | Latence médiane (ms) | Corps médian (octets) |
|---|---|---|---|---|---|
| Trending Now | Scraper intégré | 20/20 | 20/20 | 10 607 | 6 864 |
| Trending Now | Markdown | 20/20 | n/d, pas de balise de langue | 11 151 | 5 110 |
| Trending Now | HTML rendu | 18/20 | 18/18 | 26 077 | 2 351 950 |
| Trending Now | HTML sans attente | 15/20 | 15/15 | 19 735 | 2 323 239 |
| Explore | Scraper intégré | 18/20 | 14/16 | 26 029 | 4 075 |
| Explore | Markdown | 0/20 | n/d, pas de balise de langue | 44 669 | 475 |
| Explore | HTML rendu | 17/20 | 17/17 | 27 493 | 705 602 |
| Explore | HTML sans attente | 15/20 | 15/16 | 34 444 | 686 376 |
| Trending RSS | Récupération RSS | 20/20 | n/d, XML | 2 850 | 22 028 |
La colonne des pages en anglais utilise la balise de langue HTML pour les réponses HTML et la langue du libellé géographique pour le JSON des scrapers. Elle exclut les pages identifiées comme non anglaises et l'échec de transport. Aucune classification de langue n'a été enregistrée pour Markdown ou RSS, donc ces cellules indiquent n/d. La colonne de première tentative compte les vingt tentatives par chemin, y compris les échecs sur des pages localisées.
Le CSV d'origine conserve les verdicts utilisés pendant le run en direct. Les réussites corrigées et les chiffres de temps et de taille peuvent être recalculés à partir du CSV renoté. Les médianes sont arrondies à la milliseconde et à l'octet. Les crédits n'ont pas été mesurés.
Trending Now : des enregistrements structurés pour une fraction de la taille
Le scraper Trending Now intégré a réussi 20 premières tentatives sur 20, avec une latence médiane de 10 607 millisecondes et une réponse médiane de 6 864 octets. Voici le premier enregistrement tiré de cet échantillon réduit à deux tendances:
{ "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 },
L'échantillon conserve le trendsCount=25 d'origine et les métadonnées de pagination tout en ne gardant que deux enregistrements pour l'illustration. C'est un échantillon réel raccourci, pas un corps complet à soumettre à l'assertion des dix enregistrements.
Le HTML Trending Now rendu a réussi 18 sur 20, avec un corps médian de 2 351 950 octets. Le CSV renoté identifie les deux échecs comme des pages en portugais que le parseur anglais n'a pas pu lire ; le français apparaît parmi les échecs Trending Now sans attente. Le sous-ensemble rendu en anglais seul a réussi 18 sur 18.
Trending Now Markdown a aussi réussi 20 sur 20, avec un corps médian de 5 110 octets, en faisant correspondre les motifs anglais requis de titre et de volume. Passer cette vérification ne signifie pas que les six champs validés sur le JSON du scraper l'ont été sur le Markdown.
Explore : un 200 qui échoue à toutes les vérifications de contenu
Explore Markdown a réussi 0 première tentative sur 20. Les vingt ont enregistré HTTP 200, cb_status=200, et original_status=200. Dix-neuf contenaient le message Oops et une l'avis reCAPTCHA. Sur l'ensemble des premières tentatives et des nouvelles tentatives, le message Oops est apparu dans 36 des quarante corps Explore Markdown sauvegardés. Voici cet échantillon d'erreur sauvegardé, la ligne du bandeau de cookies retirée :
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)
Le chemin a renvoyé un petit document parsable, avec un corps médian de 475 octets, et aucune des données de mot-clé requises.
Le HTML Explore rendu a réussi 17 sur 20, avec une latence médiane de 27 493 millisecondes et un corps médian de 705 602 octets. Ses trois échecs étaient des pages non anglaises ; le sous-ensemble en anglais seul a réussi 17 sur 17. Le contrôle Explore sans attente a réussi 15 sur 20 : trois pages non anglaises, un échec de transport sans corps de réponse et une page en anglais avec une série temporelle extraite vide. La comparaison soutient la configuration d'attente enregistrée pour ce cas. Vingt tentatives par chemin n'établissent pas qu'une attente corrige chaque graphique vide.
Scraper Explore : le score d'origine et le score corrigé
Le scraper Explore a d'abord réussi 14 premières tentatives sur 20. Quatre réponses de plus avaient des séries temporelles et des sous-régions mais échouaient à la règle géographique d'origine parce que le libellé États-Unis était localisé : espagnol ou portugais, russe, ou néerlandais. Les vérifications corrigées acceptent les libellés localisés reconnus et se rabattent sur geo=US dans l'URL de la réponse pour le chemin scraper.
Renoter les mêmes corps a porté le compte de premières tentatives à 18 sur 20, et une nouvelle tentative au libellé polonais est passée d'échec à réussite. Le rapport renoté enregistre 23 verdicts modifiés au total : cinq changements réussite/échec et dix-huit changements de raison, dont quatre des cinq changements réussite/échec sur des premières tentatives.
Les deux échecs restants du scraper corrigé en première tentative étaient des séries temporelles vides sur des pages en anglais. Son sous-ensemble à libellé anglais était de 14 sur 16 sous les deux versions des règles. Sa réponse médiane était de 4 075 octets contre 705 602 octets pour le HTML Explore rendu. Le scraper a réduit de deux ordres de grandeur la réponse que l'application devait traiter tout en conservant la série temporelle et les sous-régions affichées.
La langue explique une grande part de l'écart entre brut et filtré
Dix-sept premières tentatives ont été identifiées comme des pages localisées ou des libellés de scraper localisés. Treize ont échoué au parseur anglais, sur des pages en russe, turc, slovaque, hébreu, ukrainien, français, portugais, chinois et persan. Les quatre autres étaient les réponses du scraper Explore acceptées après la correction géographique. Le répartiteur étiquette ces échecs de parsing pour qu'une page complète localisée ne soit pas rapportée comme un widget vide :
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
Cette étiquette est une limite du parseur observée face à du contenu localisé. Elle n'établit pas que les widgets de Google étaient vides, et elle ne rend pas ces réponses utilisables par l'application actuelle, donc elles restent des échecs dans le compte brut de réussites.
Aucun réglage de langue n'a été envoyé. Une variation selon la route de la requête est une explication plausible du changement de langue des pages, mais le run ne prouve pas ce mécanisme. Ajouter hl=en-US est une prochaine expérience utile, pas un contrôle inclus dans ces résultats. L'article rapporte une région et un jour calendaire, sans matrice de second jour ni de langue fixée.
Inspecter les diagnostics qu'une série temporelle réussie peut cacher
La validation structurelle attrape les pages d'erreur et les séries temporelles vides de ce run. Elle laisse aussi la place pour enregistrer des champs suspects sans jeter une partie utilisable de la réponse.
Les requêtes associées ne correspondaient pas au terme demandé
Sur les 59 premières tentatives qui ont enregistré l'indicateur de requêtes associées, aucune n'avait un terme associé partageant un token avec web scraping, et ce compte inclut les réponses dont la liste associée était vide. Le rapport met le terme en minuscules, extrait les tokens alphanumériques d'au moins trois caractères, ajoute un radical simple pour les mots en -ing éligibles, et cherche ces tokens comme sous-chaînes dans les noms associés :
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
Une liste vide est aussi signalée, donc related_flagged=True à lui seul ne prouve pas qu'une liste non vide est arrivée. C'est une heuristique de diagnostic, pas un modèle de pertinence sémantique, et l'application laisse délibérément le verdict de série temporelle intact quand la liste associée est signalée. Les termes sans rapport observés justifient de vérifier le lien avec la requête avant que les requêtes associées partent en aval ; ce run n'a pas établi leur cause.
"My location" différait de la région de recherche sélectionnée
Le HTML Trending Now a exposé quinze pays différents via son libellé "My location" (ma position) sur 33 lignes de première tentative. L'Inde est apparue huit fois ; le Vietnam, l'Indonésie et le Liban trois fois chacun. La région de tendance sélectionnée est restée États-Unis sur les 33 lignes. Le parseur enregistre my_location séparément de selected_geo. Utilisez la géographie Trends sélectionnée pour identifier la portée des données. Que "My location" suive la route de la requête est une inférence tirée de ces observations, pas une garantie documentée de Google.
Classic Explore affichait un bandeau d'expiration
Le bandeau "Classic Explore is expiring soon" (Classic Explore expire bientôt) est apparu sur dix-sept des vingt pages Explore rendues et seize des vingt pages sans attente. Le JSON du scraper intégré ne l'incluait pas. classic_banner enregistre sa présence sans en faire une condition de réussite. Le bandeau ne donne aucune date de migration, mais c'est une raison opérationnelle de relancer des vérifications représentatives quand l'interface Explore change, surtout pour les parseurs liés aux titres visibles et aux formats de date.
Adapter la méthode à la tâche
Le run enregistré soutient ces points de départ :
| Tâche | Chemin à utiliser | Preuves, 16 novembre 2026 |
|---|---|---|
| Flux de tendances quotidien | Scraper Trending Now intégré, ou RSS quand le titre, le trafic approximatif et la date de publication suffisent | Scraper 20/20, médiane 10 607 ms ; RSS 20/20, médiane 2 850 ms |
| Historique de mot-clé | Scraper Explore intégré avec le JavaScript token | 18/20 sous la règle géographique corrigée ; deux séries temporelles vides |
| Répartition régionale | Liste de sous-régions du scraper Explore intégré | Renvoyée dans la même réponse ; les cinq premières sous-régions affichées, pas la liste complète |
| Appel d'outil d'agent | Scraper Trending Now intégré en JSON | 20/20 ; les champs structurés peuvent être vérifiés avant que les données reviennent à l'appelant |
Le résultat 0/20 d'Explore Markdown s'applique au chemin Normal token testé. Ces résultats servent de base pour choisir une configuration à vérifier sur votre propre requête cible, pas de substitut à cette vérification.
Lancer l'implémentation et vérifier ce qui a changé
Le paquet complet importe les trois modules d'étape via load_steps.py, de sorte que les formes de requête, les assertions et la fonction de nouvelle tentative citées ci-dessus sont le code que la CLI exécute. La suite finale compte trente tests couvrant les assertions, le comportement des parseurs, le traitement de l'enveloppe, la rédaction des tokens, les nouvelles tentatives, le plafond de réponses facturables, les statistiques et l'exécution de la CLI. Son test de parité exerce le résumé partagé du harnais ; il ne revalide pas les réponses Google en direct.
Le fichier requirements déclare requests>=2.32 et pytest>=8 sans figer de versions exactes. Le run enregistré utilisait Python 3.13. Copiez le modèle d'environnement vers .env dans final/ et définissez CRAWLBASE_TOKEN et CRAWLBASE_JS_TOKEN depuis votre compte Crawlbase. Le fichier est ignoré par git. Le client n'ajoute le secret qu'à la frontière HTTP, son journal enregistre le type de token, et les corps sauvegardés comme les messages d'exception sont nettoyés des secrets configurés. Depuis la racine du dépôt :
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
Les commandes pytest et hors ligne ne font aucun appel réel vers la cible. La commande matrice fait des appels réels et consomme des crédits. Son argument --date étiquette la sortie ; il ne demande pas d'instantané historique, et today 12-m est résolu quand Google sert la requête. Le README couvre l'installation sur Windows, Linux et macOS.
Séparer les fixtures des preuves en direct
La commande hors ligne utilise des fixtures synthétiques: une série temporelle minimale, des tendances d'exemple, des éléments RSS, un corps Oops et une réponse vide. Son résumé s'identifie comme un run de fixtures. Ces résultats démontrent le comportement du programme et ne doivent pas être comptés comme des tentatives réelles supplémentaires.
Pour les runs en direct, la CLI sauvegarde un corps nettoyé pour chaque appel sous results/raw/matrix/ et sauvegarde les lots terminés en CSV à chaque étape. Le dépôt public inclut les deux CSV enregistrés et les échantillons réels réduits ; le répertoire complet des corps bruts est ignoré par git.
--report reconstruit le résumé à partir des verdicts enregistrés. --rescore a besoin des corps bruts locaux correspondants, réapplique les vérifications actuelles et écrit un CSV et un rapport Markdown distincts marqués -rescored sans nouvelle requête vers la cible. Conservez le répertoire brut de chaque run avec son CSV avant une autre matrice : les noms de fichiers des corps repartent de zéro dans leur compteur d'appels, et la renotation associe les lignes aux fichiers dans l'ordre des appels après avoir vérifié leur surface et leur chemin.
La matrice utilise store=False et ne réutilise jamais un corps réussi précédent comme repli. Une requête de la sonde a exercé store=true avec Crawlbase Cloud Storage. Son journal a enregistré un en-tête storage_url et aucun en-tête distinct rid; l'identifiant n'apparaît que dans la chaîne de requête de cette URL. La configuration versionnée note que stocker à nouveau la même URL remplace la copie stockée. Le run a donc conservé des corps locaux individuels pour la comparaison. La référence de la Crawling API documente un rid pour les requêtes stockées ; cette implémentation ne dépend pas de cet identifiant.
Séparer le nombre de requêtes de la consommation de crédits
La matrice a compté 220 réponses facturables contre son plafond configuré de 400. Le plafond compte des réponses, pas des crédits. Le classifieur local regarde principalement 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
La règle de facturation documentée de Crawlbase considère aussi original_status. Dans cette matrice enregistrée, les 220 réponses reçues avaient toutes cb_status=200 et original_status=200, et l'appel restant était l'échec de transport, donc les deux règles concordent sur ces données. Un corps peut échouer aux vérifications de cette application tout en satisfaisant les statuts de facturation. Les réponses Explore Markdown inutilisables l'ont fait. Le compte de réussites de l'application et son compte de réponses facturables répondent à des questions différentes.
Les crédits n'ont pas été mesurés. Aucun en-tête de crédits n'a été enregistré, et les résumés de compte de la sonde sont revenus avec des champs d'usage null. C'est une erreur de lecture dans l'assistant, pas un compte vide : le point de terminaison Account API imbrique les totaux du mois sous currentMonth, et l'assistant lit totalSuccess et les autres champs au niveau racine, donc ils sont toujours null. Ces résumés n'établissent aucun delta d'usage mesuré :
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"), }
Les 220 réponses de matrice reçues ont toutes enregistré complex comme palier. Selon les multiplicateurs de crédits documentés, une requête Complex consomme deux crédits et le rendu JavaScript double ce chiffre. La matrice contenait 100 réponses Normal token reçues et 120 réponses JavaScript token reçues :
Consommation estimée de la matrice : (100 × 2) + (120 × 4) = 680 crédits.
C'est une estimation tirée du mélange de tokens enregistré, pas une lecture du compte, et elle exclut la sonde. La page produit du scraper Google annonce jusqu'à 5 000 requêtes gratuites ; vérifiez le solde réel de crédits et les multiplicateurs applicables avant de lire une allocation comme un nombre d'appels Explore.
Le lanceur est séquentiel, utilise les attentes décrites ci-dessus et s'arrête avant une nouvelle requête dès que son plafond facturable est atteint. Si un plafond plus bas interrompt un lot entre une première tentative en échec et sa nouvelle tentative, le lanceur actuel peut laisser ce lot partiel hors du CSV ; cela ne s'est pas produit dans le run enregistré. Dans la limite du plafond, un avis de challenge reçoit la même nouvelle tentative unique que tout autre verdict en échec, et l'application n'ajoute aucune logique de résolution de CAPTCHA. Consultez les conditions d'utilisation de Google pour l'usage prévu et choisissez une cadence adaptée à la fraîcheur dont votre tâche a besoin. Le web s'est mis à noter les crawlers couvre le contexte plus large du rythme et du comportement des crawlers.
Conclusion
Le run du 16 novembre a montré pourquoi des données Google Trends utilisables ont besoin de leur propre vérification d'acceptation. Chaque réponse de matrice reçue rapportait des statuts HTTP et de crawl réussis, pourtant Explore Markdown n'a produit aucune série temporelle utilisable, certaines réponses Explore en anglais avaient des graphiques vides, et les pages localisées ont exposé les limites du parseur de balisage.
Les scrapers intégrés de Crawlbase ont fourni des réponses structurées compactes : Trending Now a réussi 20/20, et le scraper Explore sur JavaScript token a réussi 18/20 après la correction géographique. L'application a rendu ces résultats inspectables en préservant les statuts, en vérifiant les champs requis, en séparant les diagnostics de l'acceptation et en conservant chaque nouvelle tentative comme une tentative à part.
Partez de la documentation du scraper Google Trends ou du scraper Google Trends Explore, appliquez des vérifications adaptées aux données demandées et conservez des corps représentatifs chaque fois qu'un verdict change. Cela donne au pipeline une définition du succès qui va au-delà de la réception d'un 200.
Récupérez Google Trends en HTML rendu, en Markdown ou en JSON structuré depuis les scrapers Trending Now et Explore intégrés, avec cb_status et original_status sur chaque réponse pour que vos propres vérifications décident de ce qui compte. Commencez avec jusqu'à 5 000 requêtes gratuites, sans carte.
Questions fréquentes (FAQ)
HTTP 200 et cb_status=200 peuvent-ils prouver que les données Google Trends sont utilisables ?
Ils établissent les statuts d'acquisition rapportés. Ce run a tout de même renvoyé des pages Oops, un avis reCAPTCHA et des séries temporelles vides sous ces statuts. Exigez les champs et la couverture dont votre application a besoin avant d'accepter les données. Un verdict d'application en échec ne rend pas non plus une réponse reçue non facturable.
Scraper Google Trends exige-t-il toujours le JavaScript token ?
Le choix du token dépend de la surface et du chemin. Le JSON du scraper Trending Now, Trending Now Markdown et RSS ont réussi avec le Normal token dans cette matrice. Le scraper Explore a utilisé le JavaScript token après que la réponse Normal token de la sonde est revenue avec des objets de graphique vides. Le HTML rendu comme le HTML sans attente ont utilisé des JavaScript tokens. Le harnais retente la requête configurée sans changer de token de lui-même.
Les valeurs Explore et les libellés de volume de recherche Trending Now sont-ils la même mesure ?
Non. Les valeurs Explore sont des scores d'intérêt normalisés pour la période et la géographie sélectionnées. Les libellés Trending Now tels que 1M+ sont du trafic par tranches pour la période de tendance sélectionnée. Gardez le sens de chaque champ : ni un score Explore de 100 ni un libellé 1M+ ne sont un décompte exact de recherches que cette application puisse retrouver.
Les mêmes vérifications peuvent-elles servir pour un autre pays ou une période plus courte ?
Adaptez-les d'abord. L'option --geo de la CLI modifie les URL demandées, mais la règle d'acceptation du scraper Explore attend toujours les États-Unis. Le minimum de 40 points et la vérification du pic à 100 ont été choisis pour une expérience fixe à un seul terme sur douze mois, et le balisage localisé peut demander des changements de parseur. Testez la géographie, la langue et la fenêtre temporelle visées avec des assertions correspondantes avant de comparer leur taux de réussite à ce run.
Crawlez n'importe quel site à grande échelle, sans combattre l'infrastructure.
Crawlbase gère les proxies, les empreintes et les CAPTCHA pour que votre équipe livre des pipelines de données au lieu de maintenir l'infrastructure de crawl. Jusqu'à 5 000 requêtes gratuites, sans carte bancaire requise.

