Rotten Tomatoes scrapenFilmbewertungen und Scores

Rotten Tomatoes ist eine der meistzitierten Quellen für Filmbewertungen im öffentlichen Web. Seine Filmseiten tragen den Tomatometer-Kritikerwert, die Publikumsbewertung, das Genre und einen Link zur vollständigen Titelseite, alles sichtbar für jeden ohne Konto. Für Unterhaltungsforschung, Trendanalyse oder eine persönliche Filmdatenbank sind diese öffentlichen Bewertungsdaten genutzreich in strukturierter Form zu sammeln.

Diese Anleitung zeigt Ihnen, wie Sie Rotten Tomatoes Filmbewertungen mit Python scrapen. Die gesamte Anleitung bleibt auf öffentliche, nicht-persönliche Daten beschränkt: den Titel, die Bewertungen, das Genre und den Seitenlink, die die Website offen anzeigt. Sie berührt keine Rezensenten-Identitäten, keinen vollständigen Rezensionstext und nichts hinter einem Login. Da Rotten Tomatoes seine Bewertungen clientseitig mit JavaScript rendert, leiten wir Anfragen über die Crawling API weiter, damit die Seite vollständig geladen ist, bevor wir sie parsen.

Was Sie bauen werden

Ein kleiner Python-Scraper, der eine oder mehrere öffentliche Rotten Tomatoes Filmseiten entgegennimmt, jede gerenderte Seite über die Crawling API abruft, eine Handvoll öffentlicher Felder parst und das Ergebnis in JSON und CSV exportiert:

• Movie title der Name des Films, wie er auf der Seite angezeigt wird.
• Tomatometer score die von zugelassenen Kritikern aggregierte Kritikerbewertung.
• Audience score die aggregierte Publikumsbewertung für den Film.
• Genre die Kategorie, unter der der Film eingeordnet ist, wie Komödie oder Drama.
• Link die kanonische URL der Filmseite auf Rotten Tomatoes.

Das sind alles öffentliche, aggregierte Fakten über den Film selbst. Der Scraper verarbeitet mehrere Filme in einem Lauf und schreibt einen sauberen Datensatz, den Sie in ein Notebook oder eine Tabellenkalkulation laden können.

Warum eine einfache Anfrage bei Rotten Tomatoes fehlschlägt

Fordern Sie eine Rotten Tomatoes Filmseite mit einem einfachen HTTP-Client an, und die Bewertungen werden nicht vorhanden sein. Der Tomatometer und die Publikumszahlen sowie ein Großteil der Bewertungsmetadaten laden dynamisch über JavaScript, nachdem die initiale HTML-Seite ankommt. Eine Bibliothek wie requests sieht nur die erste Markup-Hülle, also kommen die interessanten Felder leer zurück. Dazu kommt, dass wiederholter automatisierter Traffic von einer einzelnen Datacenter-IP tendenziell herausgefordert wird, bevor der Inhalt überhaupt rendert.

Ein funktionierender Scraper benötigt daher zwei Dinge in derselben Anfrage: einen Browser, der das JavaScript der Seite ausführt, und eine IP-Adresse, die die Website als normalen Besucher liest. Sie können das selbst mit einem Headless-Browser und einem Pool von Residential-Proxies aufbauen, aber das Warten dieses Stacks ist der Großteil der Arbeit. Die Crawling API vereint beides in einem Aufruf. Sie senden eine URL mit einem JavaScript-Token, sie rendert die Seite hinter einer vertrauenswürdigen Residential-IP und gibt fertiges HTML zurück, das Sie direkt an BeautifulSoup übergeben können. Für mehr Hintergrundwissen lesen Sie unsere Anleitung zum Crawlen von JavaScript-Websites.

Voraussetzungen

Einige Dinge zuerst in Ordnung zu bringen. Keines davon nimmt lange.

Grundlegende Python-Kenntnisse. Sie sollten sich damit auskennen, ein Skript auszuführen und Pakete mit pip zu installieren. Wenn das Parsen von HTML neu für Sie ist, deckt unser Primer zum Verwenden von BeautifulSoup in Python die Extraktionsseite ab, und eine Website mit Python scrapen geht die vollständige Schleife durch.

Python 3.8 oder höher. Bestätigen Sie mit python --version. Falls nicht vorhanden, installieren Sie es von python.org.

Ein Crawlbase-Konto und JS-Token. Registrieren Sie sich, öffnen Sie Ihr Dashboard und kopieren Sie Ihr JavaScript (JS) Token. Crawlbase gibt Ihnen bis zu 20.000 kostenlose Anfragen zum Start, und Sie zahlen nur für erfolgreiche Anfragen. Behandeln Sie das Token wie ein Passwort und halten Sie es aus der Versionskontrolle heraus.

Projekt einrichten

Erstellen Sie eine isolierte virtuelle Umgebung und installieren Sie dann die beiden Bibliotheken, die der Scraper benötigt.

python --version

python -m venv rt_env
source rt_env/bin/activate

pip install crawlbase beautifulsoup4

Aktivieren Sie unter Windows mit rt_env\Scripts\activate anstatt der source-Zeile. Zwei Abhängigkeiten erledigen die Arbeit: crawlbase ist der offizielle Client für die Crawling API, und beautifulsoup4 parst das zurückgegebene HTML, damit Sie einzelne Felder per Selektor extrahieren können.

Schritt 1: Die gerenderte Filmseite abrufen

Beginnen Sie damit, die fertige Seite zu erhalten. Importieren Sie CrawlingAPI, initialisieren Sie es mit Ihrem JS-Token und fordern Sie eine öffentliche Film-URL an. Zwei Wait-Optionen sind für ein clientseitig gerendertes Ziel wichtig: ajax_wait weist die API an, auf den Abschluss asynchroner Inhalte zu warten, und page_wait hält für eine feste Anzahl von Millisekunden nach dem Laden an, damit die Bewertungen erscheinen, bevor die Seite erfasst wird. Überprüfen Sie den Status vor dem Parsen, damit Fehler sichtbar statt still bleiben.

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

Fünf Sekunden ist ein vernünftiger Ausgangspunkt für page_wait; erhöhen Sie es, wenn Bewertungen leer zurückkommen. Das Beispiel verwendet eine öffentliche Filmseite. Führen Sie das Skript aus, und Sie sollten echtes Markup von der Titelseite sehen, was bestätigt, dass das Rendering funktioniert, bevor Sie einen einzigen Selektor schreiben.

Schritt 2: Die Seite inspizieren und die öffentlichen Felder parsen

Bevor Sie Selektoren schreiben, öffnen Sie eine Filmseite in Ihrem Browser und verwenden Sie die Entwicklerwerkzeuge, um zu finden, wo jedes Feld liegt. Auf einer Rotten Tomatoes Filmseite ist die Struktur stabil genug, um sie direkt anzusprechen:

• Title befindet sich in einem <h1>-Element mit einem slot="titleIntro"-Attribut.
• Tomatometer (critics) score befindet sich in einem rt-text-Element mit slot="criticsScore".
• Audience score befindet sich ebenfalls in einem rt-text-Element, mit slot="audienceScore".
• Genre erscheint in der Film-Detailliste, unter einem <dt>-Element mit der Beschriftung Genre und seinen Werten im passenden <dd>.

Mit fertigem HTML in der Hand laden Sie es in BeautifulSoup und extrahieren jedes Feld. Der folgende Helfer liest den Titel und beide Bewertungen durch ihre slot-Selektoren und geht dann die Detailliste durch, um das Genre zu finden. Jede Nachschlage-Operation ist gesichert, sodass ein fehlendes Feld einen leeren String zurückgibt statt einen Fehler zu werfen.

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,
    }

Die zwei Bewertungen kommen direkt aus den criticsScore- und audienceScore-Slots. Das Genre kommt aus der Detailliste, wo jedes Label in einem dt.key-Element sitzt und die Werte im passenden dd. Das Verbinden der rt-link- und rt-text-Werte verarbeitet Filme, die mit mehr als einem Genre getaggt sind, wie Komödie und Fantasy.

Schritt 3: Mehrere Filme verwalten und exportieren

Die meisten Recherchen beginnen mit einer Liste von Filmen, nicht einer einzelnen Seite. Verbinden Sie die Abruf- und Parsen-Schritte in einer Schleife, die eine Liste von Film-URLs durchläuft, drosseln Sie die Anfragen und schreiben Sie die gesammelten Zeilen sowohl in JSON als auch CSV. JSON behält die Struktur für ein Notebook; CSV geht direkt in eine Tabellenkalkulation. Wenn Sie das in spätere Analysen einspeisen möchten, deckt unsere Anleitung zum Strukturieren und Bereinigen von gescrapten Daten für KI und ML den nächsten Schritt ab.

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

Das wiederverwendet die fetch_html- und parse_movie-Helfer aus den vorherigen Schritten, also fügen Sie alle drei Blöcke in eine Datei ein. Das time.sleep(3) zwischen Anfragen ist kein Dekorationselement: Drosselung ist der wichtigste Faktor dafür, ob ein Lauf gesund bleibt. Fügen Sie Ihre eigenen Film-URLs in MOVIE_URLS ein, und das Skript sammelt jede der Reihe nach.

Wie die Ausgabe aussieht

Führen Sie das vollständige Skript aus, und Sie erhalten einen sauberen Datensatz öffentlicher Felder pro Film, bereit für ein Notebook oder eine Tabellenkalkulation.

[
    {
        "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"
    }
]

Die CSV-Entsprechung enthält dieselben Spalten, eine Zeile pro Film, mit einer Kopfzeile. Von dort aus können Sie nach Tomatometer sortieren, Kritiker- gegen Publikumsbewertungen vergleichen oder nach Genre für welche Unterhaltungsforschung auch immer filtern.

Auf mehr Filme skalieren und unblockiert bleiben

Das obige Muster skaliert sauber: eine längere MOVIE_URLS-Liste oder ein Entdeckungsschritt, der zuerst Film-Links von einer öffentlichen Browse-Seite wie der Top Box Office-Liste sammelt, dann jede Titelseite besucht. Ein paar Gewohnheiten halten einen größeren Lauf gesund, und sie gelten für jedes verteidigte Ziel.

• Drosseln Sie Ihre Anfragen. Behalten Sie die Verzögerung zwischen Aufrufen bei und widerstehen Sie dem Drang, aggressiv zu parallelisieren. Drosselung ist der schnellste Weg zu einem sauberen Lauf.
• Setzen Sie auf Rotation. Die Crawling API verteilt Anfragen für Sie auf Residential-IPs, sodass keine einzelne Adresse ein Ratenlimit auslöst. Wenn Sie Ihren eigenen Stack aufbauen, ist das der Teil, den Sie richtig hinbekommen müssen.
• Lesen Sie die Statuscodes. Wenn ein Lauf beginnt, Nicht-200-Status zurückzugeben, schalten Sie zurück statt härter zu drücken.
• Halten Sie das Volumen vernünftig. Öffentliche Bewertungsforschung benötigt selten den gesamten Katalog. Probieren Sie die Filme, die Sie interessieren, und hören Sie auf.

Für das umfassendere Playbook lesen Sie unsere Anleitung zu Websites ohne Blockierung scrapen.

Ist es legal, Rotten Tomatoes zu scrapen?

Das ist der Abschnitt, den Sie lesen sollten, bevor Sie Produktionscode schreiben. Der hier verfolgte Ansatz beschränkt sich auf öffentliche, nicht-persönliche Bewertungsdaten: den Filmtitel, den Tomatometer und die Publikumsbewertungen, das Genre und den Seitenlink. Das sind aggregierte Fakten über einen Film, keine persönlichen Daten über eine Einzelperson, was dies fest auf der Seite von Bildung und öffentlichen Daten hält. Trotzdem bedeutet das verantwortungsvolle Sammeln, Rotten Tomatoes' Nutzungsbedingungen und seine robots.txt zu respektieren und Ihre Anfragen zu drosseln, damit Sie die Website nicht belasten.

Es gibt klare Grenzen, die man nicht überschreiten sollte. Veröffentlichen Sie kein urheberrechtlich geschütztes Material: Der vollständige Text einzelner Kritikerrezensionen, redaktionelle Texte, Bilder und Videos sind geschützte Inhalte, und das Aggregieren der Rezensionsprosa einer Person oder deren Verknüpfung mit einem benannten Kritiker ist eine andere Aktivität als das Aufzeichnen einer öffentlichen Bewertung. Bleiben Sie bei den Zahlen, dem Genre und dem Link. Versuchen Sie nicht, hinter einen Login zu gelangen, und sammeln Sie keine persönlichen Daten über Rezensenten oder Nutzer. Wo persönliche Daten involviert sind, gelten Datenschutzregime wie DSGVO und CCPA, einschließlich einer Rechtsgrundlage für die Erfassung und der Ehrung von Löschanfragen.

Wenn Sie umfangreichere oder groß angelegte Filmdaten für ein echtes Projekt benötigen, ist der sanktionierte Weg eine lizenzierte Datenquelle. Rotten Tomatoes-Daten sind über offizielle Partnerschaften und die Fandango-Dienstleistungsfamilie verfügbar, und es gibt lizenzierte Filmdatenbanken für programmatischen Zugang. Für alles Laufende oder Kommerzielle gibt ein offizielles Abkommen garantierte Struktur und hält Sie innerhalb der Bedingungen, was ein Scraper nicht versprechen kann. Behandeln Sie diese Anleitung als technische Übung im Lesen öffentlicher Bewertungen, nicht als Lizenz zur Spiegelung der Website.

Häufig gestellte Fragen

Warum gibt eine einfache Anfrage keine Bewertungen von Rotten Tomatoes zurück?

Weil der Tomatometer und die Publikumsbewertungen clientseitig mit JavaScript laden, nachdem die initiale HTML-Seite ankommt. Eine rohe HTTP-Anfrage mit einer Bibliothek wie requests sieht nur die erste Markup-Hülle, also kommen diese Felder leer zurück. Das Rendern der Seite zuerst, was das JS-Token der Crawling API übernimmt, ist das, was die Bewertungen zum Parsen verfügbar macht.

Brauche ich das normale Token oder das JS-Token?

Das JS-Token. Das normale Token ruft statisches HTML ab, das auf Rotten Tomatoes dieselbe unvollständige Hülle ist, die ein einfacher Abruf zurückgibt. Das JS-Token rendert die Seite in einem echten Browser, bevor es das HTML zurückgibt, sodass die Bewertungen und das Genre vorhanden sind, wenn BeautifulSoup sie parst.

Welche Rotten Tomatoes-Daten sind sicher zu scrapen?

Öffentliche, nicht-persönliche Fakten über einen Film: den Titel, den Tomatometer-Wert, die Publikumsbewertung, das Genre und den Seitenlink. Vermeiden Sie das Weiterveröffentlichen von urheberrechtlich geschütztem Material wie dem vollständigen Text von Kritikerrezensionen, und sammeln Sie keine persönlichen Daten über Rezensenten oder Nutzer. Bleiben Sie bei den aggregierten Bewertungen und respektieren Sie die Bedingungen und robots.txt der Website.

Wie scrappe ich Bewertungen für viele Filme auf einmal?

Fügen Sie die Film-URLs in eine Liste ein und schleifen Sie darüber, indem Sie die Abruf- und Parsen-Helfer für jede aufrufen, mit einer kurzen Verzögerung zwischen den Anfragen. Sie können auch einen Entdeckungsschritt hinzufügen, der zuerst Links von einer öffentlichen Browse-Seite sammelt, dann jede Titelseite besucht. Halten Sie das Volumen vernünftig und schreiben Sie die Ergebnisse während des Vorgehens in JSON oder CSV.

Was passiert, wenn Rotten Tomatoes sein Layout ändert?

Ihre Selektoren hören möglicherweise auf zu passen, und Felder kommen leer zurück. Überprüfen Sie die Live-Seite in den Entwicklerwerkzeugen Ihres Browsers, finden Sie das neue Attribut oder Element für das Feld und aktualisieren Sie den Selektor. Das Verlassen auf die slot-Attribute statt auf tief verschachtelte Klassennamen reduziert, wie oft das passiert, aber periodische Wartung ist für jeden Scraper normal.

Sollte ich stattdessen eine offizielle Quelle verwenden statt zu scrapen?

Für alles Laufende oder Kommerzielle ja. Rotten Tomatoes-Daten sind über offizielle Partnerschaften und die Fandango-Dienstleistungsfamilie verfügbar, und lizenzierte Filmdatenbanken existieren für programmatischen Zugang. Ein offizielles Abkommen gibt garantierte Struktur und hält Sie innerhalb der Bedingungen. Der hier gezeigte Scraping-Ansatz passt zu leichter, öffentlicher Datenforschung, wo kein lizenzierter Zugang vorhanden ist.

HR

Hassan Rehan

Softwareentwickler · Crawlbase

Softwareentwickler bei Crawlbase, der praxisnahe Anleitungen zu rotierenden Proxys, Scraping und den praktischen Details schreibt, Proxys in echten Code einzubinden.