Comment scraper Wikipedia en Pythonarticles, tableaux et infoboxes

Wikipedia est la plus grande encyclopédie de référence jamais constituée, et la quasi-totalité de son contenu est structurée de la même façon : un titre, un résumé introductif, une série de titres de sections, une infobox de faits clés et autant de tableaux de données que nécessaire. Cette régularité en fait l'une des sources publiques les plus utiles du web pour la recherche, l'enrichissement de contenu, les graphes de connaissances et les jeux de données d'entraînement. Ce guide vous montre comment scraper Wikipedia avec Python de manière propre et reproductible.

Tout ce qui suit se limite au contenu encyclopédique public : titres d'articles, résumés introductifs, titres de sections, champs d'infobox et tableaux que tout le monde peut consulter sans se connecter. Nous allons construire un petit scraper qui récupère une page d'article rendue via la Crawling API, analyse ces champs avec BeautifulSoup et les exporte en JSON et CSV. Le texte de Wikipedia est librement sous licence CC-BY-SA : avant de pointer cet outil sur quoi que ce soit de réel, lisez la section sur l'attribution et la légalité en fin d'article et envisagez l'API officielle MediaWiki, qui est la voie recommandée pour la plupart des projets.

Ce que vous allez construire

Un script Python qui prend l'URL d'un article Wikipedia, récupère la page via la Crawling API et analyse une poignée de champs structurés :

• Titre de l'article le titre de la page, extrait de l'élément firstHeading.
• Résumé les paragraphes d'introduction qui ouvrent l'article.
• Titres de sections les titres h2 et h3 qui structurent l'article.
• Champs de l'infobox les paires étiquette-valeur issues de l'infobox latérale (naissance, nationalité, profession, etc.).
• Tableaux les tableaux de données wikitable, analysés en lignes que vous pouvez écrire en CSV.

Chaque champ correspond à une classe CSS ou un identifiant d'élément stables de Wikipedia, ce qui fait fonctionner le scraper sur la plupart des pages d'articles, pas seulement une seule.

Pourquoi scraper via la Crawling API

Une page d'article Wikipedia est principalement du HTML rendu côté serveur, donc une requête ordinaire renverra souvent un balisage exploitable. Les difficultés apparaissent à l'échelle. Wikimedia demande aux clients automatisés de s'identifier, respecte strictement les limites de débit et ralentira ou bloquera le trafic qui martèle ses serveurs depuis une seule adresse. Si vous lancez une boucle intensive depuis une seule adresse de datacenter, vous atteindrez rapidement ces limites, et une IP bloquée stoppe toute la tâche.

Le routage des requêtes via la Crawling API résout le problème opérationnel. Vous lui envoyez l'URL de l'article, elle récupère la page depuis un pool tournant d'adresses IP de confiance, gère les nouvelles tentatives et vous restitue le HTML final à analyser. Cela évite qu'une seule adresse ne dépasse la limite de débit, et vous n'avez pas à maintenir un pool de proxies vous-même. L'approche d'analyse ci-dessous est la même que pour n'importe quelle source HTML, donc si vous y êtes novice, notre guide sur l'utilisation de BeautifulSoup en Python couvre en détail la partie extraction.

Prérequis

Quelques éléments à mettre en place au préalable. Aucun ne prend beaucoup de temps.

Python de base. Vous devez être à l'aise pour exécuter un script et installer des packages avec pip. La familiarité avec la structure HTML est utile, car tout le travail consiste à cibler des éléments par classe et par identifiant.

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

Un compte Crawlbase et un token. Inscrivez-vous, ouvrez votre tableau de bord et copiez votre token depuis la page de documentation du compte. Wikipedia est du HTML statique, donc le token de requête normale est le bon choix ici ; vous n'avez pas besoin du rendu JavaScript. Gardez le token en dehors du contrôle de version.

Configurer le projet

Créez un environnement virtuel isolé, puis installez les trois bibliothèques dont le scraper a besoin.

python --version

python -m venv wikipedia_env
source wikipedia_env/bin/activate

pip install crawlbase beautifulsoup4 pandas

Sous Windows, activez l'environnement avec wikipedia_env\Scripts\activate à la place de la ligne source. Trois dépendances font le travail : crawlbase est le client officiel de la Crawling API, beautifulsoup4 analyse le HTML retourné, et pandas transforme l'infobox et les tableaux en DataFrames que vous pouvez exporter en CSV.

Étape 1 : Récupérer le HTML de l'article

Commencez par charger la page brute. Importez CrawlingAPI, initialisez-la avec votre token et demandez l'URL d'un article. Vérifiez le code de statut avant d'analyser pour que les échecs soient visibles plutôt que silencieux. Nous utiliserons l'article Wikipedia sur Ada Lovelace comme exemple fil rouge, car il possède une infobox riche et plusieurs tableaux.

from crawlbase import CrawlingAPI

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

def crawl(page_url):
    response = api.get(page_url)
    if response["status_code"] == 200:
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['status_code']}")
    return None

if __name__ == "__main__":
    page_url = "https://en.wikipedia.org/wiki/Ada_Lovelace"
    html = crawl(page_url)
    print(html[:500] if html else "No HTML returned")

Exécutez ce script et vous devriez voir le début du HTML de l'article s'afficher dans votre terminal. Cela confirme que la requête a fonctionné et vous donne le balisage final à analyser. L'objet CrawlingAPI est créé une seule fois et réutilisé, ce qui est le schéma idéal lorsque vous commencez à récupérer de nombreuses pages en boucle par la suite.

Étape 2 : Analyser le titre et le résumé

Une fois le HTML en main, chargez-le dans BeautifulSoup. Wikipedia donne à l'en-tête de page l'identifiant firstHeading, et le résumé introductif est la suite de paragraphes dans le contenu principal avant le premier titre de section. Nous récupérons le titre depuis cet identifiant, puis nous collectons les paragraphes d'ouverture comme résumé.

from bs4 import BeautifulSoup

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

    title = soup.find("h1", id="firstHeading").get_text(strip=True)

    content = soup.find("div", class_="mw-parser-output")
    summary = []
    for p in content.find_all("p", recursive=False):
        text = p.get_text(strip=True)
        if text:
            summary.append(text)
        if len(summary) >= 3:
            break

    return title, " ".join(summary)

L'appel find('h1', id='firstHeading') cible précisément le titre de la page, avec le même sélecteur que celui que vous trouveriez en inspectant la page dans les outils de développement de votre navigateur. Pour le résumé, nous parcourons les paragraphes enfants directs de mw-parser-output, l'élément englobant le corps d'un article, et nous prenons les premiers non vides. Limiter à trois conserve l'introduction sans faire entrer tout l'article dans une seule chaîne de caractères.

Étape 3 : Collecter les titres de sections

Wikipedia structure chaque article avec une hiérarchie de titres cohérente. Dans la page rendue, le texte du titre de section se trouve dans des éléments de classe mw-headline, imbriqués sous les balises h2 et h3. Les collecter vous donne la table des matières dans l'ordre du document.

def parse_sections(soup):
    sections = []
    for tag in soup.find_all(["h2", "h3"]):
        headline = tag.find("span", class_="mw-headline")
        if headline:
            sections.append({
                "level": tag.name,
                "heading": headline.get_text(strip=True),
            })
    return sections

Nous n'enregistrons que les titres contenant un span mw-headline, ce qui filtre les balises h2 et h3 non pertinentes dans l'interface de la page et conserve les vraies sections de l'article. Enregistrer le niveau vous permet de reconstruire la hiérarchie ultérieurement : h2 pour les sections de premier niveau, h3 pour les sous-sections.

Étape 4 : Extraire les champs de l'infobox

L'infobox est le résumé encadré des faits clés sur le côté droit de nombreux articles. Wikipedia la marque avec la classe infobox, et chaque fait est une ligne de tableau associant une cellule d'étiquette (infobox-label) à une cellule de données (infobox-data). Parcourir ces lignes transforme l'infobox en un dictionnaire propre de champs.

def parse_infobox(soup):
    infobox = soup.find("table", class_="infobox")
    if not infobox:
        return {}

    fields = {}
    for row in infobox.find_all("tr"):
        label = row.find("th", class_="infobox-label")
        data = row.find("td", class_="infobox-data")
        if label and data:
            key = label.get_text(strip=True)
            value = data.get_text(" ", strip=True)
            fields[key] = value

    image = infobox.select_one(".infobox-image img")
    if image and image.has_attr("src"):
        fields["image"] = "https:" + image["src"]

    return fields

Chaque paire infobox-label / infobox-data devient une entrée clé-valeur, ce qui permet à l'infobox d'une personne de produire des champs comme Naissance, Décès, Lieu de repos, Nationalité et Profession sans que vous ayez à les nommer à l'avance. L'appel get_text(" ", strip=True) joint les valeurs sur plusieurs lignes avec un espace, ce qui rend lisibles sur une seule ligne les listes de plusieurs nationalités par exemple. Nous récupérons également l'image principale depuis .infobox-image img et préfixons https: car Wikipedia sert les URLs d'images en protocol-relative.

Étape 5 : Analyser les tableaux de données

Les tableaux d'articles utilisent la classe wikitable. Pandas lit directement les tableaux HTML, donc l'approche la plus propre consiste à passer le HTML de chaque tableau à pandas.read_html et à le laisser retourner un DataFrame. Cela vous donne des lignes et des colonnes prêtes pour le CSV sans presque aucun parcours manuel de cellules. Si vous voulez la technique générale au-delà de Wikipedia, consultez notre guide pour scraper des tableaux depuis un site web.

import pandas as pd
from io import StringIO

def parse_tables(soup):
    tables = []
    for node in soup.find_all("table", class_="wikitable"):
        try:
            df = pd.read_html(StringIO(str(node)))[0]
            tables.append(df)
        except ValueError:
            continue
    return tables

Nous bouclons sur chaque wikitable, passons son HTML à read_html et conservons le premier DataFrame retourné pour chacun. Entourer l'appel dans un try signifie qu'un tableau malformé est ignoré plutôt que de faire planter l'exécution. Le résultat est une liste de DataFrames, un par tableau, que vous pouvez écrire dans des fichiers CSV séparés ou concaténer selon les besoins. Pour nettoyer ces DataFrames avant utilisation en aval, notre guide sur la façon de structurer et nettoyer des données scrapées pour l'IA et le ML couvre les étapes courantes.

Étape 6 : Tout assembler et exporter

Reliez maintenant les pièces en un seul script exécutable. Il récupère l'article, analyse chaque champ, écrit les données structurées en JSON et écrit chaque tableau dans son propre fichier CSV.

import json
from io import StringIO
import pandas as pd
from bs4 import BeautifulSoup
from crawlbase import CrawlingAPI

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

def crawl(page_url):
    response = api.get(page_url)
    if response["status_code"] == 200:
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['status_code']}")
    return None

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

    title = soup.find("h1", id="firstHeading").get_text(strip=True)

    content = soup.find("div", class_="mw-parser-output")
    summary = []
    for p in content.find_all("p", recursive=False):
        text = p.get_text(strip=True)
        if text:
            summary.append(text)
        if len(summary) >= 3:
            break

    sections = []
    for tag in soup.find_all(["h2", "h3"]):
        headline = tag.find("span", class_="mw-headline")
        if headline:
            sections.append(headline.get_text(strip=True))

    infobox = {}
    box = soup.find("table", class_="infobox")
    if box:
        for row in box.find_all("tr"):
            label = row.find("th", class_="infobox-label")
            data = row.find("td", class_="infobox-data")
            if label and data:
                infobox[label.get_text(strip=True)] = data.get_text(" ", strip=True)

    tables = []
    for node in soup.find_all("table", class_="wikitable"):
        try:
            tables.append(pd.read_html(StringIO(str(node)))[0])
        except ValueError:
            continue

    return {
        "title": title,
        "summary": " ".join(summary),
        "sections": sections,
        "infobox": infobox,
    }, tables

def main():
    page_url = "https://en.wikipedia.org/wiki/Ada_Lovelace"
    html = crawl(page_url)
    if not html:
        return

    article, tables = scrape_article(html)
    article["source_url"] = page_url
    article["license"] = "CC BY-SA 4.0"

    with open("wikipedia.json", "w", encoding="utf-8") as f:
        json.dump(article, f, indent=2, ensure_ascii=False)

    for i, df in enumerate(tables):
        df.to_csv(f"wikipedia_table_{i}.csv", index=False)

    print(json.dumps(article, indent=2, ensure_ascii=False))
    print(f"Saved {len(tables)} table(s) to CSV")

if __name__ == "__main__":
    main()

Le script écrit le titre, le résumé, les sections et l'infobox dans wikipedia.json, et chaque wikitable dans son propre CSV numéroté. Notez les deux champs supplémentaires que nous attachons avant l'enregistrement : source_url et license. Enregistrer la provenance des données et leur licence CC-BY-SA n'est pas une formalité comptable optionnelle, c'est la façon de respecter l'exigence d'attribution que couvre la section sur la légalité ci-dessous.

À quoi ressemble la sortie

Exécutez le script complet et le fichier JSON contient un enregistrement propre et structuré de l'article.

{
  "title": "Ada Lovelace",
  "summary": "Augusta Ada King, Countess of Lovelace, was an English mathematician and writer...",
  "sections": [
    "Biography",
    "Work",
    "Commemoration",
    "In popular culture"
  ],
  "infobox": {
    "Born": "Augusta Ada Byron 10 December 1815 London, England",
    "Died": "27 November 1852 (aged 36) Marylebone, London, England",
    "Occupation": "Mathematician"
  },
  "source_url": "https://en.wikipedia.org/wiki/Ada_Lovelace",
  "license": "CC BY-SA 4.0"
}

À côté, vous obtenez un CSV par tableau, nommé wikipedia_table_0.csv, wikipedia_table_1.csv, etc., chacun avec la ligne d'en-tête et les lignes de données analysées par pandas. À partir de là, le JSON alimente une base de connaissances ou un pipeline de contenu, et les CSV s'intègrent directement dans un tableur ou une base de données.

Passer à l'échelle sur de nombreux articles

Pour construire un jeu de données, encapsulez la boucle de récupération et d'analyse sur une liste d'URL d'articles et cadencez les requêtes. Wikipedia est sensible au trafic en rafale, donc un petit délai entre les pages fait de vous un client poli.

import time

urls = [
    "https://en.wikipedia.org/wiki/Ada_Lovelace",
    "https://en.wikipedia.org/wiki/Alan_Turing",
    "https://en.wikipedia.org/wiki/Grace_Hopper",
]

dataset = []
for url in urls:
    html = crawl(url)
    if html:
        article, _ = scrape_article(html)
        article["source_url"] = url
        dataset.append(article)
    time.sleep(2)

print(f"Collected {len(dataset)} articles")

Le time.sleep(2) entre les requêtes est la seule habitude la plus importante lors de la collecte sur Wikipedia à tout volume. Cadencez votre exécution, gardez des lots modestes, et arrêtez lorsque vous avez l'échantillon dont vous avez besoin. Pour les extractions structurées en volume, l'API MediaWiki et les dumps de base de données sont toutefois réellement plus rapides et moins lourds pour les serveurs de Wikimedia, et nous les recommandons ci-après.

Est-il légal de scraper Wikipedia ?

Wikipedia est l'un des grands sites les plus permissifs avec lesquels travailler, car son contenu textuel est librement sous licence Creative Commons Attribution-ShareAlike (CC-BY-SA). Cela signifie que vous êtes autorisé à réutiliser et même redistribuer le texte des articles, y compris dans des projets commerciaux, sous deux conditions : vous attribuez la source (créditez Wikipedia et les contributeurs, typiquement avec un lien vers l'article), et vous partagez tout travail dérivé sous la même licence. Certains médias intégrés, comme certaines images, ont leur propre licence séparée, vérifiez donc la page de fichier avant de réutiliser une image. Les champs license et source_url enregistrés par le script existent précisément pour que vous puissiez satisfaire l'exigence d'attribution en aval.

Une licence permissive n'est pas une autorisation d'ignorer les serveurs. Les conditions de Wikimedia demandent aux clients automatisés de respecter les limites de débit, de s'identifier et d'éviter de dégrader le service pour les lecteurs humains. Marteler le site dans une boucle serrée est à la fois impoli et susceptible de faire bloquer votre IP. Gardez le volume modeste, cadencez vos requêtes comme indiqué ci-dessus et lisez le robots.txt du site. Ce tutoriel se limite au contenu encyclopédique public uniquement ; il ne touche pas les pages de comptes utilisateurs, les historiques de modifications liés à des individus, ni quoi que ce soit derrière une authentification.

Pour tout ce qui dépasse une poignée de pages, la voie recommandée est l'outillage officiel. L'API MediaWiki retourne le contenu structuré des articles, y compris les sections analysées et les données d'infobox, sans que vous ayez à scraper le HTML rendu, et Wikimedia publie également des dumps de base de données complets de toute l'encyclopédie pour une utilisation en masse. Les deux sont plus rapides, plus stables et bien moins lourds pour l'infrastructure de Wikimedia que le scraping HTML à l'échelle. Utilisez le scraping HTML lorsque vous avez besoin exactement de ce qu'un lecteur voit sur une page donnée ; utilisez l'API ou les dumps lorsque vous avez besoin du volume.

Foire aux questions

Ai-je besoin du token JavaScript pour scraper Wikipedia ?

Non. Les pages d'articles Wikipedia sont du HTML statique rendu côté serveur, donc le token de requête normale suffit. Le token JavaScript existe pour les sites rendus côté client qui construisent leur contenu dans le navigateur, ce que Wikipedia ne fait pas. Utiliser le token normal rend chaque requête plus légère et évite l'étape de rendu supplémentaire.

Comment extraire les champs d'infobox de manière fiable ?

Trouvez l'élément table.infobox, puis parcourez ses lignes en associant chaque th.infobox-label avec sa cellule td.infobox-data. Cette structure étiquette-valeur est cohérente entre les articles, donc la même boucle transforme l'infobox d'une personne, d'un pays ou d'un film en dictionnaire propre sans coder les noms de champs en dur.

Puis-je scraper des tableaux Wikipedia en CSV ?

Oui. Sélectionnez chaque table.wikitable, passez le HTML de chacun à pandas.read_html et vous obtenez un DataFrame par tableau que vous écrivez avec to_csv. Entourer la lecture dans un try signifie qu'un tableau malformé est ignoré au lieu d'arrêter l'exécution.

Est-il légal d'utiliser commercialement du contenu Wikipedia scrapé ?

Le texte de Wikipedia est sous licence CC-BY-SA, qui autorise la réutilisation commerciale à condition d'attribuer Wikipedia et les contributeurs et de partager le travail dérivé sous la même licence. Les médias intégrés peuvent avoir leur propre licence, vérifiez donc chaque fichier avant de réutiliser des images. Enregistrez l'URL source et la licence avec vos données pour que l'attribution soit simple ultérieurement.

Dois-je utiliser l'API MediaWiki plutôt que de scraper ?

Pour tout ce qui est en volume, oui. L'API MediaWiki retourne directement le contenu structuré des articles, et Wikimedia publie des dumps complets de base de données pour une utilisation en masse. Les deux sont plus rapides et bien moins lourds pour les serveurs de Wikipedia que le scraping HTML. Le scraping HTML est le bon outil lorsque vous avez besoin exactement de ce qu'un lecteur voit sur une page spécifique ; l'API et les dumps sont préférables pour construire de grands jeux de données.

Comment éviter d'être bloqué en scrapant Wikipedia ?

Maintenez un faible taux de requêtes, ajoutez un vrai délai entre les pages comme indiqué dans la section mise à l'échelle, et routez via des IP tournantes pour qu'aucune adresse individuelle ne soit ralentie. La Crawling API gère la rotation et les nouvelles tentatives pour vous. Lisez le robots.txt du site, gardez des lots modestes et préférez l'API officielle ou les dumps pour les grands travaux afin de rester un client poli.

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.