Comment extraire les résultats de recherche Bingun tutoriel Python

Bing est le deuxième moteur de recherche le plus utilisé au monde et celui par défaut sur une large part des ordinateurs Windows, ses pages de résultats publiques constituent donc un utile second avis face à Google. Pour la recherche de mots-clés, le suivi du classement SEO, l'analyse de marché ou l'alimentation d'un modèle en données de recherche réelles, le SERP de Bing porte exactement le signal structuré souhaité : les titres, les liens, les extraits et l'ordre dans lequel ils apparaissent.

Ce guide vous montre comment extraire les résultats de recherche Bing avec Python de manière fiable. Vous construisez un scraper simple et fonctionnel qui récupère une page de résultats rendue via la Crawling API, analyse chaque résultat organique avec BeautifulSoup, gère la pagination et exporte les données en JSON et CSV. L'ensemble du tutoriel se limite aux données de résultats de recherche publiques que tout le monde peut voir sans compte, et la section sur la légalité vers la fin mérite d'être lue avant de cibler un volume réel.

Ce que vous allez construire

Un script Python qui prend une URL de recherche Bing publique, récupère le HTML via la Crawling API et extrait un enregistrement structuré pour chaque résultat organique sur la page. Nous utiliserons un exemple de requête comme exemple et extrairons ces champs de chaque résultat :

• Position le rang du résultat sur la page, compté depuis le haut.
• Titre le texte du titre cliquable du résultat, tel qu'affiché dans le listing.
• Lien l'URL de destination vers laquelle le résultat pointe.
• Description l'extrait ou le résumé affiché sous le titre.

En plus des champs par résultat, le script parcourt plusieurs pages de résultats et écrit tout en JSON et CSV, pour que les données tombent directement dans un tableur ou une base de données.

Pourquoi une requête ordinaire échoue sur Bing

Si vous envoyez une requête HTTP brute vers une URL de résultats Bing depuis un script, vous obtenez rarement la page propre que vous voyez dans votre propre navigateur. Deux facteurs jouent contre vous. Premièrement, Bing s'appuie sur JavaScript pour assembler certaines parties de la page de résultats, de sorte qu'une simple requête peut revenir avec un squelette qui ne contient pas les résultats souhaitables. Deuxièmement, Bing surveille le trafic automatisé : les requêtes qui ne ressemblent pas à un vrai navigateur sont mises au défi, reçoivent une page de vérification ou sont limitées en débit avant d'atteindre les résultats.

Un scraper Bing fonctionnel a donc besoin de deux choses en une seule requête : une adresse IP que la plateforme considère comme un vrai visiteur, et, lorsque la page s'appuie sur des scripts, un navigateur pour la rendre. Vous pouvez assembler cela vous-même avec un navigateur sans interface graphique et un pool de proxies résidentiels rotatifs, mais maintenir ces composants 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 adresse IP fiable et effectue le rendu si nécessaire, puis retourne le HTML final à analyser.

Prérequis

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

Python de base. Vous devez être à l'aise pour écrire et exécuter un script Python et installer des paquets avec pip. Si BeautifulSoup vous est nouveau, notre guide d'utilisation de BeautifulSoup en Python couvre les bases d'analyse que ce tutoriel suppose.

Python 3.8 ou une version ultérieure. Vérifiez votre version avec python --version. Si vous ne l'avez pas, installez-le depuis python.org ou via une distribution comme Anaconda.

Un compte Crawlbase et un 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 : 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, donc gardez-le hors du contrôle de version.

Configurer le projet

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

python --version

python -m venv bing_env
source bing_env/bin/activate

pip install requests beautifulsoup4

Sur Windows, activez l'environnement avec bing_env\Scripts\activate au lieu de la ligne source. Deux dépendances font le travail : requests envoie l'appel HTTP à la Crawling API, et beautifulsoup4 analyse le HTML retourné pour que vous puissiez extraire des champs individuels par sélecteur CSS.

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

Commencez par obtenir le HTML. Écrivez une petite fonction crawl() qui envoie votre URL cible à la Crawling API avec votre token, demande le rendu JavaScript pour que le listing complet se charge, vérifie que la page sous-jacente est revenue avec un statut 200 et retourne le corps HTML. Vérifier le statut avant d'analyser rend les échecs visibles plutôt que silencieux.

import json
import requests

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

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__":
    url = "https://www.bing.com/search?q=samsung+s23+ultra"
    html = crawl(url)
    print(html[:500])

L'API retourne une enveloppe JSON, vous chargez donc la réponse avec json.loads et lisez deux champs : original_status est le statut que Bing lui-même a retourné, et body est le HTML de la page. Le paramètre javascript=true demande à l'API d'afficher la page dans un vrai navigateur avant de la retourner, ce qui garantit la présence de la liste complète de résultats. Surveiller original_status signifie qu'un blocage ou un défi se manifeste comme une exception plutôt que d'alimenter le parseur de données incorrectes. L'exemple de requête "samsung s23 ultra" est transmis dans le paramètre q, qui est la façon dont Bing porte le terme de recherche. Exécutez le script avec python crawling.py et vous devriez voir du vrai balisage de résultats 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 résultats avec BeautifulSoup

Avec le HTML en main, chargez-le dans BeautifulSoup et extrayez chaque résultat par son sélecteur. Bing enveloppe chaque résultat organique dans un élément de liste li.b_algo, avec le titre et le lien dans une ancre h2 a et l'extrait dans un paragraphe p.b_algoSlug. Inspectez la page en direct 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 de Bing au moment de la rédaction.

from bs4 import BeautifulSoup

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

    results = []
    for position, block in enumerate(soup.select("li.b_algo"), start=1):
        link = block.select_one("h2 a")
        snippet = block.select_one("p.b_algoSlug")
        if not link:
            continue
        results.append({
            "position": position,
            "title": link.get_text(strip=True),
            "url": link.get("href"),
            "description": snippet.get_text(strip=True) if snippet else None,
        })

    return results

Le sélecteur li.b_algo est le conteneur que Bing utilise pour chaque résultat organique, donc boucler sur ces éléments de liste vous donne exactement les résultats et ignore le chrome de la page. Lire le texte du titre et le href de la même ancre h2 a maintient le titre et le lien de destination alignés, et p.b_algoSlug contient la description affichée sous chaque titre. enumerate(..., start=1) vous donne la position gratuitement lors du parcours, la position provient donc de l'ordre de la page plutôt que d'un attribut fragile. La garde if not link: continue ignore les blocs sans ancre de titre, ce qui élimine les publicités, les carrousels vidéo et le balisage parasite de votre sortie. L'extrait revient à None lorsqu'un résultat n'a pas de paragraphe de description.

Étape 3 : Assembler le tout

Connectez maintenant la récupération et l'analyse dans un seul script exécutable. Crawlez la page de résultats rendue, passez le HTML au parseur, affichez les résultats et écrivez la sortie structurée en JSON.

import json
import requests
from bs4 import BeautifulSoup

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

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_html(html):
    soup = BeautifulSoup(html, "html.parser")
    results = []
    for position, block in enumerate(soup.select("li.b_algo"), start=1):
        link = block.select_one("h2 a")
        snippet = block.select_one("p.b_algoSlug")
        if not link:
            continue
        results.append({
            "position": position,
            "title": link.get_text(strip=True),
            "url": link.get("href"),
            "description": snippet.get_text(strip=True) if snippet else None,
        })
    return results

def main():
    url = "https://www.bing.com/search?q=samsung+s23+ultra"
    html = crawl(url)
    results = scrape_html(html)
    print(json.dumps(results, indent=2, ensure_ascii=False))
    with open("bing_results.json", "w", encoding="utf-8") as f:
        json.dump(results, f, ensure_ascii=False, indent=2)
    print(f"Saved {len(results)} results")

if __name__ == "__main__":
    main()

Exécutez le script complet avec python main.py. Il récupère la page de résultats pour "samsung s23 ultra", extrait un enregistrement pour chaque résultat organique, les affiche et écrit tout dans bing_results.json. Les deux mêmes fonctions sont tout ce dont vous avez besoin : changez la requête dans l'URL et le parseur gère ce qui revient.

À quoi ressemble la sortie

Vous obtenez une liste ordonnée propre d'objets de résultats, chacun avec une position, un titre, un lien et une description, prête à écrire en JSON, CSV ou dans une base de données.

[
  {
    "position": 1,
    "title": "Samsung Galaxy S23 Ultra | Samsung US",
    "url": "https://www.samsung.com/us/smartphones/galaxy-s23-ultra/",
    "description": "Meet the latest Galaxy S23 Ultra phone, equipped with a built-in S Pen, Nightography camera, and a powerful chip for epic gaming."
  },
  {
    "position": 2,
    "title": "Samsung Galaxy S23 Ultra - Full phone specifications",
    "url": "https://www.gsmarena.com/samsung_galaxy_s23_ultra-12024.php",
    "description": "Samsung Galaxy S23 Ultra Android smartphone. Announced Feb 2023. Features 6.8 inch display, Snapdragon 8 Gen 2 chipset, 5000 mAh battery."
  }
]

Passer à grande échelle sur plusieurs pages et requêtes

Une requête sur une page est une démo ; un vrai travail s'étend sur plusieurs recherches et va plus loin dans les résultats. Bing pagine avec le paramètre de requête first, qui est un décalage indexé à 1 par pas de 10 : first=11 est la deuxième page, first=21 la troisième, et ainsi de suite. La forme reste la même : construisez chaque URL, récupérez-la via la Crawling API et analysez-la avec la même fonction. L'unique habitude qui maintient la santé d'une longue exécution est le cadençage, faites donc une pause entre les requêtes plutôt que de les envoyer dans une boucle serrée.

import time
from urllib.parse import quote_plus

query = "samsung s23 ultra"
encoded = quote_plus(query)

all_results = []
for page in range(3):
    first = page * 10 + 1
    url = f"https://www.bing.com/search?q={encoded}&first={first}"
    html = crawl(url)
    all_results.extend(scrape_html(html))
    time.sleep(3)

print(f"Collected {len(all_results)} results across 3 pages")

Crawlbase sert jusqu'à 20 requêtes par seconde par défaut, ce qui est largement suffisant pour un scraper qui se cadence lui-même ; si vous en avez réellement besoin de plus, le support peut l'augmenter. Toute réponse 5XX de l'API est gratuite, donc réessayer une URL bloquée ou indisponible ne vous coûte rien. Si vous préférez router votre propre trafic via un pool rotatif plutôt qu'utiliser l'API gérée, le Smart AI Proxy (aussi appelé AI Proxy) vous offre la même rotation d'adresses IP résidentielles comme point de terminaison proxy clé en main.

Exporter les résultats en CSV

Le JSON est pratique pour le code, mais un CSV s'ouvre directement dans un tableur, c'est donc le format que la plupart des équipes s'échangent. Comme chaque résultat est déjà un dictionnaire plat avec les mêmes clés, écrire un CSV prend quelques lignes avec la bibliothèque standard.

import csv

def save_csv(results, path="bing_results.csv"):
    fields = ["position", "title", "url", "description"]
    with open(path, "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=fields)
        writer.writeheader()
        writer.writerows(results)
    print(f"Wrote {len(results)} rows to {path}")

Appelez save_csv(all_results) après une exécution paginée et vous obtenez un bing_results.csv avec une ligne par résultat organique et une ligne d'en-tête au-dessus. Utiliser DictWriter avec une liste explicite fieldnames maintient l'ordre des colonnes stable, et newline="" empêche le fichier de prendre des lignes vides sur Windows.

Rester non bloqué

Même avec une adresse IP fiable et le rendu géré, Bing surveille le trafic à l'allure d'un scraper. Quelques habitudes maintiennent la santé d'une exécution.

• Cadencez vos requêtes. Marteler les pages de résultats dans une boucle serrée est le moyen le plus rapide d'être mis au défi. Espacez les requêtes et variez vos requêtes au lieu de paginer un terme à pleine vitesse.
• Misez sur la rotation. Un pool d'adresses IP résidentielles répartit les requêtes sur de nombreuses adresses d'utilisateurs réels afin qu'aucune ne déclenche une limite. La Crawling API gère cela pour vous ; si vous construisez votre propre stack, c'est la partie à bien faire.
• Lisez les codes de statut. Une exécution qui commence à retourner des défis ou des pages de vérification vous indique que le débit actuel ou le niveau d'adresses IP n'est plus suffisant. Traitez cela comme un signal pour ralentir, pas du bruit à ignorer.
• Réinspectez quand les champs sont vides. Bing modifie périodiquement son balisage. Si les résultats cessent d'être analysés, ouvrez une page en direct dans les outils de développement et mettez à jour les sélecteurs.

Pour le guide plus complet, voir comment scraper des sites web sans être bloqué. Si une page Bing dont vous avez besoin s'appuie sur des scripts pour s'afficher, notre guide sur le crawling des sites JavaScript explique pourquoi le rendu est important et comment l'activer. Pour une vue plus large de la façon dont les principaux moteurs structurent leurs pages, voir ce que Google, Yahoo et Bing retournent.

Est-il légal de scraper Bing ?

La question de savoir si le scraping de Bing est autorisé dépend des conditions d'utilisation de Microsoft, de votre juridiction et de ce que vous faites des données. Les conditions de Bing imposent des limites à l'accès automatisé, de sorte que le scraping peut aller à l'encontre de ces conditions quelle que soit la prudence de vos outils. Aucun code ici ne change cela ; il rend seulement la partie technique fonctionnelle. Lisez les conditions de Bing et son robots.txt, et traitez les deux comme la limite de ce que vous collectez.

Quelques lignes à retenir. Collectez uniquement des données de résultats de recherche publiques : les titres, liens, descriptions et positions que tout le monde peut voir sur une page de résultats sans compte. Gardez votre volume de requêtes suffisamment bas pour ne pas surcharger les serveurs de Bing, et cadencez votre crawl plutôt que de le faire tourner à plein régime. Si vous avez besoin de données de recherche à grande échelle et souhaitez une voie sanctionnée, Microsoft propose les API Bing Search via Azure, qui est le moyen officiel et pris en charge d'interroger les résultats Bing par programmation et constitue le bon choix lorsque votre projet nécessite du volume ou des garanties.

Ce guide est délibérément limité aux pages de résultats de recherche publiques car c'est la ligne qui rend le travail défendable. Il ne couvre rien derrière une connexion, les données de compte ou personnelles, ou les médias protégés par le droit d'auteur extraits des destinations liées. Uniquement des données SERP publiques. Si votre projet a besoin de plus, un accord de données officiel ou l'API Azure Bing Search est le bon chemin, pas un scraper plus sophistiqué.

Foire aux questions

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

Bing s'appuie sur JavaScript pour assembler certaines parties de la page de résultats, de sorte qu'une simple requête peut revenir avec un squelette qui ne contient pas les résultats. Il signale également le trafic qui ne ressemble pas à un vrai navigateur et peut répondre avec un défi ou une page de vérification. Récupérer via la Crawling API avec javascript=true, qui affiche la page depuis une adresse IP résidentielle rotative, fait ressembler la requête à un visiteur ordinaire afin d'obtenir la vraie page de résultats.

Puis-je extraire les résultats de recherche Bing avec Python ?

Oui. Avec requests et BeautifulSoup, vous pouvez récupérer une page de résultats et extraire les titres, liens, descriptions et positions. La Crawling API sert de pont qui amène votre requête à Bing depuis une adresse IP fiable et l'affiche, de sorte que les requêtes sont traitées sans accroc au lieu d'être bloquées. Pour une introduction Python plus large, consultez notre guide sur le scraping de sites web avec Python.

Quels champs puis-je extraire d'une page de résultats Bing ?

Ce tutoriel extrait quatre champs de chaque résultat organique : la position sur la page, le titre, le lien de destination et la description affichée. Le titre et le lien viennent de l'ancre h2 a à l'intérieur de chaque bloc li.b_algo, et la description vient de p.b_algoSlug. Restez dans les données de résultats de recherche publiques et évitez tout ce qui est derrière une connexion.

Ai-je besoin du rendu JavaScript pour extraire les données de Bing ?

Souvent oui, car Bing remplit certaines parties de la page de résultats avec des scripts. Les exemples ici passent javascript=true à la Crawling API pour que la page soit affichée dans un vrai navigateur avant de revenir, ce qui garantit la présence du listing complet. Notre guide sur le scraping des pages JavaScript avec Python explique quand le rendu est nécessaire.

Comment paginer sur plus de résultats Bing ?

Utilisez le paramètre de requête first, qui est un décalage indexé à 1 par pas de 10 : first=11 est la deuxième page, first=21 la troisième, et ainsi de suite. Construisez chaque URL de page avec le décalage, 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 cadencer le crawl plutôt que de le marteler.

Le scraping de Bing est-il différent du scraping de Google ?

L'approche est la même, seuls les sélecteurs et les paramètres de pagination diffèrent. Bing utilise des blocs li.b_algo et un décalage first, tandis que Google utilise ses propres conteneurs de résultats et un décalage start. Si vous travaillez aussi avec Google, consultez nos guides sur le scraping des pages de recherche Google et sur le scraping des résultats de recherche Yandex pour les sélecteurs et étapes équivalents.

MA

Muhammad Atif

Développeur full stack senior · Crawlbase

Développeur full stack senior chez Crawlbase, il construit la plateforme et écrit sur l'architecture de scraping, les proxys et les pipelines de données.

IK

Ian Kalvin

Ingénieur support technique · Crawlbase

Ingénieur support technique chez Crawlbase, il écrit depuis la première ligne de ce qui casse réellement en production, sur les configurations de scraping et de proxys.