IMDb mit Python scrapen: Code, der wirklich funktioniert

Wenn du kürzlich nach „IMDb mit Python scrapen“ gesucht hast, ist dir wahrscheinlich schon etwas aufgefallen: Die meisten Tutorials da draußen sind kaputt. Nicht nur ein bisschen veraltet – eher so im Stil von „liefert null Ergebnisse und eine Wand aus NoneType-Fehlern“.

Ich habe in den letzten Wochen jede große IMDb-Scraping-Anleitung getestet, die ich finden konnte – GeeksforGeeks, Medium, freeCodeCamp, Kaggle-Notebooks, alles dabei. Von mit IMDb-Scraping-Tag nutzen die allermeisten CSS-Selektoren (td.titleColumn, td.ratingColumn), die seit Juni 2023 nicht mehr existieren, nachdem IMDb die Top-250-Seite neu gestaltet hat. Das Ergebnis? Foren voller Entwickler, die fragen: „Warum ist meine Ausgabe leer?“, und Maintainer beliebter Bibliotheken wie : „Viel können wir nicht tun, außer jeden Parser zu reparieren.“ Dieser Leitfaden zeigt dir zwei Python-Methoden, die aktuell wirklich funktionieren, wie du Pagination und typische Fehler handhabst, wann Python gar nicht das richtige Werkzeug ist und wie du deinen Scraper zukunftssicher machst, damit er nicht im Friedhof der kaputten Scraper landet.

Was bedeutet es, IMDb mit Python zu scrapen?

Web Scraping ist der programmatische Prozess, Daten aus Webseiten zu extrahieren – statt sie mühsam per Copy & Paste zusammenzutragen, schreibst du ein Skript, das das für dich erledigt. Wenn wir von „IMDb scrapen“ sprechen, meinen wir damit, strukturierte Filmdaten wie Titel, Bewertungen, Genres, Besetzung, Laufzeit und Stimmenanzahl mit Python von IMDb-Seiten auszulesen.

Der typische Python-Stack dafür besteht aus drei Bibliotheken: requests (um die Webseite abzurufen), BeautifulSoup (um das HTML zu parsen und die Daten zu finden) und pandas (um die Ergebnisse zu strukturieren und zu exportieren). Manche Tutorials nutzen außerdem Selenium oder Playwright für Seiten, die JavaScript-Rendering brauchen, aber wie du gleich sehen wirst, gibt es schnellere Wege.

Ein wichtiger Hinweis: Alle Beispiele in diesem Leitfaden wurden gegen die aktuelle IMDb-Seitenstruktur von Mitte 2025 überprüft. IMDb ändert das Layout ungefähr alle 6 bis 12 Monate. Wenn du das hier also 2027 liest, können sich einige Selektoren schon wieder verschoben haben. (Ich zeige dir auch, wie du damit umgehst.)

Warum IMDb mit Python scrapen? Praxisnahe Anwendungsfälle

Bevor du auch nur eine Zeile Code schreibst: Wofür würdest du IMDb-Daten überhaupt nutzen? Die Antwort hängt davon ab, wer du bist.

Der IMDb-Review-Datensatz gehört zu den meistgenutzten NLP-Benchmarks weltweit – die grundlegende Arbeit von Maas et al. (2011) wurde inzwischen , und der Datensatz ist direkt in TensorFlow, Keras und PyTorch eingebaut. Auf Hugging Face wird stanfordnlp/imdb monatlich 213.321-mal heruntergeladen und für das Training von über 1.500 Modellen verwendet. Wenn du im Bereich Machine Learning arbeitest, kennst du IMDb-Daten also vermutlich längst.

Die Einsatzmöglichkeiten gehen aber weit über die Forschung hinaus:

Schon der Filmtourismus-Markt hat 2025 weltweit einen geschätzten Wert von . Netflix hat 2024 über 17 Milliarden US-Dollar für Inhalte ausgegeben, wobei durch personalisierte Empfehlungen angetrieben wurden. Kurz gesagt: IMDb-Daten fließen in echten Entscheidungen in vielen Branchen ein.

Deine Optionen, um IMDb-Daten zu bekommen – bevor du eine Zeile Code schreibst

Das ist der Abschnitt, den die meisten Tutorials komplett überspringen. Sie springen direkt zu pip install beautifulsoup4, ohne zu prüfen, ob Python-Scraping in deinem Fall überhaupt der richtige Ansatz ist.

Hier ist der vollständige Überblick:

Zu diesen Optionen noch ein paar Hinweise. Cinemagoer hatte seit Mai 2023 kein PyPI-Release mehr, und viele seiner Parser sind nach dem IMDb-Redesign im Juni 2025 kaputtgegangen – für den produktiven Einsatz würde ich es aktuell nicht empfehlen. TMDb ist hervorragend, verwendet aber ein eigenes Bewertungssystem und nicht IMDb. Und die offizielle Enterprise-API von IMDb kostet über AWS Data Exchange , also für die meisten von uns keine realistische Option.

Für Leser, die gar keinen Code schreiben wollen, liest der die IMDb-Seite aus, schlägt Extraktionsfelder automatisch vor (Titel, Bewertung, Jahr, Genre) und exportiert die Daten mit zwei Klicks nach Excel, Google Sheets, Airtable oder Notion. Die KI passt sich an, wenn IMDb das Layout ändert – du musst also keine Selektoren pflegen. Dazu später mehr.

Für alle, die lieber Python schreiben möchten: Hier sind zwei Methoden, die funktionieren.

Methode 1: IMDb mit Python und BeautifulSoup scrapen (klassischer Ansatz)

Das ist der klassische Weg, den du in den meisten Tutorials findest. Er funktioniert, aber ich sage es direkt: Von den hier vorgestellten Methoden ist er die fragilste. Die CSS-Klassennamen von IMDb werden automatisch erzeugt und ändern sich bei Redesigns. Trotzdem ist das der beste Einstieg, um die Grundlagen des Web Scrapings zu lernen.

Schritt 1: Python-Bibliotheken installieren und importieren

Du brauchst vier Pakete:

1pip install requests beautifulsoup4 pandas lxml

Das macht jedes davon:

• requests — sendet HTTP-Anfragen, um die Webseite abzurufen
• beautifulsoup4 — parst das HTML, damit du gezielt nach Elementen suchen kannst
• pandas — organisiert die extrahierten Daten in Tabellen und exportiert sie als CSV/Excel
• lxml — ein schneller HTML-Parser (BeautifulSoup kann ihn als Backend nutzen)

Der Import-Block:

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

Schritt 2: Eine HTTP-Anfrage an IMDb senden

Hier stoßen viele Anfänger zum ersten Mal auf ein Problem. IMDb blockiert Anfragen ohne korrekten User-Agent-Header – dann kommt ein 403-Forbidden-Fehler. Der Standard-User-Agent von Python Requests (python-requests/2.31.0) wird sofort erkannt.

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"Seite konnte nicht geladen werden: {response.status_code}")
9else:
10    print("Seite erfolgreich geladen")

Auch der Accept-Language-Header ist wichtig – ohne ihn kann IMDb je nach Geolokation deiner IP Inhalte in einer anderen Sprache zurückgeben.

Schritt 3: Das HTML mit BeautifulSoup parsen

Sobald du das HTML hast, erstellst du ein BeautifulSoup-Objekt und suchst nach den richtigen Elementen. Öffne die IMDb-Top-250-Seite in Chrome, klicke mit der rechten Maustaste auf einen Filmtitel und dann auf „Inspect“, um die zugrunde liegende HTML-Struktur zu sehen.

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

Stand Mitte 2025 verwendet die Top-250-Seite diese Selektoren:

• Film-Container: li.ipc-metadata-list-summary-item
• Titel: h3.ipc-title__text
• Jahr: span.cli-title-metadata-item (erstes Span)
• Bewertung: span.ipc-rating-star--rating

Wichtiger Hinweis: Diese von IMDb verwendeten ipc--Klassen werden vom Component-System automatisch erzeugt. Seit dem Redesign im Juni 2023 sind sie stabil, aber es gibt keine Garantie, dass sie nicht wieder geändert werden.

Schritt 4: Filmdaten extrahieren (Titel, Jahr, Bewertung)

Hier unterscheide ich mich von den meisten Tutorials: Ich nutze try/except für die Fehlerbehandlung. Keine der konkurrierenden Anleitungen, die ich geprüft habe, macht das – genau deshalb brechen deren Skripte stillschweigend, sobald sich ein Selektor ändert.

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"Fehler beim Parsen eines Films: {e}")
18        continue
19print(f"{len(movies)} Filme extrahiert")

Schritt 5: Mit Pandas als CSV oder Excel speichern

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

Beispielausgabe:

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

Das funktioniert. Aber es ist mit CSS-Selektoren zusammengestückelt, die jeden Tag brechen könnten – und genau deshalb kommt jetzt der Ansatz, den ich wirklich empfehle.

Methode 2: Der JSON-LD-Trick – HTML-Parsing komplett umgehen

Das ist die Technik, die in keinem der Konkurrenzartikel vorkommt, und die ich für jedes ernsthafte Projekt verwenden würde. IMDb bindet strukturierte Daten als (JavaScript Object Notation for Linked Data) in <script type="application/ld+json">-Tags auf jeder Seite ein. Diese Daten folgen dem Schema.org-Standard, werden von Google für Rich Results genutzt und ändern sich deutlich seltener als CSS-Klassennamen.

Der Apify IMDb Scraper, ein produktionsreifes Tool, verwendet folgende Extraktionsreihenfolge: „JSON-LD > NEXT_DATA > DOM“. Genau diese Hierarchie würde ich auch empfehlen.

Warum JSON-LD zuverlässiger ist als CSS-Selektoren

CSS-Klassennamen wie ipc-metadata-list-summary-item werden vom React-Component-System von IMDb automatisch erzeugt und ändern sich bei jedem Redesign. Das JSON-LD-Schema beschreibt das eigentliche Datenmodell, nicht die Darstellung. Der Unterschied ist ungefähr so, als würdest du statt nach der Schriftgröße einfach das Inhaltsverzeichnis eines Buches lesen.

Schritt für Schritt: IMDb-Daten aus JSON-LD extrahieren

Schritt 1: Die Seite abrufen

Wie zuvor – nutze requests mit einem passenden User-Agent-Header.

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

Schritt 2: Das JSON-LD-Script-Tag finden

1script_tag = soup.find("script", {"type": "application/ld+json"})
2if not script_tag:
3    print("Kein JSON-LD auf dieser Seite gefunden")
4else:
5    data = json.loads(script_tag.string)
6    print(f"JSON-LD gefunden mit Typ: {data.get('@type', 'unbekannt')}")

Schritt 3: Die strukturierten Daten auslesen

Auf der Top-250-Seite enthält das JSON-LD ein itemListElement-Array mit allen 250 Filmen. Jeder Eintrag enthält Position, Name, URL, aggregateRating, datePublished, Genre, Beschreibung, Regisseur- und Schauspieler-Arrays.

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

Schritt 4: Als CSV exportieren

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

Beispielausgabe:

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

Alle 250 Filme. Sauber, strukturiert, ohne CSS-Selektor-Akrobatik. Und weil diese Daten dem Schema.org-Standard folgen, auf den Google für Suchergebnisse angewiesen ist, ändern sie sich deutlich seltener als das visuelle Layout.

Bonus: __NEXT_DATA__ für einzelne Filmseiten

Für umfangreichere Daten von einzelnen Titelseiten (Laufzeit, komplette Besetzung, Plot-Zusammenfassung, Poster-Bilder) bindet IMDb zusätzlich ein __NEXT_DATA__-JSON-Objekt ein. Das sind die Daten, mit denen React die Seite hydratisiert – sie lassen sich nicht entfernen, ohne die Seite zu zerstören.

1# Auf einer einzelnen Filmseite wie /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"]

Nutze JSON-LD für Listen- und Chart-Seiten, __NEXT_DATA__ für einzelne Titelseiten. Das ist der produktionsreife Ansatz.

Warum dein IMDb-Scraper ständig kaputtgeht – und wie du das behebst

Das ist der am häufigsten genannte Schmerzpunkt in allen IMDb-Scraping-Foren, die ich geprüft habe. Nutzer schreiben: „Ein Teil des Codes ist wegen UI-Änderungen kaputtgegangen“ und „2024 funktioniert es nicht!“ – und die Antwort ist meistens Schweigen oder „probier Selenium“.

Die Ursache ist IMDbs laufende Umstellung auf ein React-/Next.js-Frontend. Hier ist die Zeitleiste der großen Breaking Changes:

Das entspricht ungefähr einer größeren Breaking Change alle 6 bis 12 Monate. Wenn dein Scraper auf CSS-Klassennamen basiert, läufst du auf einem Laufband.

Häufige Fehler und wie du sie behebst

Leere Ergebnisse / NoneType-Fehler

Der häufigste Fehler. Du siehst AttributeError: 'NoneType' object has no attribute 'text'. Das bedeutet, dass BeautifulSoup das Element nicht gefunden hat – meist, weil sich der CSS-Klassenname geändert hat oder der Inhalt per JavaScript gerendert wird.

Lösung: Auf JSON-LD-Extraktion umsteigen (Methode 2 oben). Die Daten stecken in der initialen HTML-Antwort, JavaScript ist nicht nötig.

403 Forbidden

IMDb nutzt , um Bots zu erkennen und zu blockieren. Der häufigste Auslöser ist ein fehlender oder offensichtlich gefälschter User-Agent-Header. Das ist in Open-Source-Projekten dokumentiert und auch in , wo ein IMDb-Mitarbeiter das Problem bestätigt hat.

Lösung: Immer einen realistischen Browser-User-Agent und den Header Accept-Language: en-US mitgeben. Nutze requests.Session() für Connection Pooling.

Nur 25 Ergebnisse werden zurückgegeben

IMDb-Suchseiten und „Most Popular“-Listen verwenden Lazy Loading – zunächst werden nur etwa 25 Ergebnisse geladen, weitere Inhalte kommen per AJAX beim Scrollen nach.

Lösung: Nutze URL-Parameter für Pagination (im nächsten Abschnitt erklärt) oder wechsle zur Top-250-Seite, die alle 250 Filme in einer einzigen Antwort lädt.

Selektoren funktionieren plötzlich nicht mehr

Alte Selektoren, die nicht mehr funktionieren: td.titleColumn, td.ratingColumn, .lister-item-header, .inline-block.ratings-imdb-rating. Wenn dein Code einen davon verwendet, ist er kaputt.

Lösung: Bevorzuge data-testid-Attribute (zum Beispiel h1[data-testid="hero-title-block__title"]) statt automatisch erzeugter Klassennamen. Noch besser: JSON-LD verwenden.

Ein Entscheidungsrahmen: kurzfristige vs. langfristige Lösungen

• Schnelle Lösung: try/except-Blöcke um jeden Selektor, HTTP-Statuscodes prüfen, Fehler protokollieren statt Abstürze zu produzieren
• Mittelfristige Lösung: Von CSS-Selektoren auf JSON-LD-Extraktion wechseln (Methode 2)
• Langfristige Lösung: Für große Analysen die verwenden oder ein Tool wie , das die Seitenstruktur jedes Mal per KI neu ausliest – ohne Selektoren, die gepflegt werden müssen; die KI passt sich Layout-Änderungen automatisch an

Jenseits der 25-Ergebnisse-Grenze: IMDb-Pagination und große Datensätze scrapen

Jedes Konkurrenz-Tutorial, das ich geprüft habe, scrapt exakt eine Seite. Niemand behandelt Pagination. Aber wenn du mehr als eine einzelne Liste brauchst, stößt du schnell an Grenzen.

Seiten, die keine Pagination brauchen

Gute Nachricht: Die Top-250-Seite lädt alle 250 Filme in einer einzigen serverseitig gerenderten Antwort. Sowohl JSON-LD als auch __NEXT_DATA__ enthalten den kompletten Datensatz. Keine Pagination nötig.

So funktioniert die Pagination bei IMDb-Suchen

IMDb-Suchseiten verwenden einen start=-URL-Parameter, der in 50er-Schritten erhöht wird:

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

Hier ist eine Python-Schleife, die durch die Ergebnisse paginiert:

1import time
2all_movies = []
3for start in range(1, 1001, 50):  # Durchläuft 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"Fehler bei start={start}: {response.status_code}")
8        break
9    soup = BeautifulSoup(response.text, "lxml")
10    # Filme mit deiner bevorzugten Methode extrahieren
11    # ...
12    print(f"Seite mit Startwert {start} gescrapt")
13    time.sleep(3)  # Rücksichtsvoll sein – IMDb blockiert nach etwa 50 schnellen Requests

Dieses time.sleep(3) ist wichtig. Aus der Community gibt es Berichte, dass IMDb IPs nach ungefähr 50 schnellen Requests blockiert. Eine zufällige Verzögerung zwischen 2 und 5 Sekunden ist daher gute Praxis.

Wann du Scraping ganz überspringen solltest: die offiziellen IMDb-Bulk-Datasets

Für wirklich große Anforderungen stellt IMDb 7 kostenlose TSV-Dateien unter bereit, die täglich aktualisiert werden:

Der Import in Pandas ist unkompliziert:

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# Verknüpfen über tconst (IMDb-Titel-ID)
4merged = basics.merge(ratings, on="tconst")
5top_movies = merged[merged["titleType"] == "movie"].nlargest(250, "averageRating")

Diese Datensätze umfassen mehr als 26 Millionen Titel. Keine Pagination, keine Selektoren, keine 403-Fehler. Die Lizenz gilt nur für persönliche und nicht-kommerzielle Nutzung – du darfst die Daten nicht neu veröffentlichen oder weiterverkaufen.

Die No-Code-Abkürzung: Thunderbit übernimmt die Pagination für dich

Für Leser, die IMDb-Daten mit Pagination brauchen, aber keine Pagination-Logik schreiben möchten, unterstützt sowohl klickbasierte Pagination als auch Infinite Scroll nativ. Du sagst einfach, was gescrapt werden soll – Thunderbit erledigt den Rest, inklusive Scrollen durch Lazy-Loaded-Inhalte.

IMDb mit Python scrapen: Der komplette funktionierende Code zum Kopieren

Hier sind zwei eigenständige Skripte, die du sofort ausführen kannst.

Skript A: BeautifulSoup-Methode (CSS-Selektoren)

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"Fehler: {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 übersprungen wegen Fehler: {e}")
28df = pd.DataFrame(movies)
29df.to_csv("imdb_top250_bs4.csv", index=False)
30print(f"{len(df)} Filme gespeichert")
31print(df.head())

Skript B: JSON-LD-Methode (empfohlen)

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"Fehler: {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("Keine JSON-LD-Daten gefunden")
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)} Filme gespeichert")
42print(df.head())

Beide Skripte enthalten Fehlerbehandlung und erzeugen saubere CSV-Ausgaben. Skript B liefert dir mehr Daten – Regisseur, Beschreibung, URL – und ist robuster gegenüber Layout-Änderungen.

IMDb ohne Code scrapen: mit Thunderbit

Nicht jeder braucht oder möchte Python schreiben. Vielleicht bist du Operations-Analyst und willst einfach nur die bestbewerteten Filme dieser Woche in einer Tabelle. Vielleicht arbeitest du im Content-Team und möchtest Genre-Trends über mehrere Jahre vergleichen. In solchen Fällen ist ein eigener Scraper schlicht überdimensioniert.

So bekommst du dieselben Daten mit :

Bevor du startest:

• Schwierigkeit: Anfänger
• Benötigte Zeit: ca. 2 Minuten
• Was du brauchst: Chrome-Browser, (kostenlose Stufe reicht)

Schritt 1: Öffne die IMDb-Seite, die du scrapen möchtest. Öffne die IMDb Top 250 (oder eine andere IMDb-Liste bzw. Suchseite) in Chrome.

Schritt 2: Klicke in der Thunderbit-Seitenleiste auf „AI Suggest Fields“. Die KI analysiert die Seite und empfiehlt Spalten – typischerweise Titel, Jahr, Bewertung, Genre und je nach Seite noch weitere. Du siehst eine Vorschau-Tabelle mit den vorgeschlagenen Feldern.

Schritt 3: Felder bei Bedarf anpassen. Entferne Spalten, die du nicht brauchst, oder füge eigene hinzu, indem du auf „+ Add Column“ klickst und in normaler Sprache beschreibst, was du möchtest, z. B. „Regisseurname“ oder „Anzahl der Stimmen“.

Schritt 4: Klicke auf „Scrape“. Thunderbit extrahiert die Daten. Bei Seiten mit Infinite Scroll oder Pagination übernimmt es das Scrollen automatisch.

Schritt 5: Exportieren. Klicke auf den Export-Button und wähle dein Format – Excel, Google Sheets, CSV, Airtable oder Notion. Die Daten landen in Sekundenschnelle an ihrem Ziel.

Der entscheidende Vorteil ist nicht nur die Bequemlichkeit – Thunderbits KI liest die Seitenstruktur jedes Mal neu ein. Wenn IMDb sein Layout ändert, passt sich die KI an. Keine Selektoren, die aktualisiert werden müssen, kein Code, der repariert werden muss. Für alle, die schon einmal um 2 Uhr nachts vor einem Deadline-Tag an einem kaputten Scraper verzweifelt sind, ist das Gold wert.

Thunderbit unterstützt auch das Scrapen von Unterseiten – du kannst auf die Detailseite jedes Films gehen und deine Tabelle um Besetzung, Regisseur, Laufzeit und andere Felder erweitern, die auf der Listenansicht nicht sichtbar sind. Wenn du es in Aktion sehen möchtest, schau dir den an.

Ist es legal, IMDb zu scrapen? Das musst du wissen

Nutzer stellen diese Frage ganz direkt in Foren: „Ist so etwas legal? IMDb will doch eigentlich nicht, dass Leute ihre Website scrapen.“ Eine berechtigte Frage – und ein Punkt, den kein Konkurrenzartikel sauber behandelt.

IMDb robots.txt: Die Top-250-Seite (/chart/top/), einzelne Titelseiten (/title/ttXXXXXXX/) und Namensseiten (/name/nmXXXXXXX/) sind in der robots.txt NICHT gesperrt. Gesperrte Pfade sind unter anderem /find, /_json/*, /search/name-text, /user/ur*/ratings sowie verschiedene AJAX-Endpunkte. Eine Crawl-delay-Anweisung ist nicht angegeben.

IMDb-Nutzungsbedingungen: Die relevante Klausel lautet sinngemäß: „Sie dürfen auf dieser Website keine Data-Mining-, Roboter-, Screen-Scraping- oder ähnliche Tools zur Datenerfassung und -extraktion verwenden, außer mit unserer ausdrücklichen schriftlichen Zustimmung.“ Eine weitere Klausel verbietet den Weiterverkauf oder die kommerzielle Nutzung der gescrapten Daten.

Was das in der Praxis bedeutet: Jüngste Gerichtsentscheidungen aus dem Jahr 2024 (Meta v. Bright Data, X Corp v. Bright Data) kamen zu dem Schluss, dass AGB möglicherweise nicht bindend sind, wenn Nutzer ihnen nie zugestimmt haben – wenn du öffentlich zugängliche Daten ohne Login scrapest, ist die Durchsetzbarkeit der AGB also umstritten. Das rechtliche Feld entwickelt sich jedoch weiter.

Sichere Alternativen: Die sind ausdrücklich für persönliche und nicht-kommerzielle Nutzung freigegeben. Die TMDb-API ist mit kostenlosem API-Key ebenfalls sehr großzügig nutzbar. Beide sind gute Optionen, wenn du rechtlich auf der sicheren Seite bleiben möchtest.

Praktische Empfehlung: Wenn du dennoch scrapen willst, arbeite mit einer vernünftigen Crawl-Rate (time.sleep(3) zwischen den Anfragen), setze saubere Header und rufe keine von robots.txt gesperrten Pfade auf. Bei kommerziellen Projekten solltest du juristischen Rat einholen oder die offiziellen Datasets/API nutzen.

Wir haben die im Thunderbit-Blog ausführlich behandelt.

Fazit: Wähle den richtigen Weg, um IMDb mit Python zu scrapen

Die Kurzfassung:

• BeautifulSoup + CSS-Selektoren: Gut, um die Grundlagen zu lernen. Rechne damit, dass es alle 6 bis 12 Monate bricht. Fehlerbehandlung ist Pflicht.
• JSON-LD-Extraktion: Der Ansatz, den ich für jedes laufende Python-Projekt empfehlen würde. Orientiert sich am Schema.org-Standard, ändert sich viel seltener als CSS-Klassen und liefert dir saubere, strukturierte Daten ohne JavaScript-Rendering.
• __NEXT_DATA__-JSON: Als Ergänzung für reichere Daten auf einzelnen Titelseiten nutzen (Laufzeit, komplette Besetzung, Handlung, Posterbilder).
• IMDb Official Datasets: Die beste Wahl für groß angelegte Analysen. Über 26 Mio. Titel, tägliche Updates, kein Scraping nötig. Nur für persönliche/nicht-kommerzielle Nutzung.
• : Die beste Wahl für Nicht-Programmierer oder alle, die schnell Daten brauchen, ohne Code pflegen zu müssen. Die KI passt sich Layout-Änderungen an, übernimmt Pagination und exportiert nach Excel/Sheets/Airtable/Notion.

Setze dir ein Lesezeichen für diesen Leitfaden – ich aktualisiere ihn, wenn sich die IMDb-Struktur das nächste Mal ändert. Und wenn du den Code komplett überspringen möchtest, teste und schau, wie schnell du von einer IMDb-Seite zu einer sauberen Tabelle kommst. Wenn du auch mit anderen Webseiten arbeitest, erklärt unser Leitfaden zum den gesamten Workflow.

FAQs

Ist es legal, IMDb zu scrapen?

Die Nutzungsbedingungen von IMDb verbieten Scraping ohne Zustimmung, aber die Durchsetzbarkeit solcher AGB bei öffentlich zugänglichen Daten ist nach jüngsten Gerichtsentscheidungen aus dem Jahr 2024 rechtlich umstritten. Die sichersten Optionen sind die (für persönliche/nicht-kommerzielle Nutzung) oder die TMDb-API (kostenloser Key). Wenn du dennoch scrapen willst, halte dich an robots.txt, verwende angemessene Pausen zwischen den Anfragen und vermeide gesperrte Pfade. Für kommerzielle Zwecke solltest du juristischen Rat einholen.

Warum liefert mein IMDb-Scraper leere Ergebnisse?

Fast immer liegt es an veralteten CSS-Selektoren – Klassennamen wie td.titleColumn und td.ratingColumn gibt es seit Juni 2023 nicht mehr. Die Lösung: auf JSON-LD-Extraktion umsteigen (den <script type="application/ld+json">-Tag parsen) oder die Selektoren auf die aktuellen ipc--Klassen anpassen. Prüfe außerdem, ob du einen korrekten User-Agent-Header sendest, denn ein fehlender Header führt zu einem 403-Fehler, der wie ein leeres Ergebnis aussehen kann.

Wie scrape ich mehr als 25 Ergebnisse von IMDb?

Die Top-250-Seite lädt alle 250 Filme in einer einzigen Antwort – keine Pagination nötig. Für Suchergebnisse nutzt du den start=-URL-Parameter (in 50er-Schritten), um durch die Ergebnisse zu blättern. Beispiel: start=1, start=51, start=101. Füge zwischen den Anfragen time.sleep(3) ein, um nicht blockiert zu werden. Alternativ enthalten die offiziellen IMDb-Datasets unter über 26 Mio. Titel ganz ohne Pagination.

Was ist __NEXT_DATA__ und warum sollte ich es zum IMDb-Scraping verwenden?

__NEXT_DATA__ ist ein JSON-Objekt, das in einem <script id="__NEXT_DATA__">-Tag auf IMDb-Seiten mit React/Next.js eingebettet ist. Es enthält die vollständigen strukturierten Daten, mit denen React die Seite rendert – Titel, Bewertungen, Besetzung, Genres, Laufzeit und mehr. Weil es das zugrunde liegende Datenmodell und nicht das visuelle Layout repräsentiert, ist es robuster gegen UI-Redesigns als CSS-Selektoren. Nutze es zusammen mit JSON-LD für den robustesten Extraktionsansatz.

Kann ich IMDb ohne Programmieren scrapen?

Ja. Zwei Hauptoptionen: (1) Die herunterladen – 7 TSV-Dateien mit 26 Mio.+ Titeln, täglich aktualisiert, frei für nicht-kommerzielle Nutzung. (2) Den verwenden, der die IMDb-Seite liest, Extraktionsfelder automatisch vorschlägt und Daten mit zwei Klicks nach Excel, Google Sheets oder CSV exportiert – ganz ohne Code und ohne zu wartende Selektoren.

Mehr erfahren