Comment scraper Rotten Tomatoesnotes de films et scores

Rotten Tomatoes est l'une des sources de notes de films les plus consultées sur le web public. Ses pages de films portent le score Tomatometer des critiques, le score du public, le genre et un lien vers la page du titre complet, le tout visible par n'importe qui sans compte. Pour la recherche sur le divertissement, l'analyse de tendances ou une base de données de films personnelle, ces données de notation publiques sont réellement utiles à collecter sous forme structurée.

Ce guide vous montre comment extraire des notes de films Rotten Tomatoes avec Python. L'ensemble du guide se limite aux données publiques non personnelles : le titre, les scores, le genre et le lien de page que le site affiche ouvertement. Il ne touche pas aux identités des critiques, au texte intégral des avis, ni à quoi que ce soit derrière une connexion. Comme Rotten Tomatoes affiche ses scores côté client avec JavaScript, nous routons les requêtes via la Crawling API pour que la page soit entièrement chargée avant de l'analyser.

Ce que vous allez construire

Un petit scraper Python qui prend une ou plusieurs pages publiques de films Rotten Tomatoes, récupère chaque page rendue via la Crawling API, analyse quelques champs publics et exporte le résultat au format JSON et CSV :

• Titre du film le nom du film tel qu'il apparaît sur la page.
• Score Tomatometer le score des critiques agrégé depuis les critiques approuvés.
• Score du public le score public agrégé pour le film.
• Genre la catégorie sous laquelle le film est classé, comme comédie ou drame.
• Lien l'URL canonique de la page du film sur Rotten Tomatoes.

Ce sont tous des faits publics et agrégés sur le film lui-même. Le scraper gère plusieurs films en une seule exécution et produit un jeu de données propre que vous pouvez charger dans un notebook ou un tableur.

Pourquoi une requête simple échoue sur Rotten Tomatoes

Demandez une URL de film Rotten Tomatoes avec un client HTTP brut et les scores ne seront pas là. Le Tomatometer et les chiffres du public, ainsi qu'une grande partie des métadonnées de notation, se chargent dynamiquement via JavaScript après l'arrivée du HTML initial. Une bibliothèque comme requests ne voit que la première coquille de balisage, les champs qui vous intéressent reviennent donc vides. Par-dessus cela, le trafic automatisé répétitif depuis une seule IP de centre de données tend à être soumis à des défis avant même que le contenu ne se rende.

Un scraper fonctionnel a donc besoin de deux choses dans la même requête : un navigateur qui exécute le JavaScript de la page, et une adresse IP que le site reconnaît comme un visiteur ordinaire. Vous pouvez assembler cela vous-même avec un navigateur sans interface et un pool de proxies résidentiels, mais maintenir cette pile représente l'essentiel de l'effort. La Crawling API réunit les deux en un seul appel. Vous lui envoyez une URL avec un token JavaScript, elle rend la page derrière une IP résidentielle de confiance et retourne le HTML finalisé que vous pouvez passer directement à BeautifulSoup. Pour plus de contexte, consultez notre guide sur comment crawler des sites web JavaScript.

Prérequis

Quelques éléments à avoir en place d'abord. Aucun ne prend longtemps.

Connaissances de base en Python. Vous devez être à l'aise pour exécuter un script et installer des packages avec pip. Si l'analyse HTML est nouvelle pour vous, notre guide sur comment utiliser BeautifulSoup en Python couvre le côté extraction, et scraper un site web avec Python parcourt la boucle complète de bout en bout.

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

Un compte Crawlbase et un token JS. Inscrivez-vous, ouvrez votre tableau de bord et copiez votre token JavaScript (JS). Crawlbase vous donne jusqu'à 20 000 requêtes gratuites pour commencer, et vous ne payez que pour les requêtes réussies. Traitez le token comme un mot de passe et gardez-le en dehors du contrôle de version.

Configurer le projet

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

python --version

python -m venv rt_env
source rt_env/bin/activate

pip install crawlbase beautifulsoup4

Sous Windows, activez avec rt_env\Scripts\activate au lieu de la ligne source. Deux dépendances font le travail : crawlbase est le client officiel pour la Crawling API, et beautifulsoup4 analyse le HTML retourné pour que vous puissiez extraire des champs individuels par sélecteur.

Étape 1 : Récupérer la page de film rendue

Commencez par obtenir la page finalisée. Importez CrawlingAPI, initialisez-la avec votre token JS et demandez une URL de film public. Deux options d'attente importent pour une cible rendue côté client : ajax_wait indique à l'API d'attendre que le contenu asynchrone finisse de se charger, et page_wait maintient un nombre fixe de millisecondes après le chargement pour que les scores apparaissent avant que la page ne soit capturée. Vérifiez le statut avant d'analyser pour que les échecs restent visibles plutôt que silencieux.

from crawlbase import CrawlingAPI

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

def fetch_html(url):
    options = {"ajax_wait": "true", "page_wait": "5000"}
    response = crawling_api.get(url, options)
    if response["headers"]["cb_status"] == "200":
        return response["body"].decode("utf-8")
    print(f"Failed to fetch the page. Status code: {response['headers']['cb_status']}")
    return None

if __name__ == "__main__":
    url = "https://www.rottentomatoes.com/m/beetlejuice_beetlejuice"
    html = fetch_html(url)
    print(html[:500] if html else "No HTML returned")

Cinq secondes est un bon point de départ pour page_wait ; augmentez-le si les scores reviennent vides. L'exemple utilise une page de film public. Exécutez le script et vous devriez voir du vrai balisage depuis la page du titre, ce qui confirme que le rendu fonctionne avant d'écrire un seul sélecteur.

Étape 2 : Inspecter la page et analyser les champs publics

Avant d'écrire des sélecteurs, ouvrez une page de film dans votre navigateur et utilisez les outils développeur pour trouver où chaque champ réside. Sur une page de film Rotten Tomatoes, la structure est suffisamment stable pour être ciblée directement :

• Le titre se trouve dans un élément <h1> avec un attribut slot="titleIntro".
• Le score Tomatometer (critiques) est dans un élément rt-text avec slot="criticsScore".
• Le score du public est également dans un élément rt-text, avec slot="audienceScore".
• Le genre apparaît dans la liste des détails du film, sous un <dt> libellé Genre avec ses valeurs dans le <dd> correspondant.

Avec le HTML rendu en main, chargez-le dans BeautifulSoup et extrayez chaque champ. L'assistant ci-dessous lit le titre et les deux scores par leurs sélecteurs slot, puis parcourt la liste des détails pour trouver le genre. Chaque recherche est protégée pour qu'un champ manquant retourne une chaîne vide au lieu de lever une exception.

from bs4 import BeautifulSoup

def text_or_blank(node):
    return node.text.strip() if node else ""

def find_genre(soup):
    for dt in soup.select("dt.key rt-text"):
        if dt.text.strip() == "Genre":
            dd = dt.find_parent("dt").find_next_sibling("dd")
            if dd:
                values = [v.text.strip() for v in dd.find_all(["rt-link", "rt-text"]) if v.text.strip()]
                return ", ".join(values)
    return ""

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

    title = text_or_blank(soup.select_one('h1[slot="titleIntro"]'))
    critics_score = text_or_blank(soup.select_one('rt-text[slot="criticsScore"]'))
    audience_score = text_or_blank(soup.select_one('rt-text[slot="audienceScore"]'))
    genre = find_genre(soup)

    return {
        "title": title,
        "tomatometer_score": critics_score,
        "audience_score": audience_score,
        "genre": genre,
        "link": url,
    }

Les deux scores viennent directement des slots criticsScore et audienceScore. Le genre provient de la liste des détails, où chaque étiquette réside dans un dt.key et les valeurs dans le dd correspondant. Joindre les valeurs rt-link et rt-text gère les films étiquetés avec plus d'un genre, comme comédie et fantaisie.

Étape 3 : Gérer plusieurs films et exporter

La plupart des recherches commencent par une liste de films, pas une seule page. Reliez les étapes de récupération et d'analyse en une seule boucle qui parcourt une liste d'URL de films, rythme les requêtes et écrit les lignes collectées en JSON et CSV. JSON conserve la structure pour un notebook ; CSV se charge directement dans un tableur. Si vous prévoyez d'alimenter cela dans une analyse ultérieure, notre guide sur la structuration et le nettoyage des données scrappées pour l'IA et le ML couvre l'étape suivante.

import csv
import json
import time
from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup

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

MOVIE_URLS = [
    "https://www.rottentomatoes.com/m/beetlejuice_beetlejuice",
    "https://www.rottentomatoes.com/m/deadpool_and_wolverine",
    "https://www.rottentomatoes.com/m/twisters",
]

def save_to_json(rows, filename="movies.json"):
    with open(filename, "w") as f:
        json.dump(rows, f, indent=4)
    print(f"Saved {len(rows)} movies to {filename}")

def save_to_csv(rows, filename="movies.csv"):
    fields = ["title", "tomatometer_score", "audience_score", "genre", "link"]
    with open(filename, "w", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=fields)
        writer.writeheader()
        writer.writerows(rows)
    print(f"Saved {len(rows)} movies to {filename}")

def main():
    movies = []
    for url in MOVIE_URLS:
        html = fetch_html(url)
        if html:
            movies.append(parse_movie(html, url))
        time.sleep(3)

    save_to_json(movies)
    save_to_csv(movies)

if __name__ == "__main__":
    main()

Ce code réutilise les assistants fetch_html et parse_movie des étapes précédentes, collez donc les trois blocs dans un seul fichier. Le time.sleep(3) entre les requêtes n'est pas décoratif : le rythme est le facteur le plus important pour qu'une exécution reste saine. Insérez vos propres URL de films dans MOVIE_URLS et le script collecte chacun à tour de rôle.

À quoi ressemble la sortie

Exécutez le script complet et vous obtenez un enregistrement propre de champs publics par film, prêt à charger dans un notebook ou un tableur.

[
    {
        "title": "Beetlejuice Beetlejuice",
        "tomatometer_score": "77%",
        "audience_score": "81%",
        "genre": "Comedy, Fantasy",
        "link": "https://www.rottentomatoes.com/m/beetlejuice_beetlejuice"
    },
    {
        "title": "Deadpool & Wolverine",
        "tomatometer_score": "79%",
        "audience_score": "95%",
        "genre": "Action, Comedy",
        "link": "https://www.rottentomatoes.com/m/deadpool_and_wolverine"
    }
]

Le miroir CSV porte les mêmes colonnes, une ligne par film, avec une ligne d'en-tête. À partir de là, vous pouvez trier par Tomatometer, comparer les scores des critiques et du public, ou filtrer par genre pour la recherche sur le divertissement que vous avez en tête.

Passer à l'échelle avec plus de films et rester non bloqué

Le modèle ci-dessus s'adapte facilement : une liste MOVIE_URLS plus longue, ou une étape de découverte qui collecte d'abord les liens de films depuis une page de navigation publique comme la liste du box-office, puis visite chaque page de titre. Quelques habitudes maintiennent une exécution plus grande saine, et elles s'appliquent à toute cible défendue.

• Rythmez vos requêtes. Maintenez le délai entre les appels, et résistez à l'envie de paralléliser agressivement. La limitation de débit est le moyen le plus rapide d'obtenir une exécution propre.
• Misez sur la rotation. La Crawling API répartit les requêtes sur des IPs résidentielles pour vous, de sorte qu'aucune adresse ne déclenche une limite de débit. Si vous construisez votre propre pile, c'est la partie à bien maîtriser.
• Lisez les codes de statut. Lorsqu'une exécution commence à retourner des statuts non-200, reculez plutôt que de pousser plus fort.
• Gardez le volume raisonnable. La recherche sur les notes publiques nécessite rarement l'ensemble du catalogue. Échantillonnez les films qui vous intéressent et arrêtez.

Pour le guide général, consultez notre guide sur comment scraper des sites web sans être bloqué.

Est-il légal de scraper Rotten Tomatoes ?

C'est la section à lire avant d'écrire du code de production. L'approche ici se limite aux données de notation publiques non personnelles : le titre du film, les scores Tomatometer et du public, le genre et le lien de page. Ce sont des faits agrégés sur un film, pas des données personnelles sur un individu, ce qui maintient cela fermement du côté éducatif et des données publiques. Même ainsi, les collecter de manière responsable signifie respecter les Conditions d'utilisation de Rotten Tomatoes et son robots.txt, et rythmer vos requêtes pour ne pas mettre de charge sur le site.

Il y a des lignes claires à ne pas franchir. Ne republiez pas de matériel protégé par le droit d'auteur : le texte intégral des avis individuels des critiques, les rédactions éditoriales, les images et les vidéos sont du contenu protégé, et agréger la prose d'avis de quelqu'un ou la lier à un critique nommé est une activité différente de l'enregistrement d'un score public. Restez avec les chiffres, le genre et le lien. N'essayez pas d'atteindre quoi que ce soit derrière une connexion, et ne collectez pas de données personnelles sur les critiques ou les utilisateurs. Là où des données personnelles sont impliquées, les régimes de confidentialité comme le RGPD et le CCPA s'appliquent, y compris une base légale pour la collecte et le respect des demandes de suppression.

Si vous avez besoin de données cinématographiques plus riches ou à grande échelle pour un vrai projet, la voie sanctionnée est une source de données sous licence. Les données de Rotten Tomatoes sont disponibles via des partenariats officiels et la famille de services Fandango, et il existe des bases de données de films sous licence conçues pour l'accès programmatique. Pour tout usage continu ou commercial, un accord officiel vous garantit une structure et vous maintient dans les conditions, ce qu'un scraper ne peut pas promettre. Traitez ce guide comme un exercice technique de lecture de notes publiques, pas comme une licence pour reproduire le site.

Foire aux questions

Pourquoi une requête simple ne retourne-t-elle aucun score depuis Rotten Tomatoes ?

Parce que le Tomatometer et les scores du public se chargent côté client avec JavaScript après l'arrivée du HTML initial. Une requête HTTP brute avec une bibliothèque comme requests ne voit que la première coquille de balisage, ces champs reviennent donc vides. Rendre la page d'abord, ce que gère le token JS de la Crawling API, est ce qui rend les scores disponibles à l'analyse.

Ai-je besoin du token normal ou du token JS ?

Le token JS. Le token normal récupère le HTML statique, qui sur Rotten Tomatoes est la même coquille incomplète qu'une simple récupération retourne. Le token JS rend la page dans un vrai navigateur avant de retourner le HTML, de sorte que les scores et le genre sont présents lorsque BeautifulSoup les analyse.

Quelles données de Rotten Tomatoes est-il prudent de scraper ?

Les faits publics et non personnels sur un film : le titre, le score Tomatometer, le score du public, le genre et le lien de page. Évitez de republier du matériel protégé par le droit d'auteur comme le texte intégral des avis des critiques, et ne collectez pas de données personnelles sur les critiques ou les utilisateurs. Restez avec les notes agrégées et respectez les conditions et robots.txt du site.

Comment scraper les notes de nombreux films à la fois ?

Mettez les URL de films dans une liste et bouclez sur elles, en appelant les assistants de récupération et d'analyse pour chacune, avec un court délai entre les requêtes. Vous pouvez également ajouter une étape de découverte qui collecte d'abord les liens depuis une page de navigation publique, puis visite chaque page de titre. Gardez le volume raisonnable et écrivez les résultats en JSON ou CSV au fur et à mesure.

Que se passe-t-il si Rotten Tomatoes modifie sa mise en page ?

Vos sélecteurs peuvent cesser de correspondre et les champs reviendront vides. Réinspectez la page en direct dans les outils de développement de votre navigateur, trouvez le nouvel attribut ou élément pour le champ, et mettez à jour le sélecteur. S'appuyer sur les attributs slot plutôt que sur des noms de classes profondément imbriqués réduit la fréquence à laquelle cela se produit, mais la maintenance périodique est normale pour tout scraper.

Devrais-je utiliser une source officielle plutôt que de scraper ?

Pour tout usage continu ou commercial, oui. Les données de Rotten Tomatoes sont disponibles via des partenariats officiels et la famille de services Fandango, et des bases de données de films sous licence existent pour l'accès programmatique. Un accord officiel vous garantit une structure et vous maintient dans les conditions. L'approche de scraping ici convient à une recherche légère sur des données publiques où aucun accès sous licence n'est en place.

HR

Hassan Rehan

Ingénieur logiciel · Crawlbase

Ingénieur logiciel chez Crawlbase, il rédige des guides pratiques sur les proxys rotatifs, le scraping et les détails concrets de l'intégration de proxys dans du vrai code.