Comment faire du web scraping sur Python avec BeautifulSoup ?

Vous voulez plonger dans le monde du web scraping mais sans vous perdre dans des codes compliqués ?

Avec Python et la bibliothèque BeautifulSoup, vous pouvez facilement extraire et organiser les données d’un site web en quelques lignes seulement.

Prérequis pour faire du scraping sur Python avec BeautifulSoup

✅ Avant de vous lancer, il est important d’avoir quelques bases en programmation. Cela vous permet de mieux comprendre le fonctionnement du code. Pas besoin d’être expert, mais savoir lire et exécuter un script Python vous aidera beaucoup.

Ensuite, voici ce que vous devez effectuer en premier lieu pour faire du scraping sur Python avec BeautifulSoup :

pip install beautifulsoup4

pip install requests

Comment faire du web scraping avec Python et BeautifulSoup ?

Suivez notre tutoriel pour un projet de web scraping simple.

Projet : récupérer le titre d’une page et tous les liens qu’elle contient.

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

Pour effectuer une requête HTTP GET vers une URL, il faut utiliser la bibliothèque Requests.

📌 Quand vous envoyez une requête HTTP avec Requests, le serveur renvoie toujours un code de statut. Ces codes indiquent si la requête a réussi ou non.

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

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

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

# 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"))

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

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

# 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"]')

Les sélecteurs CSS sont très puissants si vous voulez cibler exactement certaines parties d’une page sans parcourir tout le HTML manuellement.

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

Jusqu’ici, nous avons vu comment récupérer des titres, des liens ou encore du texte dans une page web.

⚠ Mais souvent, les vrais cas d’utilisation sont plus complexes : extraction de données structurées comme des tableaux ou des listes, la gestion de la pagination ou encore la résolution d’erreurs fréquentes liées au scraping. C’est exactement ce que nous allons voir ensemble.

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>, <li>). Pour transformer ces structures en données exploitables, il faut apprendre à les parcourir ligne par ligne ou élément par élément.

Quand vous voulez 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 vraies données.
• ✅ Stocker les informations dans une liste ou un dictionnaire.

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

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

En résumé :

Les balises <table>, <tr>, <th>, <td> servent à reconstruire un tableau.
Les balises <ul>/<ol>, <li> permettent de transformer une liste HTML en 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. On boucle 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"]

Ici, 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 sur plusieurs via des liens de “page suivante” ou une pagination numérotée (?page=1, ?page=2, …).

📌 Dans les deux cas, vous devez boucler (parcourir en boucle) 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 :

• Préparer 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érer le HTML de la page.

requests.get(url)

• Limiter le temps d’attente si le site ne répond pas.

requests.get(url, timeout=20)

• Parser la page.

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

• Récupérer tous les titres d’articles.

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

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

all_articles.extend(articles)

• Introduire 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 toujours appuyer sur un bouton et tout est bon. Vous pourrez rencontrer des obstacles fréquents comme :

• Les erreurs HTTP

404 : page non trouvée
403 : accès interdit
500 : erreur côté serveur

Exemple :

response = requests.get(url)
if response.status_code == 200:
    # Page OK
    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, vous ne verrez rien.

✅ Dans ce cas, il faut utiliser des outils comme Selenium ou Playwright.

Par ailleurs, si vous voulez scraper efficacement sans vous faire bloquer ni abîmer le site, voici les meilleures pratiques :

• ✔ Respecter le fichier robots.txt d’un site web.
• ✔ Mettre en place des délais entre les requêtes pour ne pas surcharger le serveur (utilisation de time.sleep()).
• ✔ Utiliser des proxies et les faire tourner.
• ✔ Changer régulièrement votre User-Agent.

Comment faire du web scraping avec Selenium et BeautifulSoup ?

⚠ Petit rappel : BeautifulSoup est un excellent analyseur HTML, mais il ne peut pas exécuter JavaScript d’une page web. C’est là que Selenium devient votre allié !

En gros, Selenium contrôle un vrai navigateur, exécute JavaScript et affiche la page comme si un humain naviguait. BeautifulSoup va ensuite analyser le code HTML une fois que la page est complètement rendue. Ainsi, vous pourrez extraire ce que vous voulez.

Étape 1 : Installer Selenium et BeautifulSoup

Ici, au lieu d’utiliser la bibliothèque Request, on va utiliser Selenium. Pour l’installer, il faut passer par pip.

pip install selenium beautifulsoup4 

Ensuite, vous devez télécharger et installer un WebDriver qui correspond à la version de votre navigateur (exemple : ChromeDrive pour Google Chrome).

✅ Vous pouvez soit le placer dans le même dossier que votre script Python, soit l’ajouter à la variable d’environnement PATH de votre système.

Étape 2 : Configurer Selenium

Avant tout, il faut importer webdriver depuis Selenium pour pouvoir contrôler un navigateur.

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

On lance ensuite un navigateur. C’est lui qui ouvrira la page web et exécutera le JavaScript (Exemple : Chrome).

driver = webdriver.Chrome() 

Vous indiquez au navigateur quelle page visiter.

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

Si la page met du temps à afficher certains éléments, vous pouvez dire à Selenium d’attendre un peu.

driver.implicitly_wait(10) 

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

Une fois la page chargée, vous récupérez le DOM complet (code source HTML après exécution du JS).

html_content = driver.page_source 

Étape 4 : Analyse du HTML avec BeautifulSoup

Passez maintenant ce code source à BeautifulSoup pour pouvoir 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 offre des méthodes puissantes comme find(), find_all(), et les sélecteurs CSS pour cibler et extraire des éléments précis du code HTML.

Étape 5 : Fermeture du navigateur

Très important : fermez toujours votre navigateur après l’exécution pour libérer les ressources !

driver.quit() 

✅ Et voilà ! Vous pouvez ainsi combiner la puissance de Selenium pour simuler une navigation humaine (clics, défilements, etc.) avec l’efficacité de BeautifulSoup pour l’analyse du code HTML.

FAQ

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

Il n’y a pas vraiment de meilleur outil universel, mais plutôt des solutions adaptées selon votre projet.

🔥 BeautifulSoup : simple et efficace pour analyser du HTML et extraire rapidement du contenu. Il est idéal si vous débutez ou si vous avez de petits projets.

🔥 Scrapy : c’est 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, car il simule un vrai navigateur et permet d’interagir avec la page comme un humain.

Comment utiliser BeautifulSoup pour extraire du contenu d’une balise <div> ?

Avec BeautifulSoup, vous pouvez cibler une balise précise grâce à un sélecteur CSS. Pour extraire du contenu d’une balise <div>, voici les étapes :

1. Récupérer la page avec Requests, puis analyser avec BeautifulSoup

from bs4 import BeautifulSoup
import requests

url = "URL_DE_VOTRE_SITE" # Remplacez 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() en lui passant votre sélecteur CSS pour cibler la balise <div>

Pour récupérer le premier élément, utilisez soup.select_one
Pour récupérer tous les éléments, utilisez soup.select

Exemple HTML :

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

Exemple avec CSS :

# 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))

Ici, le sélecteur CSS est div.article.

3. Extraire des é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.

1. Requests récupère le contenu d’une page web avec une requête HTTP.

Elle envoie une requête HTTP vers le site cible 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, vous n’avez qu’un texte énorme plein de balises (<html>,<div><p>, etc.).

2. BeautifulSoup analyse ce contenu HTML pour extraire ce qui vous intéresse.

Elle prend le HTML brut et le transforme en une structure organisée. Grâce à ça, vous pouvez naviguer facilement à l’intérieur du HTML : faire du repérage, extraire 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 votre script ne récupère rien, car certains sites ne fournissent pas tout le contenu directement en HTML.

Ces sites utilisent JavaScript pour charger dynamiquement les données. Or, BeautifulSoup ne permet pas d’analyser des données rendues par JavaScript.

Dans ce cas, vous devez vous 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 prend le code source d’une page sous forme de texte brut et le transforme en un objet structuré que vous pouvez parcourir facilement.

Sans cette bibliothèque, vous verrez un énorme bloc de texte illisible. En clair, BeautifulSoup est le traducteur entre le HTML brut et votre code Python.

Web scraping : BeautifulSoup vs Scrapy ?

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

Pour tout résumé, BeautifulSoup facilite l’extraction de données HTML en Python. Cette bibliothèque est parfaite pour débuter, car elle rend le scraping simple et rapide.

Sinon, si vous ne voulez pas coder, l’outil complet Bright Data est également une excellente solution pour faire du web scraping.

👉 Maintenant, dites-nous en commentaire ce que vous avez réussi à scraper !