Comment extraire et analyser des données SEO de Googletransformer les SERP en insight SEO

Les résultats de recherche de Google sont le tableau de bord du SEO. Le classement d'une page pour un mot-clé, les titres et extraits qui gagnent le clic, les questions qui apparaissent dans la zone "People also ask" et les recherches associées que Google suggère : chacun est un signal public que vous pouvez lire directement sur la page de résultats. Collectés sur vos mots-clés cibles, ils vous indiquent contre qui vous concurrencez, où vous en êtes aujourd'hui et quels sujets vous n'avez pas encore couverts.

Ce guide vous montre comment extraire et analyser des données SEO de Google avec Python. Vous construisez un petit flux de travail exécutable qui récupère une SERP rendue via la Crawling API, analyse les champs qui comptent pour le SEO, exécute la même requête sur une liste de mots-clés et charge le résultat dans pandas pour trouver les positions de classement, les chevauchements concurrentiels et les lacunes de contenu. L'ensemble du tutoriel se limite aux données de résultats de recherche publics, et la section sur la légalité vers la fin n'est pas du remplissage, lisez-la avant de pointer cet outil sur un volume réel.

Ce que vous allez construire

Un flux de travail Python qui prend une liste de mots-clés cibles, récupère le HTML de chaque SERP via la Crawling API et extrait un enregistrement structuré pour chaque résultat organique ainsi que les fonctionnalités SEO de la page. Nous extrayons ces champs de chaque recherche :

• Position le classement organique de chaque résultat, compté depuis le haut de la page.
• Title le méta-titre affiché pour chaque résultat, qui influence le taux de clic.
• Link l'URL de destination, depuis laquelle nous dérivons aussi le domaine pour l'analyse concurrentielle.
• Snippet la méta-description que Google affiche sous chaque résultat.
• People also ask les questions PAA que Google attache à la requête, utiles pour les idées de contenu.
• Related searches les suggestions de requêtes associées en bas de page, une source de mots-clés longue traîne.

Ces champs couvrent les points de données SEO à suivre depuis une SERP : classements organiques, fonctionnalités SERP comme PAA, méta-titres et descriptions, et les URLs et domaines des pages qui vous devancent. Le volume de recherche et le CPC ne figurent pas sur la page elle-même, ils proviennent donc encore d'un outil de mots-clés comme Google Keyword Planner, Ahrefs ou SEMrush ; ce flux de travail vous donne tout ce que la page de résultats porte.

Pourquoi une simple requête échoue sur Google

Si vous lancez une requête HTTP brute vers une URL de recherche Google depuis un script, vous obtenez rarement la SERP propre que vous voyez dans votre propre navigateur. Google applique de solides mesures anti-scraping. Les requêtes qui ne ressemblent pas à un vrai navigateur sont challengées par un CAPTCHA, redirigées vers une page interstitielle "désolé" ou limitées en débit après une poignée d'appels. Une IP de datacenter faisant des requêtes rapides et identiques est le signal le plus clair possible, et Google la bloque rapidement.

De plus, une grande partie d'une SERP moderne est assemblée avec JavaScript. Les fonctionnalités comme la boîte PAA se remplissent après le chargement du HTML initial, de sorte que même une requête qui passe peut revenir sans les données recherchées. Un scraper SEO Google fonctionnel a donc besoin de deux choses en une seule requête : une IP que la plateforme lit comme un vrai visiteur, et un navigateur qui rend la page. Vous pouvez construire cela vous-même avec un navigateur sans tête et des proxies résidentiels tournants, mais maintenir cette pile en bonne santé représente la majorité du travail. La Crawling API regroupe les deux dans un seul appel : vous lui envoyez l'URL, elle récupère depuis une IP de confiance et rend quand nécessaire, puis renvoie le HTML final à analyser.

Prérequis

Quelques éléments doivent être en place avant d'écrire du code. Aucun d'eux ne prend longtemps.

Basic Python. Vous devez savoir écrire et exécuter un script Python et installer des paquets avec pip. Si BeautifulSoup est nouveau pour vous, notre guide d'utilisation de BeautifulSoup en Python couvre les bases d'analyse que ce tutoriel suppose acquises, et notre guide d'analyse de données avec pandas couvre le côté DataFrame.

Python 3.8 or later. Confirmez votre version avec python --version. Si vous ne l'avez pas, installez-le depuis python.org ou via une distribution comme Anaconda.

A Crawlbase account and token. Inscrivez-vous, ouvrez votre tableau de bord et copiez votre token de requête depuis la page de documentation du compte. Vous obtenez jusqu'à 20 000 requêtes gratuites, et vous ne payez que pour les requêtes réussies. Traitez le token comme un mot de passe : il authentifie vos requêtes, gardez-le hors du contrôle de version.

Configurer le projet

Créez un environnement virtuel afin que les dépendances du projet restent isolées, puis installez les trois bibliothèques dont le flux de travail a besoin.

python --version

python -m venv seo_env
source seo_env/bin/activate

pip install requests beautifulsoup4 pandas

Sous Windows, activez l'environnement avec seo_env\Scripts\activate à la place de la ligne source. Trois dépendances font le travail : requests envoie l'appel HTTP à la Crawling API, beautifulsoup4 analyse le HTML renvoyé afin que vous puissiez extraire les champs individuels par sélecteur CSS, et pandas contient les données scrapées dans un DataFrame pour l'analyse à la fin.

Étape 1 : Récupérer une SERP via la Crawling API

Commencez par obtenir le HTML. Écrivez une petite fonction crawl() qui envoie votre URL de recherche Google cible à la Crawling API avec votre token, vérifie que la page sous-jacente est revenue avec un statut 200 et renvoie le corps HTML. Passez "javascript": "true" afin que l'API rende la page avec un vrai navigateur avant de la renvoyer, ce qui remplit les fonctionnalités chargées par script comme la boîte PAA. Vérifier le statut avant d'analyser permet de faire remonter les erreurs clairement plutôt que silencieusement.

import json
import requests
from urllib.parse import quote_plus

API_TOKEN = "YOUR_CRAWLBASE_TOKEN"  # replace with your token
API_ENDPOINT = "https://api.crawlbase.com/"

def search_url(keyword):
    return f"https://www.google.com/search?q={quote_plus(keyword)}&hl=en&gl=us"

def crawl(url):
    params = {"token": API_TOKEN, "url": url, "javascript": "true"}
    response = requests.get(API_ENDPOINT, params=params)
    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__":
    html = crawl(search_url("web scraping api"))
    print(html[:500])

L'API renvoie une enveloppe JSON, vous chargez donc la réponse avec json.loads et lisez deux champs : original_status est le statut que Google lui-même a renvoyé, et body est le HTML rendu de la page. Garder un contrôle sur original_status signifie qu'une page CAPTCHA ou un blocage remonte comme une exception au lieu d'injecter des ordures dans l'analyseur. Le helper search_url() encode l'URL du mot-clé et fixe la langue et la région avec hl=en et gl=us, de sorte que les résultats sont cohérents d'une exécution à l'autre. Exécutez le script avec python crawling.py et vous devriez voir du vrai balisage SERP dans les 500 premiers caractères, ce qui confirme que la récupération fonctionne avant d'écrire un seul sélecteur.

Étape 2 : Analyser les champs SEO avec BeautifulSoup

Une fois le HTML en main, chargez-le dans BeautifulSoup et extrayez chaque résultat par son sélecteur. Google enveloppe chaque résultat organique dans un conteneur avec le titre dans une balise h3, la destination dans l'ancre autour de lui et l'extrait dans un bloc de description à côté. Les questions PAA et les recherches associées se trouvent plus bas dans leurs propres blocs. Inspectez une SERP en production dans les outils de développement de votre navigateur (clic droit, puis Inspecter) pour confirmer les noms de classes actuels ; les sélecteurs ci-dessous correspondent à la mise en page au moment de la rédaction.

from urllib.parse import urlparse
from bs4 import BeautifulSoup

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

    results = []
    for position, block in enumerate(soup.select("div.g"), start=1):
        heading = block.select_one("h3")
        link = block.select_one("a[href]")
        snippet = block.select_one("div.VwiC3b")
        if not heading or not link:
            continue
        url = link["href"]
        results.append({
            "keyword": keyword,
            "position": position,
            "title": heading.get_text(strip=True),
            "url": url,
            "domain": urlparse(url).netloc,
            "snippet": snippet.get_text(strip=True) if snippet else None,
        })

    paa = [
        q.get_text(strip=True)
        for q in soup.select("div.related-question-pair")
        if q.get_text(strip=True)
    ]

    related = [
        r.get_text(strip=True)
        for r in soup.select("div.y6Uyqe div.b2Rnsc, a.k8XOCe")
        if r.get_text(strip=True)
    ]

    return {
        "keyword": keyword,
        "results": results,
        "people_also_ask": paa,
        "related_searches": related,
    }

Le sélecteur div.g est l'enveloppe que Google utilise pour chaque résultat organique, avec le titre dans une balise h3, la destination dans l'ancre autour de lui et l'extrait dans div.VwiC3b. enumerate(..., start=1) vous donne le rang gratuitement, le classement provient donc de l'ordre dans la page plutôt que d'un attribut fragile. urlparse(url).netloc dérive le domaine de chaque lien, le champ clé pour l'analyse concurrentielle plus tard. La garde if not heading or not link: continue exclut les annonces et le balisage parasite de votre sortie. Les questions PAA proviennent de div.related-question-pair, et les recherches associées du bloc de suggestions en bas de page.

Étape 3 : L'exécuter sur vos mots-clés

Assemblez maintenant la récupération et l'analyse en un seul script exécutable qui boucle sur une liste de mots-clés cibles, collecte les données SEO structurées pour chacun et écrit tout en JSON. Rythmer la boucle avec un court sleep maintient une exécution multi-mots-clés en bonne santé plutôt que de lancer des requêtes dos à dos.

import json
import time
import requests
from urllib.parse import quote_plus, urlparse
from bs4 import BeautifulSoup

API_TOKEN = "YOUR_CRAWLBASE_TOKEN"
API_ENDPOINT = "https://api.crawlbase.com/"

KEYWORDS = [
    "web scraping api",
    "how to scrape google",
    "rotating proxy service",
]

def search_url(keyword):
    return f"https://www.google.com/search?q={quote_plus(keyword)}&hl=en&gl=us"

def crawl(url):
    params = {"token": API_TOKEN, "url": url, "javascript": "true"}
    response = requests.get(API_ENDPOINT, params=params)
    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_serp(html, keyword):
    soup = BeautifulSoup(html, "html.parser")
    results = []
    for position, block in enumerate(soup.select("div.g"), start=1):
        heading = block.select_one("h3")
        link = block.select_one("a[href]")
        snippet = block.select_one("div.VwiC3b")
        if not heading or not link:
            continue
        url = link["href"]
        results.append({
            "keyword": keyword,
            "position": position,
            "title": heading.get_text(strip=True),
            "url": url,
            "domain": urlparse(url).netloc,
            "snippet": snippet.get_text(strip=True) if snippet else None,
        })
    paa = [q.get_text(strip=True) for q in soup.select("div.related-question-pair") if q.get_text(strip=True)]
    related = [r.get_text(strip=True) for r in soup.select("div.y6Uyqe div.b2Rnsc, a.k8XOCe") if r.get_text(strip=True)]
    return {"keyword": keyword, "results": results, "people_also_ask": paa, "related_searches": related}

def main():
    serps = []
    for keyword in KEYWORDS:
        html = crawl(search_url(keyword))
        serps.append(scrape_serp(html, keyword))
        print(f"Scraped '{keyword}': {len(serps[-1]['results'])} results")
        time.sleep(2)
    with open("google_seo_data.json", "w", encoding="utf-8") as f:
        json.dump(serps, f, ensure_ascii=False, indent=2)

if __name__ == "__main__":
    main()

Exécutez le script complet avec python main.py. Il boucle sur les trois mots-clés d'exemple, récupère et rend chaque SERP, extrait les résultats organiques ainsi que les blocs PAA et recherches associées, et écrit tout dans google_seo_data.json. Substituez vos propres mots-clés cibles et les deux mêmes fonctions gèrent tout ce qui revient. Pour un tutoriel plus approfondi du scraping lui-même, y compris la pagination sur plusieurs pages de résultats, consultez notre guide dédié sur le scraping des résultats de recherche Google avec Python.

À quoi ressemble le résultat

Vous obtenez un objet structuré par mot-clé : les résultats organiques dans l'ordre de classement, chacun avec son domaine dérivé, plus les questions PAA et les recherches associées que Google a attachées à la requête.

{
  "keyword": "web scraping api",
  "results": [
    {
      "keyword": "web scraping api",
      "position": 1,
      "title": "Crawling API - Crawlbase",
      "url": "https://crawlbase.com/crawling-api-avoid-captchas-blocks",
      "domain": "crawlbase.com",
      "snippet": "Crawl any website with a single API call and skip blocks and CAPTCHAs."
    },
    {
      "keyword": "web scraping api",
      "position": 2,
      "title": "Best Web Scraping APIs Compared",
      "url": "https://example-blog.com/web-scraping-apis",
      "domain": "example-blog.com",
      "snippet": "A side-by-side look at popular scraping APIs and how they handle blocks."
    }
  ],
  "people_also_ask": [
    "What is a web scraping API?",
    "Is using a scraping API legal?"
  ],
  "related_searches": [
    "free web scraping api",
    "web scraping api python"
  ]
}

C'est la matière première pour toutes les questions SEO que vous souhaitez poser : les classements sont dans position, le paysage concurrentiel dans domain, les signaux de taux de clic dans title et snippet, et les idées de contenu dans people_also_ask et related_searches.

Analyser les données SEO avec pandas

Le scraping vous donne des données ; pandas les transforme en insight. Chargez la liste plate de résultats organiques dans un DataFrame et vous pouvez répondre aux trois questions qui orientent la plupart des travaux SEO : où je me classe, contre qui je concurrence, et qu'est-ce que je n'ai pas couvert. L'ancienne approche consistant à lire un CSV et compter les domaines principaux fonctionne toujours ; ici nous le faisons directement depuis les objets scrapés.

import json
import pandas as pd

with open("google_seo_data.json", encoding="utf-8") as f:
    serps = json.load(f)

# Flatten every organic result across all keywords into one table
rows = [r for serp in serps for r in serp["results"]]
df = pd.DataFrame(rows)

# 1. Where do I rank? Find your own domain's position per keyword
MY_DOMAIN = "crawlbase.com"
mine = df[df["domain"] == MY_DOMAIN][["keyword", "position", "title"]]
print("Your rankings:")
print(mine.to_string(index=False))

# 2. Who am I competing with? Domains that appear most across SERPs
top_domains = df["domain"].value_counts().head(10)
print("\nTop competing domains:")
print(top_domains)

# 3. Content gaps: PAA and related searches you have not covered yet
ideas = []
for serp in serps:
    for q in serp["people_also_ask"] + serp["related_searches"]:
        ideas.append({"keyword": serp["keyword"], "idea": q})
gaps = pd.DataFrame(ideas).drop_duplicates()
print(f"\n{len(gaps)} content ideas from PAA and related searches")
print(gaps.head(10).to_string(index=False))

df.to_csv("google_seo_results.csv", index=False)

Trois analyses en ressortent. La première filtre le tableau sur votre propre domaine et affiche votre position par mot-clé, ce qui est le suivi du classement. La deuxième exécute value_counts() sur la colonne domain pour faire remonter les sites apparaissant le plus dans votre ensemble de mots-clés, les concurrents dominant votre niche. La troisième regroupe chaque question PAA et recherche associée dans une liste dédupliquée d'idées de contenu : de vraies requêtes d'utilisateurs auxquelles vous pouvez répondre pour gagner des featured snippets et du trafic longue traîne. La dernière ligne écrit les résultats plats dans google_seo_results.csv afin que vous puissiez comparer les classements semaine après semaine.

Passer à l'échelle sur les mots-clés et les concurrents

Trois mots-clés sont une démonstration ; un vrai travail en suit des dizaines ou des centaines, parfois aussi contre les résultats publicitaires. La forme reste la même : étendez la liste KEYWORDS, récupérez chaque SERP via la Crawling API et analysez-la avec la même fonction. Quelques habitudes maintiennent une exécution plus large en bonne santé.

• Pace your requests. Maintenez le time.sleep() entre les mots-clés et évitez d'exécuter des centaines de recherches dans une boucle serrée. Répartir le travail est le facteur le plus déterminant pour rester non bloqué.
• Retry blocked URLs cheaply. Toute réponse 5XX de l'API est gratuite, donc réessayer un mot-clé qui est revenu bloqué ou indisponible ne vous coûte rien.
• Re-inspect when fields go empty. Google change souvent son balisage. Si une colonne revient entièrement nulle, ouvrez une SERP en production dans les outils de développement et mettez à jour le sélecteur.
• Schedule re-runs. Les classements bougent, donc exécutez le même ensemble de mots-clés selon un calendrier hebdomadaire et stockez chaque exécution avec une colonne de date pour tracer la position dans le temps.

Si vous souhaitez aussi étudier le côté payant de la SERP, le même schéma de récupération et d'analyse s'applique aux résultats sponsorisés ; notre guide sur l'analyse des Google Ads des concurrents détaille cela. Pour le manuel anti-blocage plus large, consultez comment scraper des sites sans être bloqué.

Est-il légal de scraper les données SEO de Google ?

La légalité du scraping de Google dépend des conditions d'utilisation de Google, de votre juridiction et de l'usage que vous faites des données. Les conditions de Google placent des limites sur l'accès automatisé à son service de recherche, de sorte que le scraping peut contrevenir à ces conditions quelle que soit la prudence de vos outils. Aucun des codes présentés ici ne change cela ; il se contente de faire fonctionner la partie technique. Lisez les conditions de Google et son robots.txt, et traitez les deux comme la limite de ce que vous collectez.

Quelques principes à respecter. Collectez uniquement les données publiques des résultats de recherche : les classements, titres, extraits, questions PAA et recherches associées que tout le monde peut voir sur une page de résultats sans compte. Maintenez votre volume de requêtes assez bas pour ne pas surcharger les serveurs de Google, et rythmez votre crawl plutôt que de le lancer à pleine vitesse. Les titres et extraits sur la page sont le rendu par Google du contenu d'autres sites, utilisez-les donc comme signaux analytiques, pas comme médias à republier en bloc.

Ce flux de travail se limite délibérément aux données SERP publiques parce que c'est la ligne qui rend le travail défendable. Il ne couvre pas ce qui se trouve derrière une connexion, les données de compte ou personnelles, ni les médias protégés par le droit d'auteur tirés des destinations liées. Pour un accès sanctionné et à grand volume aux données Google, Google propose des produits officiels tels que l'API Custom Search JSON et, pour les données publicitaires, l'API Google Ads ; ce sont les bonnes voies quand un projet dépasse l'analyse SERP publique. Utilisez un scraper pour lire ce qui est sur la page, pas pour aller au-delà.

Foire aux questions

Quelles données SEO puis-je extraire des résultats de recherche Google ?

Vous pouvez extraire les classements organiques, les méta-titres, les méta-descriptions (extraits), les URLs des résultats et leurs domaines, les questions "People also ask" et les recherches associées. Ceux-ci couvrent le suivi des classements, l'analyse concurrentielle et les idées de contenu. Le volume de recherche et le CPC ne figurent pas sur la page, extrayez-les donc depuis un outil de mots-clés comme Google Keyword Planner, Ahrefs ou SEMrush et fusionnez-les.

Comment scraper les résultats de recherche Google sans être bloqué ?

Google challenge le trafic automatisé avec des CAPTCHA et des limites de débit, notamment depuis des IP de datacenter. Faites tourner les IP, rythmez vos requêtes, rendez JavaScript afin que les fonctionnalités chargées par script apparaissent, et laissez un service géré gérer le côté CAPTCHA. Récupérer via la Crawling API, qui fait tourner les IP et résout les CAPTCHA côté serveur, fait en sorte que chaque requête ressemble à un visiteur ordinaire afin que vous obteniez la vraie SERP en retour.

De quels outils ai-je besoin pour extraire et analyser les données SEO de Google ?

Trois bibliothèques suffisent : la Crawling API pour récupérer et rendre chaque SERP sans être bloqué, BeautifulSoup pour analyser les résultats organiques et les fonctionnalités SERP depuis le HTML, et pandas pour charger tout dans un DataFrame pour l'analyse de classement, de concurrence et de lacunes de contenu. Un outil de mots-clés comme Ahrefs ou SEMrush complète avec le volume et la difficulté.

Comment repérer les lacunes de contenu à partir d'une SERP ?

Collectez les questions "People also ask" et les recherches associées pour chaque mot-clé cible, regroupez-les dans une liste dédupliquée unique et comparez-les aux sujets que votre site couvre déjà. Les questions restantes sont de vraies requêtes d'utilisateurs auxquelles vous n'avez pas encore répondu, ce qui est exactement là où viennent les nouvelles opportunités de contenu et de featured snippets.

Puis-je suivre l'évolution des classements dans le temps ?

Oui. Exécutez le même ensemble de mots-clés selon un calendrier, hebdomadaire est courant, et écrivez chaque exécution dans un CSV avec une colonne de date. Filtrer le tableau combiné sur votre propre domaine vous donne un historique de position par mot-clé que vous pouvez tracer avec pandas ou un tableur pour voir si votre travail SEO déplace l'aiguille.

Google propose-t-il une API officielle pour ces données ?

Google fournit des produits officiels pour certains d'entre eux, comme l'API Custom Search JSON pour la recherche programmatique et l'API Google Ads pour les données publicitaires. Ils sont la voie sanctionnée pour une utilisation en volume ou commerciale. Pour les signaux SERP publics que couvre ce guide, scraper la page de résultats rendue via la Crawling API est une option pratique tant que vous restez dans les conditions de Google et sur les données publiques.

HR

Hassan Rehan

Ingénieur logiciel · Crawlbase

Ingénieur logiciel chez Crawlbase, il rédige des guides pratiques sur les proxys rotatifs, le scraping et les détails concrets de l'intégration de proxys dans du vrai code.