Comment faire du web scraping sur Python avec BeautifulSoup ?

Pour faire du web scraping en Python avec BeautifulSoup, tu as besoin de deux bibliothèques : requests pour télécharger la page web, et beautifulsoup4 pour extraire les données du code HTML.

Installe-les avec la commande pip install requests beautifulsoup4, puis suis le guide ci-dessous pour scraper un site étape par étape.

Prérequis pour faire du scraping sur Python avec BeautifulSoup

Avant de te lancer, tu n’as pas besoin d’être expert. Savoir lire et exécuter un script Python suffit largement pour débuter.

Voici ce qu’il faut installer pour démarrer :

• Installer Python ainsi qu’un environnement de développement.
• Installer pip, l’outil qui permet d’ajouter des bibliothèques Python en une commande.
• Installer BeautifulSoup :

pip install beautifulsoup4

Attention au nom du paquet : sur PyPI, c’est bien beautifulsoup4 qu’il faut écrire. Le module que tu importeras dans ton code s’appelle bs4.

• Installer Requests pour télécharger les pages web :

pip install requests

• Installer lxml (optionnel), un parseur plus rapide qu’utilise BeautifulSoup pour analyser le HTML :

pip install lxml

Comment faire du web scraping avec Python et BeautifulSoup ?

Voici un projet complet pour récupérer le titre d’une page web et tous les liens qu’elle contient.

Étape 1 : Récupérer le contenu de la page avec Requests

Pour télécharger une page web, tu envoies une requête HTTP GET vers une URL. C’est le rôle de la bibliothèque Requests.

À chaque requête, le serveur renvoie un code de statut qui t’indique si tout s’est bien passé. Les principaux à connaître :

• 200 : succès.
• 301 / 302 : redirection.
• 404 : page non trouvée.
• 500 : erreur interne du serveur.

Avec Requests, tu vérifies ce résultat grâce à l’attribut .status_code. Voici un exemple concret : ce code envoie une requête vers un site, contrôle le code de statut, puis affiche un extrait du contenu HTML si tout va bien.

import requests

# URL cible
url = "https://bonjour.com"

# Envoyer une requête GET
response = requests.get(url)

# Vérifier le code de statut
if response.status_code == 200:
    print("Succès : la page a bien été récupérée !")
    html = response.text  # contenu HTML de la page
    print("Extrait du contenu HTML :")
    print(html[:500])  # affiche seulement les 500 premiers caractères
else:
    print(f"Erreur : code de statut {response.status_code}")

Étape 2 : Analyser le code HTML avec BeautifulSoup

Quand tu récupères le contenu d’une page avec response.text, tu obtiens une simple chaîne de caractères : tout le code HTML de la page, mais inexploitable en l’état. Pour le manipuler facilement, tu crées un objet BeautifulSoup, qui transforme ce HTML brut en une structure que tu peux parcourir et analyser.

Indique toujours un parseur, par exemple "html.parser". BeautifulSoup interprète alors correctement le HTML, sans afficher d’avertissement. Tu peux aussi utiliser lxml, plus rapide, à installer séparément.

from bs4 import BeautifulSoup
import requests

url = "https://bonjour.com"
response = requests.get(url)
html = response.text

# Spécifier le parseur est recommandé
soup = BeautifulSoup(html, "html.parser")

Étape 3 : Trouver et extraire des éléments

Le HTML est maintenant un objet BeautifulSoup. Tu peux rechercher et récupérer les données qui t’intéressent, balise par balise. Trois méthodes couvrent la majorité des besoins.

Utiliser find() et find_all()

find() renvoie le premier élément trouvé. find_all() renvoie la liste complète des éléments correspondants.

# Récupérer le titre <h1>
h1 = soup.find("h1")
print(h1.get_text())

# Récupérer tous les liens <a>
liens = soup.find_all("a")
for lien in liens:
    print(lien.get_text(), lien.get("href"))

Cibler les éléments par attribut

Tu peux affiner la recherche selon un attribut HTML, comme class, id ou n’importe quel autre. À noter : en Python, on écrit class_ et non class, pour éviter le conflit avec le mot réservé du langage.

# Récupérer un div avec un id spécifique
conteneur = soup.find("div",)

# Récupérer tous les liens avec une classe spécifique
liens_nav = soup.find_all("a", class_="nav-link")

Utiliser des sélecteurs CSS avec select()

Pour des recherches plus précises, la méthode select() accepte des sélecteurs CSS. Tu cibles exactement certaines parties d’une page, sans parcourir tout le HTML à la main.

# Tous les liens dans des titres d'articles
liens_articles = soup.select("article h2 a")

# Tous les <a> dont l'attribut href commence par "http"
liens_http = soup.select('a[href^="http"]')

Comment extraire des données d’un tableau HTML avec BeautifulSoup ?

Les vrais cas d’utilisation sont souvent plus complexes que récupérer un titre ou un lien. Tu vas devoir gérer l’extraction de données structurées comme les tableaux et les listes, la pagination, et les erreurs fréquentes du scraping.

Extraire des tableaux et des listes

Les sites web présentent souvent leurs données dans des tableaux HTML (<table>, <tr>, <th>, <td>) ou des listes (<ul>/<ol> avec <li>). Pour transformer ces structures en données exploitables, tu dois les parcourir ligne par ligne ou élément par élément.

Pour extraire un tableau HTML, le principe est simple :

• Récupérer les en-têtes (<th>) pour identifier les titres des colonnes.
• Parcourir chaque ligne (<tr>) et chercher les cellules (<td>) qui contiennent les données.
• Stocker les informations dans une liste ou un dictionnaire.

Pour une liste HTML (<ul> ou <ol>) :

• Repérer toutes les balises <li> avec find_all.
• Récupérer leur contenu (texte ou lien) et l’ajouter dans une liste Python.

Voici un exemple avec un tableau :

html = """
<table>
  <tr>
    <th>Nom</th>
    <th>Age</th>
    <th>Ville</th>
  </tr>
  <tr>
    <td>Alice</td>
    <td>25</td>
    <td>Paris</td>
  </tr>
  <tr>
    <td>Bob</td>
    <td>30</td>
    <td>Lyon</td>
  </tr>
</table>
"""

# Créer l'objet BeautifulSoup
soup = BeautifulSoup(html, "html.parser")

# Extraire les en-têtes du tableau
headers = [th.get_text(strip=True) for th in soup.find_all("th")]
print("En-têtes :", headers)

# Extraire les lignes de données (on saute la 1re ligne car ce sont les en-têtes)
rows = []
for tr in soup.find_all("tr")[1:]:
    cells = [td.get_text(strip=True) for td in tr.find_all("td")]
    if cells:
        rows.append(cells)

print("Lignes :", rows)

Ici, find_all("th") récupère les en-têtes et find_all("td") récupère les cellules de chaque ligne. Tu boucles sur les <tr> pour reconstruire le tableau ligne par ligne.

Voici un exemple sur une liste :

from bs4 import BeautifulSoup

html_list = """
<ul>
  <li>Pomme</li>
  <li>Banane</li>
  <li>Orange</li>
</ul>
"""

soup = BeautifulSoup(html_list, "html.parser")

# Récupérer les éléments de la liste
items = [li.get_text(strip=True) for li in soup.find_all("li")]
print("Liste extraite :", items)  # ["Pomme", "Banane", "Orange"]

Chaque <li> est directement transformé en élément de liste Python, ce qui donne le résultat ["Pomme", "Banane", "Orange"].

Gérer la pagination et les liens

Souvent, les données ne tiennent pas sur une seule page. Elles sont réparties via des liens de “page suivante” ou une pagination numérotée (?page=1, ?page=2, etc.). Dans les deux cas, tu dois boucler pour aller chercher toutes les pages et fusionner les données.

Exemple avec un paramètre page :

import time
import requests
from bs4 import BeautifulSoup

# Exemple d'URL avec pagination
BASE_URL = "https://bonjour.com/articles?page={}"
HEADERS = {"User-Agent": "Mozilla/5.0"}

all_articles = []

# On suppose qu'il y a 5 pages à parcourir
for page in range(1, 6):
    url = BASE_URL.format(page)
    r = requests.get(url, headers=HEADERS, timeout=20)
    if r.status_code == 200:
        soup = BeautifulSoup(r.text, "html.parser")
        # Extraire les titres des articles
        articles = [h2.get_text(strip=True) for h2 in soup.find_all("h2", class_="title")]
        all_articles.extend(articles)
    else:
        print(f"Erreur sur la page {page} (code : {r.status_code})")
    time.sleep(1.0)  # politeness

print("Articles récupérés :", all_articles)

Petite explication étape par étape :

• Prépare l’URL avec un emplacement {} pour insérer le numéro de la page.

BASE_URL = "https://bonjour.com/articles?page={}

• Certains sites bloquent les requêtes sans identité de navigateur. Ajouter un User-Agent évite d’être pris pour un bot.

headers = {"User-Agent": "Mozilla/5.0"}
requests.get(url, headers=headers) 

• Boucle de la page 1 à 5.

for page in range(1, 6):

• Récupère le HTML de la page avec requests.

requests.get(url)

• Limite le temps d’attente si le site ne répond pas (timeout de 20 secondes).

requests.get(url, timeout=20)

• Analyse la page avec BeautifulSoup.

BeautifulSoup(response.text, "html.parser")

• Récupère tous les titres d’articles.

find_all("h2", class_="title")

• Ajoute les articles trouvés dans une liste globale.

all_articles.extend(articles)

• Introduis une pause entre chaque requête pour ne pas surcharger le serveur et éviter d’être banni.

time.sleep(1.0)

Après la boucle, all_articles contient tous les titres des 5 pages.

Les erreurs et les défis courants

Le scraping, ce n’est pas juste appuyer sur un bouton. Tu vas rencontrer des obstacles fréquents :

• Les erreurs HTTP : 404 (page non trouvée), 403 (accès interdit) et 500 (erreur côté serveur).

Exemple de gestion :

response = requests.get(url)
if response.status_code == 200:
    print("Page récupérée avec succès")
elif response.status_code == 404:
    print("Erreur : page introuvable")
else:
    print("Code renvoyé :", response.status_code)

• Les sites qui bloquent le scraping : certains détectent les requêtes automatiques et bloquent l’accès.
• Les pages dynamiques (JavaScript) : BeautifulSoup ne lit que le HTML statique. Si la page charge son contenu avec JavaScript, tu ne verras rien. Dans ce cas, tu dois utiliser un outil comme Selenium ou Playwright.

Pour scraper efficacement sans te faire bloquer ni abîmer le site, voici les meilleures pratiques :

• Respecte le fichier robots.txt du site que tu veux analyser.
• Mets en place des délais entre les requêtes avec time.sleep() pour ne pas surcharger le serveur.
• Utilise des proxies et fais-les tourner.
• Change régulièrement ton User-Agent.

Comment faire du web scraping avec Selenium et BeautifulSoup ?

Selenium contrôle un vrai navigateur, exécute le JavaScript et affiche la page comme si un humain naviguait dessus. BeautifulSoup analyse ensuite le HTML une fois la page complètement rendue, et tu extrais toutes les données que tu veux.

Étape 1 : Installer Selenium et BeautifulSoup

Ici, au lieu de requests, tu utilises Selenium pour récupérer le contenu de la page. Installe les deux bibliothèques avec cette commande :

pip install selenium beautifulsoup4

Tu dois ensuite télécharger un WebDriver adapté à la version de ton navigateur. Pour Google Chrome, c’est ChromeDriver. Tu as deux options : le placer dans le même dossier que ton script Python, ou l’ajouter à la variable d’environnement PATH de ton système.

Étape 2 : Configurer Selenium

Commence par importer webdriver depuis Selenium pour piloter le navigateur.

from selenium import webdriver
from selenium.webdriver.common.by import By

Lance ensuite un navigateur. C’est lui qui ouvre la page et exécute le JavaScript, ici Chrome.

driver = webdriver.Chrome()

Indique au navigateur quelle URL visiter.

driver.get("https://www.exemple.com")

Si la page met du temps à afficher certains éléments, tu peux demander à Selenium d’attendre jusqu’à 10 secondes.

driver.implicitly_wait(10)

Étape 3 : Récupération du contenu de la page

Une fois la page chargée, tu récupères le DOM complet : le code source HTML obtenu après exécution du JavaScript.

html_content = driver.page_source

Étape 4 : Analyse du HTML avec BeautifulSoup

Passe maintenant ce code source à BeautifulSoup pour l’exploiter :

from bs4 import BeautifulSoup

# Créer un objet BeautifulSoup
soup = BeautifulSoup(html_content, 'html.parser')

# Exemple : récupérer tous les titres de la page
titres = soup.find_all('h2')
for titre in titres:
    print(titre.get_text())

BeautifulSoup propose des méthodes puissantes comme find(), find_all() et les sélecteurs CSS pour cibler et extraire des éléments précis du HTML.

Étape 5 : Fermeture du navigateur

Très important : ferme toujours ton navigateur après l’exécution pour libérer les ressources.

driver.quit()

Tu combines ainsi la puissance de Selenium pour simuler une navigation humaine (clics, défilements) avec l’efficacité de BeautifulSoup pour l’analyse du HTML. C’est la méthode idéale pour scraper un site qui charge ses données en JavaScript.

FAQ

Quel est le meilleur outil pour le web scraping en Python ?

Il n’y a pas d’outil de scraping universel, plutôt des solutions adaptées à ton projet. Voici les trois plus utilisés :

• BeautifulSoup : simple et efficace pour analyser du HTML et extraire rapidement du contenu. Idéal si tu débutes ou si tu as de petits projets.
• Scrapy : un framework complet, pensé pour gérer de gros volumes de données avec des fonctionnalités avancées.
• Playwright : parfait pour les sites complexes générés par JavaScript. Il simule un vrai navigateur et interagit avec la page comme un humain.

Comment utiliser BeautifulSoup pour extraire le contenu d’une balise div ?

Avec BeautifulSoup, tu cibles une balise précise grâce à un sélecteur CSS. Pour extraire le contenu d’une balise <div>, suis ces étapes.

1. Récupérer la page web avec requests, puis analyser le HTML avec BeautifulSoup.

from bs4 import BeautifulSoup
import requests

url = "URL_DE_TON_SITE"  # Remplace par l'URL réelle
reponse = requests.get(url)
html_content = reponse.text

soup = BeautifulSoup(html_content, "html.parser")

2. Utiliser la méthode select() avec ton sélecteur CSS pour cibler la balise <div>.

Pour récupérer le premier élément, utilise soup.select_one. Pour récupérer tous les éléments, utilise soup.select. Voici un exemple de code HTML :

<div>
  <h2>Titre de l'article</h2>
  <p>Voici le contenu du paragraphe.</p>
</div>

Et voici l’exemple avec le sélecteur CSS div.article :

# Récupérer le premier div avec la classe "article"
div_article = soup.select_one("div.article")

# Afficher son contenu texte
if div_article:
    print(div_article.get_text(strip=True))

3. Extraire les éléments à l’intérieur de la <div>.

# Récupérer le titre à l'intérieur du div
titre = soup.select_one("div.article h2").get_text()

# Récupérer le paragraphe à l'intérieur du div
paragraphe = soup.select_one("div.article p").get_text()

print("Titre :", titre)
print("Paragraphe :", paragraphe)

Comment utiliser Requests et BeautifulSoup ensemble ?

Ces deux bibliothèques sont complémentaires : l’une télécharge la page, l’autre l’analyse.

1. requests envoie une requête HTTP et télécharge le code HTML brut de la page.

import requests

url = "https://sitecible.com"
response = requests.get(url)  # requête HTTP
print(response.text)  # affiche le HTML brut

À ce stade, tu n’as qu’un énorme texte plein de balises (<html>, <div>, <p>, etc.).

2. BeautifulSoup analyse ce HTML brut et le transforme en une structure organisée. Tu peux alors naviguer dans la page, repérer les balises et récupérer les données.

from bs4 import BeautifulSoup

soup = BeautifulSoup(response.text, "html.parser")  # analyse le HTML
titre = soup.find("h1").get_text()  # extrait le contenu d'un <h1>
print(titre)

Pourquoi mon code de web scraping ne fonctionne pas sur certains sites ?

Il arrive que ton script ne récupère rien. Certains sites ne fournissent pas tout leur contenu directement en HTML : ils utilisent JavaScript pour charger les données dynamiquement. Or, BeautifulSoup ne sait pas analyser les données rendues par JavaScript. Dans ce cas, tu dois te tourner vers des outils comme Playwright ou Selenium.

Quel est le rôle de BeautifulSoup dans le web scraping ?

BeautifulSoup joue le rôle d’analyseur HTML. Il transforme le code d’une page en un objet structuré que tu peux parcourir facilement. En clair, c’est le traducteur entre le HTML brut et ton code Python.

Web scraping : BeautifulSoup ou Scrapy ?

BeautifulSoup et Scrapy sont vraiment différents, même si les deux servent au web scraping.

BeautifulSoup est le choix parfait pour débuter : il rend l’extraction de données HTML en Python simple et rapide.

Si tu préfères réduire au maximum la partie code, l’outil Bright Data propose des jeux de données prêts à l’emploi pour réduire la partie code.