Extraire IMDb avec Python : un code qui fonctionne vraiment

Si vous avez récemment cherché « scrape IMDb with Python », vous avez sans doute remarqué une chose : la plupart des tutoriels qu’on trouve sont cassés. Pas « un peu dépassés » cassés — plutôt du genre « renvoie zéro résultat et une pluie d’erreurs NoneType » cassés.

J’ai passé les dernières semaines à tester tous les grands tutoriels d’extraction IMDb que j’ai pu trouver — GeeksforGeeks, Medium, freeCodeCamp, notebooks Kaggle, j’ai tout essayé. Sur tagués pour l’extraction IMDb, l’immense majorité s’appuie sur des sélecteurs CSS (td.titleColumn, td.ratingColumn) qui n’existent plus depuis juin 2023, quand IMDb a refondu sa page Top 250. Résultat : des forums remplis de développeurs qui demandent « pourquoi mon code renvoie-t-il vide ? » et des mainteneurs de bibliothèques populaires comme : « On ne peut pas faire grand-chose, à part corriger chaque parser. » Ce guide présente deux méthodes Python qui fonctionnent vraiment aujourd’hui, explique comment gérer la pagination et les erreurs fréquentes, précise quand Python n’est même pas le bon outil, et montre comment garder votre scraper pérenne pour éviter qu’il finisse au cimetière des scripts cassés.

Que signifie extraire IMDb avec Python ?

Le web scraping consiste à extraire automatiquement des données depuis des pages web — au lieu de copier-coller à la main, vous écrivez un script qui le fait pour vous. Quand on parle de « scraper IMDb », il s’agit d’extraire des données cinématographiques structurées (titres, notes, genres, casting, durée, nombre de votes) depuis les pages IMDb à l’aide de Python.

La pile Python classique pour ce genre de tâche repose sur trois bibliothèques : requests (pour récupérer la page), BeautifulSoup (pour analyser le HTML et repérer les données) et pandas (pour organiser et exporter les résultats). Certains tutoriels utilisent aussi Selenium ou Playwright pour les pages qui nécessitent du JavaScript, mais comme vous allez le voir, il existe des approches plus rapides.

Un point important : tout ce guide a été vérifié par rapport à la structure actuelle des pages IMDb, à la mi-2025. IMDb modifie son interface environ tous les 6 à 12 mois ; si vous lisez ceci en 2027, certains sélecteurs auront peut-être changé. (J’expliquerai aussi comment gérer cela.)

Pourquoi extraire IMDb avec Python ? Cas d’usage concrets

Avant d’écrire la moindre ligne de code, que feriez-vous réellement des données IMDb ? La réponse dépend de votre profil.

Le jeu de données de critiques IMDb est l’un des benchmarks NLP les plus utilisés au monde — l’article fondateur de Maas et al. (2011) a accumulé , et l’ensemble est intégré à TensorFlow, Keras et PyTorch. Sur Hugging Face, le dataset stanfordnlp/imdb est téléchargé 213 321 fois par mois et a servi à entraîner plus de 1 500 modèles. Si vous travaillez en machine learning, vous connaissez sans doute déjà ces données.

Mais les usages vont bien au-delà du monde académique :

Rien que le marché du tourisme cinématographique pèserait . Netflix a dépensé plus de 17 milliards de dollars en contenu en 2024, avec tirée par des recommandations personnalisées. En clair : les données IMDb alimentent des décisions concrètes dans de nombreux secteurs.

Vos options pour obtenir des données IMDb (avant même d’écrire du code)

C’est la partie que la plupart des tutoriels passent complètement sous silence. Ils enchaînent sur pip install beautifulsoup4 sans même se demander si le scraping Python est la bonne approche pour votre cas.

Voici le panorama complet :

Quelques précisions sur ces options. Cinemagoer n’a pas eu de publication PyPI depuis mai 2023 et la plupart de ses parsers ont cassé après la refonte d’IMDb en juin 2025 — je ne le recommanderais pas pour un usage en production aujourd’hui. TMDb est excellent, mais utilise son propre système de notation, pas celui d’IMDb. Et l’API entreprise officielle d’IMDb coûte via AWS Data Exchange, ce qui n’est pas une option pour la plupart d’entre nous.

Pour les lecteurs qui ne veulent pas écrire de code, lit la page IMDb, propose automatiquement les champs à extraire (titre, note, année, genre), puis exporte en deux clics vers Excel, Google Sheets, Airtable ou Notion. L’IA s’adapte lorsque la mise en page d’IMDb change, donc aucun sélecteur à maintenir. On y revient plus loin.

Pour ceux qui veulent quand même coder en Python, voici deux méthodes qui fonctionnent.

Méthode 1 : extraire IMDb avec Python via BeautifulSoup (approche traditionnelle)

C’est l’approche classique qu’on retrouve dans la plupart des tutoriels. Elle fonctionne, mais soyons francs : c’est la méthode la plus fragile présentée ici. Les noms de classes CSS d’IMDb sont générés automatiquement et changent lors des refontes. Cela dit, c’est la meilleure façon d’apprendre les bases du web scraping.

Étape 1 : installer et importer les bibliothèques Python

Vous avez besoin de quatre paquets :

1pip install requests beautifulsoup4 pandas lxml

Rôle de chacun :

• requests — envoie les requêtes HTTP pour récupérer la page
• beautifulsoup4 — analyse le HTML pour rechercher des éléments précis
• pandas — organise les données extraites en tableaux et exporte en CSV/Excel
• lxml — parseur HTML rapide (BeautifulSoup peut l’utiliser en backend)

Bloc d’import :

1import requests
2from bs4 import BeautifulSoup
3import pandas as pd

Étape 2 : envoyer une requête HTTP à IMDb

C’est souvent ici que les débutants tombent sur leur premier blocage. IMDb bloque les requêtes qui n’incluent pas un en-tête User-Agent correct — vous obtiendrez une erreur 403 Forbidden. La chaîne user-agent par défaut de Python Requests (python-requests/2.31.0) est repérée immédiatement.

1url = "https://www.imdb.com/chart/top/"
2headers = {
3    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
4    "Accept-Language": "en-US,en;q=0.9"
5}
6response = requests.get(url, headers=headers)
7if response.status_code != 200:
8    print(f"Échec de la récupération de la page : {response.status_code}")
9else:
10    print("Page récupérée avec succès")

L’en-tête Accept-Language compte aussi — sans lui, IMDb peut renvoyer un contenu dans une autre langue selon la géolocalisation de votre adresse IP.

Étape 3 : analyser le HTML avec BeautifulSoup

Une fois le HTML obtenu, créez un objet BeautifulSoup et commencez à chercher les bons éléments. Ouvrez la page IMDb Top 250 dans Chrome, faites un clic droit sur un titre de film, puis cliquez sur « Inspecter » pour voir la structure HTML sous-jacente.

1soup = BeautifulSoup(response.text, "lxml")

À la mi-2025, la page Top 250 utilise ces sélecteurs :

• Conteneur du film : li.ipc-metadata-list-summary-item
• Titre : h3.ipc-title__text
• Année : span.cli-title-metadata-item (premier span)
• Note : span.ipc-rating-star--rating

Attention : ces classes préfixées par ipc- sont générées par le système de composants d’IMDb. Elles sont restées stables depuis la refonte de juin 2023, mais rien ne garantit qu’elles ne changeront pas encore.

Étape 4 : extraire les données des films (titre, année, note)

Ici, je m’écarte de la plupart des tutoriels : j’ajoute une gestion d’erreurs via try/except. Aucun des guides concurrents que j’ai consultés ne le fait, et c’est exactement pour cela que leur code casse silencieusement quand un sélecteur change.

1movies = []
2movie_items = soup.select("li.ipc-metadata-list-summary-item")
3for item in movie_items:
4    try:
5        title_tag = item.select_one("h3.ipc-title__text")
6        title = title_tag.text.strip() if title_tag else "N/A"
7        year_tag = item.select_one("span.cli-title-metadata-item")
8        year = year_tag.text.strip() if year_tag else "N/A"
9        rating_tag = item.select_one("span.ipc-rating-star--rating")
10        rating = rating_tag.text.strip() if rating_tag else "N/A"
11        movies.append({
12            "title": title,
13            "year": year,
14            "rating": rating
15        })
16    except Exception as e:
17        print(f"Erreur lors de l’analyse du film : {e}")
18        continue
19print(f"{len(movies)} films extraits")

Étape 5 : enregistrer au format CSV ou Excel avec Pandas

1df = pd.DataFrame(movies)
2df.to_csv("imdb_top_250.csv", index=False)
3df.to_excel("imdb_top_250.xlsx", index=False)
4print(df.head())

Exemple de sortie :

1                          title  year rating
20  1. The Shawshank Redemption  1994    9.3
31           2. The Godfather    1972    9.2
42     3. The Dark Knight        2008    9.0
53  4. The Godfather Part II     1974    9.0
64         5. 12 Angry Men       1957    9.0

Ça marche. Mais tout repose sur des sélecteurs CSS qui peuvent casser du jour au lendemain — ce qui nous amène à l’approche que je recommande vraiment.

Méthode 2 : l’astuce JSON-LD — éviter complètement l’analyse du HTML

C’est la technique qu’aucun article concurrent ne couvre, et celle que j’utiliserais pour tout projet sérieux. IMDb intègre des données structurées au format (JavaScript Object Notation for Linked Data) dans des balises <script type="application/ld+json"> sur chaque page. Ces données suivent le standard Schema.org, sont utilisées par Google pour les résultats enrichis, et changent beaucoup moins souvent que les noms de classes CSS.

L’outil Apify IMDb Scraper, de niveau production, applique d’ailleurs cet ordre de priorité : « JSON-LD > NEXT_DATA > DOM ». C’est aussi l’ordre que je recommande.

Pourquoi le JSON-LD est plus fiable que les sélecteurs CSS

Les noms de classes comme ipc-metadata-list-summary-item sont générés automatiquement par le système de composants React d’IMDb et changent à chaque refonte. Le schéma JSON-LD représente le vrai modèle de données, pas la couche d’affichage. C’est un peu comme la différence entre lire la table des matières d’un livre et essayer d’identifier ses chapitres à partir de la taille de la police.

Étape par étape : extraire les données IMDb depuis le JSON-LD

Étape 1 : récupérer la page

Même logique qu’avant — utilisez requests avec un en-tête User-Agent correct.

1import requests
2from bs4 import BeautifulSoup
3import json
4import pandas as pd
5url = "https://www.imdb.com/chart/top/"
6headers = {
7    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
8    "Accept-Language": "en-US,en;q=0.9"
9}
10response = requests.get(url, headers=headers)
11soup = BeautifulSoup(response.text, "lxml")

Étape 2 : trouver la balise script JSON-LD

1script_tag = soup.find("script", {"type": "application/ld+json"})
2if not script_tag:
3    print("Aucun JSON-LD trouvé sur cette page")
4else:
5    data = json.loads(script_tag.string)
6    print(f"JSON-LD trouvé avec le type : {data.get('@type', 'inconnu')}")

Étape 3 : analyser les données structurées

Sur la page Top 250, le JSON-LD contient un tableau itemListElement avec les 250 films. Chaque entrée inclut la position, le nom, l’URL, aggregateRating, datePublished, les genres, la description, ainsi que des tableaux pour le réalisateur et les acteurs.

1movies = []
2for item in data.get("itemListElement", []):
3    movie = item.get("item", {})
4    rating_info = movie.get("aggregateRating", {})
5    movies.append({
6        "rank": item.get("position"),
7        "title": movie.get("name"),
8        "url": movie.get("url"),
9        "rating": rating_info.get("ratingValue"),
10        "vote_count": rating_info.get("ratingCount"),
11        "date_published": movie.get("datePublished"),
12        "genre": ", ".join(movie.get("genre", [])),
13        "description": movie.get("description"),
14    })

Étape 4 : exporter au format CSV

1df = pd.DataFrame(movies)
2df.to_csv("imdb_top_250_json_ld.csv", index=False)
3print(df.head())

Exemple de sortie :

1   rank                      title                                     url  rating  vote_count date_published              genre
20     1  The Shawshank Redemption  https://www.imdb.com/title/tt0111161/     9.3     2900000     1994-10-14     Drama
31     2            The Godfather   https://www.imdb.com/title/tt0068646/     9.2     2000000     1972-03-24     Crime, Drama
42     3          The Dark Knight   https://www.imdb.com/title/tt0468569/     9.0     2800000     2008-07-18     Action, Crime, Drama

Les 250 films sont là. Propre, structuré, sans jongler avec des sélecteurs CSS. Et comme ces données respectent le standard Schema.org (sur lequel Google s’appuie pour les résultats enrichis), elles ont beaucoup moins de chances de changer que la mise en page visuelle.

Bonus : __NEXT_DATA__ pour les pages de film individuelles

Pour obtenir des données plus riches sur une page titre individuelle (durée, casting complet, résumé, images d’affiche), IMDb intègre aussi un objet JSON __NEXT_DATA__. C’est la donnée que React utilise pour hydrater la page — elle ne peut pas être supprimée sans casser le site.

1# Sur une page de film individuelle comme /title/tt0111161/
2next_data_tag = soup.find("script", {"id": "__NEXT_DATA__"})
3if next_data_tag:
4    next_data = json.loads(next_data_tag.string)
5    above_fold = next_data["props"]["pageProps"]["aboveTheFoldData"]
6    title = above_fold["titleText"]["text"]
7    year = above_fold["releaseYear"]["year"]
8    rating = above_fold["ratingsSummary"]["aggregateRating"]
9    runtime_seconds = above_fold.get("runtime", {}).get("seconds", 0)
10    genres = [g["text"] for g in above_fold["genres"]["genres"]]
11    plot = above_fold["plot"]["plotText"]["plainText"]

Utilisez JSON-LD pour les pages de listes/tableaux, et __NEXT_DATA__ pour les pages de titres individuels. C’est l’approche de niveau production.

Pourquoi votre scraper IMDb casse sans arrêt (et comment le corriger)

C’est le point de friction le plus souvent cité sur tous les forums d’extraction IMDb que j’ai consultés. Les utilisateurs écrivent : « Une partie du code a cassé à cause des changements d’interface » ou « Ça ne marche plus en 2024 ! » — et la réponse est généralement le silence ou « essayez Selenium ».

La cause profonde est la migration continue d’IMDb vers une interface React/Next.js. Voici la chronologie des principaux changements cassants :

Ça fait grosso modo une cassure majeure tous les 6 à 12 mois. Si votre scraper repose sur des noms de classes CSS, vous courez sur un tapis roulant.

Erreurs courantes et solutions

Résultats vides / erreurs NoneType

L’erreur la plus fréquente. Vous verrez AttributeError: 'NoneType' object has no attribute 'text'. Cela signifie que BeautifulSoup n’a pas trouvé l’élément recherché — généralement parce que le nom de la classe CSS a changé ou que le contenu est rendu par JavaScript.

Solution : passez à l’extraction JSON-LD (Méthode 2 ci-dessus). Les données sont dans la réponse HTML initiale, aucun JavaScript requis.

403 Forbidden

IMDb utilise pour détecter et bloquer les bots. Le premier déclencheur est l’absence d’un en-tête User-Agent crédible ou sa falsification trop évidente. C’est documenté dans projets open source ainsi que sur les , où un employé IMDb a reconnu le problème.

Solution : incluez toujours une chaîne User-Agent de navigateur réaliste et un en-tête Accept-Language: en-US. Utilisez requests.Session() pour le pooling de connexions.

Seulement 25 résultats retournés

Les pages de recherche IMDb et les listes « Most Popular » utilisent le chargement différé — elles n’affichent qu’environ 25 résultats au départ et en chargent davantage via AJAX au fil du défilement.

Solution : utilisez la pagination par paramètre d’URL (décrite dans la section suivante) ou passez à la page Top 250, qui charge les 250 films en une seule réponse.

Les sélecteurs cessent soudainement de fonctionner

Sélecteurs devenus obsolètes : td.titleColumn, td.ratingColumn, .lister-item-header, .inline-block.ratings-imdb-rating. Si votre code utilise l’un d’eux, il est cassé.

Solution : privilégiez les attributs data-testid (par exemple h1[data-testid="hero-title-block__title"]) plutôt que les noms de classes générés automatiquement. Mieux encore : utilisez JSON-LD.

Un cadre de décision : correctifs à court terme vs long terme

• Correctif rapide : ajoutez des blocs try/except autour de chaque sélecteur, vérifiez les codes de réponse HTTP, journalisez les erreurs au lieu de faire planter le script
• Correctif moyen terme : passez des sélecteurs CSS à l’extraction JSON-LD (Méthode 2)
• Correctif long terme : utilisez les pour les analyses à grande échelle, ou un outil comme qui relit la structure de la page via l’IA à chaque fois — aucun sélecteur à maintenir, l’IA s’adapte automatiquement aux changements de mise en page

Au-delà de la limite des 25 résultats : pagination IMDb et gros volumes de données

Tous les tutoriels concurrents que j’ai consultés extraient exactement une page. Personne ne traite la pagination. Mais si vous avez besoin de plus qu’une simple liste, vous allez vite buter sur une limite.

Les pages qui n’ont pas besoin de pagination

Bonne nouvelle : la page Top 250 charge les 250 films dans une seule réponse rendue côté serveur. Le JSON-LD et __NEXT_DATA__ contiennent tous les deux l’ensemble du jeu de données. Aucune pagination n’est nécessaire.

Comment fonctionne la pagination dans la recherche IMDb

Les pages de recherche IMDb utilisent un paramètre d’URL start=, incrémenté par 50 :

1https://www.imdb.com/search/title/?groups=top_1000&start=1
2https://www.imdb.com/search/title/?groups=top_1000&start=51
3https://www.imdb.com/search/title/?groups=top_1000&start=101

Voici une boucle Python pour parcourir les résultats :

1import time
2all_movies = []
3for start in range(1, 1001, 50):  # Parcourt le top 1000
4    url = f"https://www.imdb.com/search/title/?groups=top_1000&start={start}"
5    response = requests.get(url, headers=headers)
6    if response.status_code != 200:
7        print(f"Échec à start={start} : {response.status_code}")
8        break
9    soup = BeautifulSoup(response.text, "lxml")
10    # Extraire les films avec la méthode de votre choix
11    # ...
12    print(f"Page extraite à partir de {start}")
13    time.sleep(3)  # Restez raisonnable — IMDb bloque après ~50 requêtes rapides

Ce time.sleep(3) est important. Les retours de la communauté indiquent qu’IMDb commence à bloquer certaines IP après environ 50 requêtes rapides. Un délai aléatoire entre 2 et 5 secondes est une bonne pratique.

Quand éviter complètement le scraping : les jeux de données officiels IMDb

Pour les besoins vraiment massifs, IMDb fournit 7 fichiers TSV gratuits sur , mis à jour quotidiennement :

Le chargement dans Pandas est simple :

1ratings = pd.read_csv("title.ratings.tsv.gz", sep="\t", compression="gzip")
2basics = pd.read_csv("title.basics.tsv.gz", sep="\t", compression="gzip", low_memory=False)
3# Fusion sur tconst (ID de titre IMDb)
4merged = basics.merge(ratings, on="tconst")
5top_movies = merged[merged["titleType"] == "movie"].nlargest(250, "averageRating")

Ces jeux de données couvrent plus de 26 millions de titres. Pas de pagination, pas de sélecteurs, pas d’erreurs 403. La licence est réservée à un usage personnel et non commercial — vous ne pouvez pas republier ni revendre les données.

L’option sans code : Thunderbit gère la pagination pour vous

Pour les lecteurs qui ont besoin de données IMDb paginées mais ne veulent pas écrire la logique de pagination, prend en charge nativement la pagination par clic et le défilement infini. Vous lui dites de scraper, il gère le reste — y compris le défilement des contenus chargés à la demande.

Extraire IMDb avec Python : le code complet qui fonctionne (prêt à copier-coller)

Voici deux scripts autonomes que vous pouvez exécuter immédiatement.

Script A : méthode BeautifulSoup (sélecteurs CSS)

1import requests
2from bs4 import BeautifulSoup
3import pandas as pd
4url = "https://www.imdb.com/chart/top/"
5headers = {
6    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
7    "Accept-Language": "en-US,en;q=0.9"
8}
9response = requests.get(url, headers=headers)
10if response.status_code != 200:
11    print(f"Erreur : {response.status_code}")
12    exit()
13soup = BeautifulSoup(response.text, "lxml")
14movie_items = soup.select("li.ipc-metadata-list-summary-item")
15movies = []
16for item in movie_items:
17    try:
18        title = item.select_one("h3.ipc-title__text")
19        year = item.select_one("span.cli-title-metadata-item")
20        rating = item.select_one("span.ipc-rating-star--rating")
21        movies.append({
22            "title": title.text.strip() if title else "N/A",
23            "year": year.text.strip() if year else "N/A",
24            "rating": rating.text.strip() if rating else "N/A",
25        })
26    except Exception as e:
27        print(f"Film ignoré à cause d’une erreur : {e}")
28df = pd.DataFrame(movies)
29df.to_csv("imdb_top250_bs4.csv", index=False)
30print(f"{len(df)} films enregistrés")
31print(df.head())

Script B : méthode JSON-LD (recommandée)

1import requests
2from bs4 import BeautifulSoup
3import json
4import pandas as pd
5url = "https://www.imdb.com/chart/top/"
6headers = {
7    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
8    "Accept-Language": "en-US,en;q=0.9"
9}
10response = requests.get(url, headers=headers)
11if response.status_code != 200:
12    print(f"Erreur : {response.status_code}")
13    exit()
14soup = BeautifulSoup(response.text, "lxml")
15script_tag = soup.find("script", {"type": "application/ld+json"})
16if not script_tag:
17    print("Aucune donnée JSON-LD trouvée")
18    exit()
19data = json.loads(script_tag.string)
20movies = []
21for item in data.get("itemListElement", []):
22    movie = item.get("item", {})
23    rating_info = movie.get("aggregateRating", {})
24    directors = movie.get("director", [])
25    director_names = ", ".join(
26        d.get("name", "") for d in (directors if isinstance(directors, list) else [directors])
27    )
28    movies.append({
29        "rank": item.get("position"),
30        "title": movie.get("name"),
31        "url": movie.get("url"),
32        "rating": rating_info.get("ratingValue"),
33        "votes": rating_info.get("ratingCount"),
34        "year": movie.get("datePublished", "")[:4],
35        "genre": ", ".join(movie.get("genre", [])),
36        "director": director_names,
37        "description": movie.get("description"),
38    })
39df = pd.DataFrame(movies)
40df.to_csv("imdb_top250_jsonld.csv", index=False)
41print(f"{len(df)} films enregistrés")
42print(df.head())

Les deux scripts incluent une gestion des erreurs et produisent un CSV propre. Le script B vous donne des données plus riches — réalisateur, description, URL — et résiste mieux aux changements de mise en page.

Comment extraire IMDb sans écrire une seule ligne de code (avec Thunderbit)

Tout le monde n’a pas besoin ni envie d’écrire du Python. Peut-être êtes-vous analyste opérationnel et vous avez juste besoin des films les mieux notés de la semaine dans un tableur. Peut-être êtes-vous stratège éditorial et voulez comparer les tendances de genres selon les années. Dans ces cas-là, créer un scraper est excessif.

Voici comment obtenir les mêmes données avec :

Avant de commencer :

• Difficulté : Débutant
• Temps requis : ~2 minutes
• Ce qu’il vous faut : Navigateur Chrome, (la version gratuite suffit)

Étape 1 : ouvrez la page IMDb à scraper. Ouvrez le Top 250 IMDb (ou toute autre page de liste/recherche IMDb) dans Chrome.

Étape 2 : cliquez sur « AI Suggest Fields » dans la barre latérale Thunderbit. L’IA analyse la page et recommande des colonnes — généralement Titre, Année, Note, Genre et quelques autres selon la page. Vous verrez un aperçu du tableau avec les champs suggérés.

Étape 3 : ajustez les champs si besoin. Supprimez les colonnes inutiles ou ajoutez des colonnes personnalisées en cliquant sur « + Add Column » et en décrivant ce que vous voulez en langage naturel (par exemple « nom du réalisateur » ou « nombre de votes »).

Étape 4 : cliquez sur « Scrape ». Thunderbit extrait les données. Pour les pages à défilement infini ou à pagination, il gère automatiquement le scrolling.

Étape 5 : exportez. Cliquez sur le bouton d’export et choisissez votre format — Excel, Google Sheets, CSV, Airtable ou Notion. Les données arrivent à destination en quelques secondes.

L’avantage clé n’est pas seulement la simplicité : c’est que l’IA de Thunderbit relit la structure de la page à chaque exécution. Quand IMDb change sa mise en page (et ce sera le cas), l’IA s’adapte. Aucun sélecteur à mettre à jour, aucun code à corriger. Pour quiconque s’est déjà retrouvé avec un scraper cassé à 2 h du matin avant une échéance, ça vaut de l’or.

Thunderbit prend aussi en charge l’extraction des sous-pages — vous pouvez ouvrir la fiche détaillée de chaque film et enrichir votre tableau avec le casting, le réalisateur, la durée et d’autres champs non visibles dans la liste. Pour voir cela en action, consultez la .

Est-ce légal d’extraire IMDb ? Ce qu’il faut savoir

Les utilisateurs posent la question explicitement sur les forums : « Est-ce légal… IMDb ne veut pas que l’on scrape son site. » C’est une question légitime, et aucun article concurrent n’y répond vraiment.

Le robots.txt d’IMDb : le classement Top 250 (/chart/top/), les pages de titres individuelles (/title/ttXXXXXXX/) et les pages de noms (/name/nmXXXXXXX/) ne sont PAS bloqués par robots.txt. Les chemins bloqués incluent /find, /_json/*, /search/name-text, /user/ur*/ratings et divers endpoints AJAX. Aucune directive Crawl-delay n’est spécifiée.

Les Conditions d’utilisation d’IMDb : la clause pertinente stipule : « Vous ne pouvez pas utiliser de data mining, de robots, de screen scraping ou d’outils similaires de collecte et d’extraction de données sur ce site, sauf consentement écrit explicite de notre part. » Une clause supplémentaire interdit la revente ou l’usage commercial des données extraites.

Ce que cela signifie en pratique : des décisions de justice récentes en 2024 (Meta v. Bright Data, X Corp v. Bright Data) ont estimé que des conditions d’utilisation peuvent ne pas lier des utilisateurs qui n’y ont jamais consenti — si vous scrapez des données publiquement accessibles sans vous connecter, l’opposabilité des CGU est discutable. Mais il s’agit d’un domaine juridique en évolution.

Alternatives plus sûres : les sont explicitement autorisés pour un usage personnel et non commercial. L’API TMDb est permissive avec une clé gratuite. Ce sont deux options solides si vous voulez rester clairement dans les clous.

Conseil pratique : si vous scrapez malgré tout, adoptez un rythme de collecte respectueux (time.sleep(3) entre les requêtes), définissez des en-têtes corrects et n’accédez pas aux chemins bloqués par robots.txt. Pour un projet commercial, consultez un professionnel du droit ou utilisez les jeux de données / l’API officiels.

Nous avons détaillé les sur le blog Thunderbit.

Conclusion : choisissez la bonne façon d’extraire IMDb avec Python

En résumé :

• BeautifulSoup + sélecteurs CSS : utile pour apprendre les bases. Attendez-vous à des cassures tous les 6 à 12 mois. Ajoutez toujours de la gestion d’erreurs.
• Extraction JSON-LD : l’approche que je recommande pour tout projet Python suivi dans le temps. Elle suit le standard Schema.org, change beaucoup moins souvent que les classes CSS et fournit des données structurées propres sans rendu JavaScript.
• JSON __NEXT_DATA__ : à utiliser en complément pour obtenir davantage de données sur les pages titre individuelles (durée, casting complet, intrigue, images d’affiche).
• Jeux de données officiels IMDb : le meilleur choix pour les analyses à grande échelle. Plus de 26 millions de titres, mises à jour quotidiennes, aucun scraping requis. Usage personnel / non commercial uniquement.
• : le meilleur choix pour les non-codeurs ou pour ceux qui veulent des données rapidement sans maintenir de script. L’IA s’adapte aux changements de mise en page, gère la pagination et exporte vers Excel/Sheets/Airtable/Notion.

Ajoutez ce guide à vos favoris — je le mettrai à jour lorsque la structure d’IMDb changera à nouveau. Et si vous voulez éviter complètement le code, et voyez à quelle vitesse vous pouvez passer d’une page IMDb à un tableur propre. Si vous travaillez aussi sur d’autres sites, notre guide sur couvre le workflow global.

FAQ

Est-il légal d’extraire IMDb ?

Les Conditions d’utilisation d’IMDb interdisent l’extraction sans consentement, mais l’applicabilité de ces CGU sur des données accessibles publiquement est juridiquement discutée à la suite de décisions rendues en 2024. Les options les plus sûres sont les (usage personnel / non commercial) ou l’API TMDb (clé gratuite). Si vous scrapez malgré tout, respectez robots.txt, espacez raisonnablement les requêtes et évitez les chemins bloqués. Pour un usage commercial, consultez un avocat.

Pourquoi mon scraper IMDb renvoie-t-il des résultats vides ?

Dans la quasi-totalité des cas, la cause est l’obsolescence des sélecteurs CSS — des classes comme td.titleColumn et td.ratingColumn n’existent plus depuis juin 2023. La solution consiste à passer à l’extraction JSON-LD (analyser la balise <script type="application/ld+json">) ou à mettre à jour vos sélecteurs avec les classes actuelles préfixées par ipc-. Vérifiez aussi que vous envoyez bien un en-tête User-Agent valide, car son absence déclenche une erreur 403 qui peut donner l’impression de résultats vides.

Comment extraire plus de 25 résultats depuis IMDb ?

La page Top 250 charge les 250 films en une seule réponse — aucune pagination n’est nécessaire. Pour les résultats de recherche, utilisez le paramètre d’URL start= (par incréments de 50) pour parcourir les pages. Par exemple : start=1, start=51, start=101. Ajoutez time.sleep(3) entre les requêtes pour éviter le blocage. Sinon, les jeux de données officiels d’IMDb sur contiennent plus de 26 millions de titres, sans pagination.

Qu’est-ce que __NEXT_DATA__ et pourquoi l’utiliser pour extraire IMDb ?

__NEXT_DATA__ est un objet JSON intégré dans une balise <script id="__NEXT_DATA__"> sur les pages React/Next.js d’IMDb. Il contient toutes les données structurées utilisées par React pour afficher la page — titres, notes, casting, genres, durée, et plus encore. Comme il représente le modèle de données sous-jacent plutôt que la mise en page visuelle, il est plus robuste face aux refontes que les sélecteurs CSS. Utilisez-le avec JSON-LD pour l’approche d’extraction la plus solide.

Peut-on extraire IMDb sans coder ?

Oui. Deux options principales : (1) télécharger les — 7 fichiers TSV couvrant plus de 26 millions de titres, mis à jour quotidiennement, gratuits pour un usage non commercial. (2) utiliser , qui lit la page IMDb, suggère automatiquement les champs à extraire et exporte vers Excel, Google Sheets ou CSV en deux clics — sans code, sans sélecteurs à maintenir.

En savoir plus