Comment extraire les données Google Shoppingproduits, prix et vendeurs

Google Shopping est l'une des surfaces de commerce électronique les plus denses du web. Une seule page de résultats regroupe titres de produits, prix, vendeurs, notes et liens de dizaines de détaillants côte à côte, ce qui est exactement la forme de données qu'un travail de surveillance des prix ou de recherche de marché recherche. Si vous vendez quelque chose en ligne, les annonces publiques vous montrent ce que les concurrents facturent et qui stocke un produit donné en ce moment.

Ce guide vous montre comment extraire les données Google Shopping avec Python de manière fiable. Vous construisez un petit scraper opérationnel qui récupère une page de résultats Shopping rendue via la Crawling API, analyse chaque annonce avec BeautifulSoup, gère la pagination et exporte les enregistrements en JSON et CSV pour le suivi des prix. L'ensemble du tutoriel reste limité aux annonces Shopping publiques que tout le monde peut voir sans compte, et la section légalité vers la fin n'est pas du remplissage, lisez-la avant de lancer ceci sur un volume réel.

Ce que vous allez construire

Un script Python qui prend une URL de recherche Google Shopping publique, récupère le HTML via la Crawling API et extrait un enregistrement structuré pour chaque produit sur la page. Nous utiliserons la requête "louis vuitton bags" comme exemple fil conducteur et extrairons ces champs de chaque annonce :

• Titre le nom du produit tel qu'il apparaît dans l'annonce.
• Prix le texte du prix affiché, utile comme signal principal pour la surveillance des prix.
• Vendeur le marchand ou le détaillant proposant le produit.
• Note la note client moyenne quand elle est affichée.
• Lien l'URL vers la page Google Shopping du produit.

Pourquoi une requête ordinaire échoue sur Google Shopping

Si vous envoyez une requête HTTP brute vers une URL Google Shopping depuis un script, vous obtenez rarement la page propre que vous voyez dans votre propre navigateur. Deux choses travaillent contre vous. Premièrement, Google rend une grande partie de la grille Shopping avec JavaScript et adapte ce qu'il retourne en fonction de l'IP et de la région de la requête, donc une adresse de datacenter étranger peut revenir avec un mur de consentement, une devise différente ou un contenu partiel. Deuxièmement, Google surveille le trafic automatisé : les requêtes qui ne ressemblent pas à un vrai navigateur sont challengées, reçoivent un CAPTCHA ou sont bloquées avant d'atteindre les annonces.

Un scraper Google Shopping fonctionnel a donc besoin de deux choses en une seule requête : une IP que la plateforme lit comme un visiteur réel, et un navigateur qui rend la page quand elle s'appuie sur des scripts. Vous pouvez assembler cela vous-même avec un navigateur headless plus un pool de proxies résidentiels rotatifs, mais maintenir ceux-ci en bon état représente l'essentiel du travail. La Crawling API combine les deux en un seul appel : vous lui envoyez l'URL, elle récupère depuis une IP résidentielle de confiance et rend la page si nécessaire, et elle retourne le HTML final pour que vous l'analysiez.

Prérequis

Vous avez besoin de quelques éléments en place avant d'écrire du code. Aucun ne prend longtemps.

Python de base. Vous devez être à l'aise pour é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.

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

Un compte et un token Crawlbase. Inscrivez-vous, ouvrez votre tableau de bord et copiez votre token de requête. Crawlbase émet deux types de tokens : un token normal pour les pages statiques et un token JavaScript pour les pages rendues par navigateur. Google Shopping fonctionne avec le token normal dans la plupart des régions. Vous obtenez jusqu'à 20 000 requêtes gratuites : 1 000 à l'inscription, et davantage à mesure que vous complétez les étapes d'onboarding. Traitez le token comme un mot de passe : il authentifie vos requêtes, ne le mettez donc pas sous contrôle de version.

Configurer le projet

Créez un environnement virtuel pour isoler les dépendances du projet, puis installez les deux bibliothèques dont le scraper a besoin.

python --version

python -m venv shopping_env
source shopping_env/bin/activate

pip install crawlbase beautifulsoup4

Sous Windows, activez l'environnement avec shopping_env\Scripts\activate à la place de la ligne source. Deux dépendances font le travail : crawlbase est le client officiel qui envoie la requête à la Crawling API et retourne le HTML rendu, et beautifulsoup4 analyse ce HTML pour que vous puissiez extraire chaque champ par sélecteur CSS.

Étape 1 : récupérer la page via la Crawling API

Commencez par obtenir le HTML. Initialisez le client CrawlingAPI avec votre token, puis écrivez une petite fonction scrape_google_shopping() qui envoie l'URL cible avec un ensemble d'options, vérifie que la page sous-jacente est revenue avec un statut 200 et retourne le HTML analysé. Les options fixent le pays, définissent un user agent réaliste et donnent à la page quelques secondes pour se rendre avant que le HTML ne soit capturé.

from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup
import json

# Initialize CrawlingAPI with your access token
crawling_api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})

# Request options: pin the region, look like a real browser, let the page render
options = {
    "country": "US",
    "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36",
    "page_wait": 5000,
}

def fetch_html(url):
    response = crawling_api.get(url, options)
    if response["headers"]["cb_status"] != "200":
        print(f"Failed to fetch the page. Status: {response['headers']['cb_status']}")
        return None
    return response["body"].decode("utf-8")

if __name__ == "__main__":
    url = "https://www.google.com/search?q=louis+vuitton+bags&tbm=shop&num=20"
    html = fetch_html(url)
    if html:
        print(html[:500])

Le client retourne une réponse dont le headers["cb_status"] est le statut que Crawlbase a vu lors de la récupération de la page, donc le vérifier signifie qu'un blocage ou un mur de consentement apparaît comme un message clair plutôt que d'alimenter du contenu indésirable dans l'analyseur. L'URL de recherche comporte trois éléments importants : q est la requête, tbm=shop fait passer Google en mode Shopping et num=20 demande vingt résultats par page. Exécutez le script avec python shopping.py et vous devriez voir le vrai balisage Shopping dans les 500 premiers caractères, ce qui confirme que la récupération fonctionne avant d'écrire un seul sélecteur.

Comprendre la page de résultats Google Shopping

Avant d'écrire des sélecteurs, il est utile de savoir comment la page de résultats est structurée. Ouvrez une recherche Shopping dans votre navigateur, faites un clic droit sur un produit et choisissez Inspecter pour voir la structure dans les outils de développement. Chaque résultat est l'un de quelques composants mobiles.

• Annonces de produits. Chaque carte comporte un titre, une image, un prix, un vendeur ou détaillant et une note quand elle existe. C'est l'essentiel de ce que vous extrayez.
• Pagination. Les résultats s'étalent sur plusieurs pages, accessibles en changeant l'offset start dans l'URL.
• Filtres et tri. Les filtres de plage de prix, de marque et de catégorie changent ce que la page retourne, ce qui compte quand vous voulez une tranche ciblée.
• Annonces sponsorisées. Certaines cartes sont des publicités. Si vous ne voulez que les annonces organiques, vous devez les distinguer des annonces sponsorisées.

Étape 2 : analyser les annonces avec BeautifulSoup

Avec le HTML en main, chargez-le dans BeautifulSoup et extrayez chaque produit par son sélecteur. Google encapsule chaque résultat de grille dans un conteneur .sh-dgr__grid-result, et les champs individuels se trouvent dans des éléments imbriqués à l'intérieur. Inspectez la page live dans les outils de développement de votre navigateur pour confirmer les noms de classes actuels ; les sélecteurs ci-dessous correspondent à la mise en page au moment de la rédaction.

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

    products = []
    for item in soup.select(".sh-dgr__grid-result"):
        title_el = item.select_one("h3.tAxDx")
        price_el = item.select_one("span.a8Pemb.OFFNJ")
        seller_el = item.select_one(".aULzUe.IuHnof")
        rating_el = item.select_one(".Rsc7Yb")
        link_el = item.select_one("a.Lq5OHe")

        products.append({
            "title": title_el.get_text(strip=True) if title_el else None,
            "price": price_el.get_text(strip=True) if price_el else None,
            "seller": seller_el.get_text(strip=True) if seller_el else None,
            "rating": rating_el.get_text(strip=True) if rating_el else None,
            "link": "https://www.google.com" + link_el["href"] if link_el else None,
        })

    return products

Chaque champ se lit depuis son propre sélecteur : h3.tAxDx contient le titre, span.a8Pemb.OFFNJ le prix, .aULzUe.IuHnof le vendeur ou détaillant, .Rsc7Yb la note et l'ancre a.Lq5OHe porte le lien produit. Le href que Google stocke est relatif, donc préfixer https://www.google.com le transforme en URL complète. Chaque champ utilise une garde, ... if el else None, donc une note ou un vendeur manquant laisse un None dans l'enregistrement au lieu de lever une exception et tuer toute l'exécution.

Étape 3 : gérer la pagination

Vingt produits sur une page, c'est une démonstration ; la surveillance des prix veut l'ensemble complet. Google Shopping pagine avec le paramètre de requête start, un offset dans les résultats : start=0 est la première page, start=20 la deuxième, start=40 la troisième, et ainsi de suite par pas de vingt. La forme reste la même pour chaque page, vous construisez donc chaque URL, la récupérez via la Crawling API et l'analysez avec la même fonction. Rythmer la boucle avec une courte pause entre les requêtes maintient une longue exécution en bonne santé.

import time

def scrape_multiple_pages(base_url, pages=3):
    all_products = []
    for page in range(pages):
        start_index = page * 20
        paginated_url = f"{base_url}&start={start_index}"
        html = fetch_html(paginated_url)
        if html:
            all_products.extend(parse_products(html))
        time.sleep(3)
    return all_products

La boucle multiplie l'index de page par vingt pour obtenir chaque offset start, l'ajoute à l'URL de base et collecte les produits analysés dans une liste plate. Le time.sleep(3) entre les pages est la seule habitude la plus utile pour une longue exploration : espacer les requêtes est ce qui fait que Google vous lit comme un acheteur plutôt qu'un bot.

Étape 4 : assembler le tout et exporter en JSON et CSV

Maintenant, connectez la récupération, l'analyse et la pagination en un seul script opérationnel, puis écrivez les résultats en JSON et CSV. Le JSON conserve la structure imbriquée pour le code qui le consomme ; le CSV se glisse directement dans un tableur, qui est le format que la plupart des workflows de surveillance des prix ouvrent réellement.

from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup
import json
import csv
import time

crawling_api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})

options = {
    "country": "US",
    "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36",
    "page_wait": 5000,
}

def fetch_html(url):
    response = crawling_api.get(url, options)
    if response["headers"]["cb_status"] != "200":
        print(f"Failed to fetch the page. Status: {response['headers']['cb_status']}")
        return None
    return response["body"].decode("utf-8")

def parse_products(html):
    soup = BeautifulSoup(html, "html.parser")
    products = []
    for item in soup.select(".sh-dgr__grid-result"):
        title_el = item.select_one("h3.tAxDx")
        price_el = item.select_one("span.a8Pemb.OFFNJ")
        seller_el = item.select_one(".aULzUe.IuHnof")
        rating_el = item.select_one(".Rsc7Yb")
        link_el = item.select_one("a.Lq5OHe")
        products.append({
            "title": title_el.get_text(strip=True) if title_el else None,
            "price": price_el.get_text(strip=True) if price_el else None,
            "seller": seller_el.get_text(strip=True) if seller_el else None,
            "rating": rating_el.get_text(strip=True) if rating_el else None,
            "link": "https://www.google.com" + link_el["href"] if link_el else None,
        })
    return products

def scrape_multiple_pages(base_url, pages=3):
    all_products = []
    for page in range(pages):
        paginated_url = f"{base_url}&start={page * 20}"
        html = fetch_html(paginated_url)
        if html:
            all_products.extend(parse_products(html))
        time.sleep(3)
    return all_products

def save_json(data, filename="products.json"):
    with open(filename, "w", encoding="utf-8") as f:
        json.dump(data, f, ensure_ascii=False, indent=4)

def save_csv(data, filename="products.csv"):
    if not data:
        return
    with open(filename, "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=data[0].keys())
        writer.writeheader()
        writer.writerows(data)

def main():
    base_url = "https://www.google.com/search?q=louis+vuitton+bags&tbm=shop&num=20"
    products = scrape_multiple_pages(base_url, pages=3)
    if products:
        save_json(products)
        save_csv(products)
        print(f"Saved {len(products)} products to products.json and products.csv")

if __name__ == "__main__":
    main()

Exécutez le script complet avec python shopping.py. Il parcourt trois pages des résultats Shopping "louis vuitton bags", extrait un enregistrement pour chaque produit et écrit tout dans products.json et products.csv. Pour suivre un produit différent, changez la valeur de q dans base_url ; le reste du pipeline gère ce qui revient. Exécutez-le selon un calendrier et comparez la colonne prix entre les exécutions et vous avez le cœur d'un système de surveillance des prix.

À quoi ressemble la sortie

Vous obtenez une liste propre d'enregistrements de produits, chacun avec le titre, le prix, le vendeur, la note et le lien, prêt à écrire en JSON, CSV ou dans une base de données.

[
    {
        "title": "Louis Vuitton Mini Pochette Accessoires Monogram",
        "price": "$760.00",
        "seller": "louisvuitton.com",
        "rating": "4.5",
        "link": "https://www.google.com/shopping/product/11460745201866483383"
    },
    {
        "title": "Louis Vuitton Onthego Empreinte PM Black",
        "price": "$3,568.00",
        "seller": "StockX",
        "rating": null,
        "link": "https://www.google.com/shopping/product/7199001631589324220"
    }
]

Le miroir CSV contient les mêmes enregistrements sous forme de tableau plat avec les colonnes title,price,seller,rating,link et une ligne d'en-tête, ce qui s'ouvre proprement dans n'importe quel outil de tableur. Un champ manquant apparaît comme une cellule vide dans le CSV et null dans le JSON, ce qui est la note de la deuxième annonce dans l'exemple ci-dessus.

Rester non bloqué à l'échelle

Même avec une IP de confiance gérée pour vous, Google surveille le trafic à allure de scraper, et Shopping ne fait pas exception. Quelques habitudes maintiennent une exécution en bonne santé.

• Rythmez vos requêtes. Bombarder les pages de résultats dans une boucle serrée est le moyen le plus rapide d'être challengé. Le time.sleep entre les pages est là pour une raison ; gardez-le et variez vos requêtes plutôt que de paginer un terme à toute vitesse.
• Misez sur la rotation. Un pool d'IPs résidentielles répartit les requêtes sur de nombreuses adresses d'utilisateurs réels pour qu'aucune ne déclenche une limite. La Crawling API gère cela pour vous ; si vous construisez votre propre pile, c'est la partie à bien faire.
• Fixez le bon pays. Les prix et les vendeurs varient selon la région. Définissez l'option country sur le marché que vous surveillez pour que les données correspondent à ce qu'un acheteur local voit.
• Réinspectez quand les champs deviennent vides. Google change son balisage périodiquement. Si un champ arrête de s'analyser, ouvrez une page live dans les outils de développement et mettez à jour le sélecteur.

Pour le guide plus large, consultez comment extraire des sites web sans être bloqué. Si vous intégrez cela dans un travail récurrent de suivi des prix, notre guide sur le web scraping pour l'intelligence des prix couvre comment transformer les annonces brutes en signal utilisable, et le guide plus large sur le web scraping e-commerce étend la même approche à d'autres boutiques. Pour extraire les résultats de recherche Google standard plutôt que l'onglet Shopping, consultez comment extraire les pages de recherche Google.

Est-il légal d'extraire Google Shopping ?

La légalité du scraping de Google Shopping dépend des conditions d'utilisation de Google, de votre juridiction et de ce que vous faites avec les données. Les conditions de Google limitent l'accès automatisé, donc le scraping peut aller à l'encontre de ces conditions, quelle que soit la prudence de vos outils. Aucun des codes ici ne change cela ; il rend simplement la partie technique fonctionnelle. Lisez les conditions de Google et son robots.txt, et traitez les deux comme la frontière de ce que vous collectez.

Quelques lignes méritent d'être respectées. Collectez uniquement les données d'annonces publiques : les titres de produits, prix, vendeurs, notes et liens que tout le monde peut voir sur une page de résultats Shopping sans compte. Maintenez votre volume de requêtes suffisamment bas pour ne pas surcharger les serveurs de Google, rythmez votre exploration plutôt que de la lancer à pleine vitesse, et fixez le pays sur le marché dont vous avez réellement besoin. Ne republiez pas les images de produits ou les médias protégés par droit d'auteur de Google en gros, et restez à l'écart de tout ce qui est derrière une connexion ou de toute donnée personnelle, que ce tutoriel ne touche pas.

Si vous avez besoin de données Shopping à une échelle ou sous une forme que le scraping public ne peut pas justifier, Google propose des voies officielles. L'API Content for Shopping et les API marchands et publicités sont les moyens officiels de gérer et lire les données produits de manière programmatique, et un accord officiel est la voie correcte quand un projet dépasse une collecte modeste, publique et bien rythmée. Un scraper plus astucieux ne remplace pas un accord de données.

Foire aux questions

Pourquoi une requête ordinaire échoue-t-elle ou retourne-t-elle la mauvaise page sur Google Shopping ?

Google rend une grande partie de la grille Shopping avec JavaScript et adapte ce qu'il retourne en fonction de l'IP et de la région de la requête, donc un appel depuis une adresse de datacenter étranger peut revenir avec un mur de consentement, la mauvaise devise ou un contenu partiel au lieu des annonces que vous voyez dans votre propre navigateur. Il signale aussi le trafic qui ne ressemble pas à un vrai navigateur. Récupérer via la Crawling API, qui utilise des IPs résidentielles rotatives et rend la page, fait ressembler la requête à un acheteur ordinaire pour que vous obteniez les vrais résultats.

Quels champs puis-je extraire de Google Shopping ?

Ce tutoriel extrait cinq champs de chaque carte produit : le titre, le prix, le vendeur ou détaillant, la note quand elle est affichée et le lien vers la page Shopping du produit. Vous pouvez étendre l'analyseur pour récupérer les images ou le texte de livraison en ajoutant plus de sélecteurs. Restez dans les données d'annonces publiques et évitez tout ce qui est derrière une connexion.

Comment gérer la pagination sur Google Shopping ?

Utilisez le paramètre de requête start, un offset dans les résultats : start=0 est la première page, start=20 la deuxième, start=40 la troisième, et ainsi de suite par pas de 20. Construisez chaque URL de page avec l'offset, récupérez-la via la Crawling API, analysez-la avec la même fonction et faites une pause de quelques secondes entre les requêtes pour rythmer l'exploration plutôt que de la bombarder.

Puis-je utiliser cela pour la surveillance des prix ?

Oui, c'est le cas d'utilisation principal. Exécutez le script selon un calendrier, exportez les résultats en CSV et comparez la colonne prix entre les exécutions pour repérer les hausses, les baisses et les nouveaux vendeurs pour les produits que vous suivez. Fixer l'option country maintient les prix comparables au marché qui vous intéresse. Notre guide sur le web scraping pour l'intelligence des prix va plus loin sur la transformation des données brutes en signal.

Mes sélecteurs ne retournent rien. Qu'est-ce qui a changé ?

Presque certainement le balisage de Google. Les noms de classes comme tAxDx et a8Pemb sont générés et changent quand Google redéploie son interface, donc les sélecteurs qui fonctionnaient le mois dernier peuvent casser. Réinspectez une page Shopping live dans les outils de développement de votre navigateur et mettez à jour les sélecteurs. La maintenance périodique des sélecteurs est normale pour tout scraper en production.

Google Shopping a-t-il une API officielle ?

Oui. Google propose l'API Content for Shopping ainsi que des API marchands et publicités qui permettent aux développeurs de gérer les annonces de produits, les campagnes publicitaires et les données de performance de manière programmatique. Si votre projet a besoin de données Shopping à grande échelle ou sous une forme officielle, ces points de terminaison officiels sont la bonne voie plutôt que le scraping public.

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.