Wer in letzter Zeit nach „IMDb mit Python scrapen“ gesucht hat, wird eine unangenehme Erfahrung gemacht haben: Die meisten Tutorials, die man findet, funktionieren schlicht nicht mehr. Und zwar nicht im Sinne von „leicht veraltet“, sondern eher von „liefert null Ergebnisse und eine Wand aus NoneType-Fehlern“.
Wer jedes größere IMDb-Scraping-Tutorial durchprobiert – GeeksforGeeks, Medium, freeCodeCamp, Kaggle-Notebooks, das ganze Programm –, stellt schnell fest: Von den 214+ öffentlichen GitHub-Repositories, die unter dem Stichwort IMDb-Scraping getaggt sind, setzen die allermeisten auf CSS-Selektoren (td.titleColumn, td.ratingColumn), die seit dem Redesign der Top-250-Seite im Juni 2023 gar nicht mehr existieren. Das Ergebnis sind Foren voller Entwickler mit der immer gleichen Frage „Warum gibt mein Code leere Ergebnisse zurück?“ – und Maintainer beliebter Bibliotheken wie Cinemagoer, die offen einräumen: „Viel können wir nicht tun, außer jeden Parser zu reparieren.“ Dieser Leitfaden zeigt zwei Python-Methoden, die aktuell tatsächlich funktionieren, klärt den Umgang mit Paginierung und typischen Fehlern, sagt dir, wann Python nicht einmal das passende Werkzeug ist, und wie du deinen Scraper so absicherst, dass er nicht nach kurzer Zeit auf dem Friedhof landet.
Was bedeutet es, IMDb mit Python zu scrapen?
Web-Scraping ist der Vorgang, Daten programmgesteuert aus Webseiten zu extrahieren – statt manuell zu kopieren und einzufügen, schreibst du ein Skript, das dir die Arbeit abnimmt. „IMDb scrapen“ heißt in diesem Zusammenhang, strukturierte Filmdaten (Titel, Bewertungen, Genres, Besetzung, Laufzeit, Stimmenzahlen) mit Python aus den IMDb-Webseiten zu ziehen.
Der typische Python-Stack stützt sich dabei auf 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 greifen für Seiten mit JavaScript-Rendering zusätzlich zu Selenium oder Playwright, aber wie sich gleich zeigt, geht es auch deutlich schneller.
Wichtig: Alles in diesem Leitfaden ist gegen die aktuelle Seitenstruktur von IMDb (Mitte 2025) geprüft. IMDb baut ungefähr alle 6–12 Monate etwas um, also können sich einzelne Selektoren verschoben haben, falls du das hier 2027 liest. (Wie du damit umgehst, erkläre ich ebenfalls.)
Warum IMDb mit Python scrapen? Praxisbeispiele aus der echten Welt
Bevor die erste Codezeile entsteht, lohnt die Gegenfrage: Was willst du mit IMDb-Daten überhaupt anfangen? Das hängt ganz davon ab, wer du bist.
Der IMDb-Bewertungsdatensatz zählt zu den meistgenutzten NLP-Benchmarks weltweit – die grundlegende Arbeit von Maas et al. (2011) ist inzwischen auf 5.706 Zitationen gekommen, und der Datensatz steckt fest in TensorFlow, Keras und PyTorch. Auf Hugging Face wird der Datensatz stanfordnlp/imdb monatlich 213.321 Mal heruntergeladen und diente bereits zum Training von über 1.500 Modellen. Wer im Machine Learning unterwegs ist, kennt IMDb-Daten also vermutlich längst.
Die Anwendungsfälle reichen aber weit über die Wissenschaft hinaus:
| Anwendungsfall | Für wen | Benötigte Datenfelder |
|---|---|---|
| Empfehlungs-Engine für Filme | Data Scientists, Hobbyisten | Titel, Genres, Bewertungen, Besetzung |
| Content-Strategie für Streaming-Plattformen | Produkt-/Content-Teams | Bewertungen, Stimmen, Erscheinungsjahr, Genres |
| Sentiment-Analyse / NLP-Training | ML-Forschende, Studierende | Rezensionen, Bewertungen |
| Wettbewerbsanalyse für Inhalte | Analysten der Entertainment-Branche | Box Office, Erscheinungsdaten, Bewertungstrends |
| Forschung zu Filmtourismus | Tourismusverbände, Reiseunternehmen | Drehorte, Popularitätsmetriken |
| Wissenschaftliche Forschung | Universitätsforscher | Beliebige strukturierte Filmetadaten |
Der Markt für Filmtourismus allein wird 2025 weltweit auf 66 Milliarden US-Dollar geschätzt. Netflix gab 2024 über 17 Milliarden US-Dollar für Inhalte aus, wobei 80 % der Zuschaueraktivität auf personalisierte Empfehlungen zurückgingen. Kurzum: IMDb-Daten fließen in vielen Branchen in echte Entscheidungen ein.
Deine Optionen, um an IMDb-Daten zu kommen (bevor du eine Zeile Code schreibst)
Diesen Abschnitt überspringen die meisten Tutorials komplett. Sie stürzen sich direkt auf pip install beautifulsoup4, ohne überhaupt zu fragen, ob Python-Scraping für deine Lage der richtige Weg ist.
Hier die komplette Landschaft:
| Weg | Am besten für | Vorteile | Nachteile |
|---|---|---|---|
| Python + BeautifulSoup | Lernen, individuelle Extraktion | Volle Kontrolle, flexibel | Fragile Selektoren, bricht oft |
JSON-LD- / __NEXT_DATA__-Extraktion | Entwickler, die Stabilität wollen | Verarbeitet JS-Inhalte, robuster | Erfordert Verständnis der JSON-Struktur |
| IMDb Official Datasets | Analysen im großen Maßstab, akademische Nutzung | Legal, vollständig, 26M+ Titel, tägliche Updates | TSV-Format, keine Rezensionen/Bilder |
| Cinemagoer-(IMDbPY)-Bibliothek | Programmgesteuerte Abfragen pro Titel | Pythonische API, viele Felder | 88 offene Issues, letzte Veröffentlichung Mai 2023 |
| TMDb API | Filmetadaten + Bilder | Kostenloser API-Key, JSON, gut dokumentiert | Andere Quelle (keine IMDb-Bewertungen) |
| Thunderbit (No-Code) | Nicht-Coder, schnelle Exporte | Scraping in 2 Klicks, KI schlägt Felder vor, Export nach Excel/Sheets | Bei großen Scrapes kreditbasiert |
Ein paar Anmerkungen zu diesen Optionen: Cinemagoer hat seit Mai 2023 kein PyPI-Release mehr gesehen, und die meisten Parser sind mit dem IMDb-Redesign im Juni 2025 zerbrochen – für den Produktiveinsatz würde ich es derzeit nicht empfehlen. TMDb ist hervorragend, nutzt aber sein eigenes Bewertungssystem statt der IMDb-Bewertungen. Und die offizielle Enterprise-API von IMDb schlägt über AWS Data Exchange mit über 50.000 US-Dollar pro Jahr zu Buche – für die meisten von uns also keine Option.
Wer überhaupt keinen Code schreiben will, lässt Thunderbits KI-Web-Scraper die IMDb-Seite auslesen: Das Tool schlägt die Extraktionsfelder automatisch vor (Titel, Bewertung, Jahr, Genre) und exportiert in zwei Klicks nach Excel, Google Sheets, Airtable oder Notion. Die KI passt sich an, sobald IMDb das Layout umstellt – es gibt also keine Selektoren, die du pflegen müsstest. Dazu später mehr.
Für alle, die Python schreiben möchten, kommen hier zwei funktionierende Methoden.
Methode 1: IMDb mit Python und BeautifulSoup scrapen (klassischer Ansatz)
Das ist der klassische Ansatz aus den meisten Tutorials. Er funktioniert, aber sei ehrlich gewarnt: Er ist die fragilste der hier vorgestellten Methoden. Die CSS-Klassennamen von IMDb werden automatisch generiert und wechseln bei jedem Redesign. Trotzdem eignet er sich am besten, um die Grundlagen des Web-Scrapings zu lernen.
Schritt 1: Deine Python-Bibliotheken installieren und importieren
Du brauchst vier Pakete:
pip install requests beautifulsoup4 pandas lxml
Was jedes davon leistet:
requests— sendet HTTP-Anfragen, um die Webseite abzurufenbeautifulsoup4— parst das HTML, damit du gezielt nach Elementen suchen kannstpandas— organisiert die extrahierten Daten in Tabellen und exportiert sie nach CSV/Excellxml— ein schneller HTML-Parser (BeautifulSoup kann ihn als Backend nutzen)
Dein Import-Block:
import requests
from bs4 import BeautifulSoup
import pandas as pd
Schritt 2: Eine HTTP-Anfrage an IMDb senden
An dieser Stelle scheitern die meisten Einsteiger zum ersten Mal. IMDb blockiert Anfragen ohne passenden User-Agent-Header – du fängst dir dann einen 403 Forbidden ein. Den Standard-User-Agent von Python Requests (python-requests/2.31.0) erkennt der Server sofort.
url = "https://www.imdb.com/chart/top/"
headers = {
"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",
"Accept-Language": "en-US,en;q=0.9"
}
response = requests.get(url, headers=headers)
if response.status_code != 200:
print(f"Seite konnte nicht abgerufen werden: {response.status_code}")
else:
print("Seite erfolgreich abgerufen")
Auch der Accept-Language-Header zählt – ohne ihn kann IMDb je nach Geolokalisierung deiner IP Inhalte in einer anderen Sprache ausliefern.
Schritt 3: Das HTML mit BeautifulSoup parsen
Sobald das HTML vorliegt, erstellst du ein BeautifulSoup-Objekt und gehst auf die Suche nach den richtigen Elementen. Öffne die IMDb-Top-250-Seite in Chrome, klicke mit der rechten Maustaste auf einen Filmtitel und dann auf „Untersuchen“, um die zugrunde liegende HTML-Struktur freizulegen.
soup = BeautifulSoup(response.text, "lxml")
Stand Mitte 2025 nutzt 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(erstesspan) - Bewertung:
span.ipc-rating-star--rating
Beachte: Diese Klassen mit dem Präfix ipc- stammen aus dem Komponenten-System von IMDb. Seit dem Redesign im Juni 2023 sind sie stabil, aber eine Garantie gegen erneute Änderungen gibt es nicht.
Schritt 4: Filmdaten extrahieren (Titel, Jahr, Bewertung)
Hier weiche ich von den meisten Tutorials ab: Ich baue try/except-Fehlerbehandlung ein. Keine der geprüften Konkurrenz-Anleitungen tut das – und genau deshalb bricht ihr Code lautlos zusammen, sobald sich ein Selektor ändert.
movies = []
movie_items = soup.select("li.ipc-metadata-list-summary-item")
for item in movie_items:
try:
title_tag = item.select_one("h3.ipc-title__text")
title = title_tag.text.strip() if title_tag else "N/A"
year_tag = item.select_one("span.cli-title-metadata-item")
year = year_tag.text.strip() if year_tag else "N/A"
rating_tag = item.select_one("span.ipc-rating-star--rating")
rating = rating_tag.text.strip() if rating_tag else "N/A"
movies.append({
"title": title,
"year": year,
"rating": rating
})
except Exception as e:
print(f"Fehler beim Parsen des Films: {e}")
continue
print(f"{len(movies)} Filme extrahiert")
Schritt 5: Mit Pandas als CSV oder Excel speichern
df = pd.DataFrame(movies)
df.to_csv("imdb_top_250.csv", index=False)
df.to_excel("imdb_top_250.xlsx", index=False)
print(df.head())
Beispielausgabe:
title year rating
0 1. The Shawshank Redemption 1994 9.3
1 2. The Godfather 1972 9.2
2 3. The Dark Knight 2008 9.0
3 4. The Godfather Part II 1974 9.0
4 5. 12 Angry Men 1957 9.0
Das funktioniert. Aber es hängt an CSS-Selektoren, die morgen schon hinüber sein können – und deshalb kommen wir jetzt zu der Methode, die ich tatsächlich empfehle.
Methode 2: Der JSON-LD-Trick — HTML-Parsing komplett überspringen
Diese Technik behandelt kein einziger Konkurrenzartikel, und sie wäre für jedes ernsthafte Projekt meine erste Wahl. IMDb bettet auf jeder Seite strukturierte Daten als JSON-LD (JavaScript Object Notation for Linked Data) in <script type="application/ld+json">-Tags ein. Diese Daten folgen dem Schema.org-Standard, Google verwertet sie für Rich Results, und sie ändern sich weitaus seltener als CSS-Klassennamen.
Der Apify IMDb Scraper, ein produktionsreifes Tool, arbeitet bei der Extraktion nach der Prioritätsreihenfolge „JSON-LD > NEXT_DATA > DOM“. Genau diese Hierarchie würde ich ebenfalls empfehlen.
Warum JSON-LD zuverlässiger ist als CSS-Selektoren
| Ansatz | Verarbeitet JS-Inhalte? | Robust bei UI-Änderungen? | Geschwindigkeit | Komplexität |
|---|---|---|---|---|
| BeautifulSoup + CSS-Selektoren | ❌ Nein | ⚠️ Fragil (Klassennamen ändern sich) | Schnell | Niedrig |
| JSON-LD-Extraktion | ✅ Ja | ✅ Folgt dem Schema.org-Standard | Schnell | Niedrig–Mittel |
JSON-Extraktion aus __NEXT_DATA__ | ✅ Ja | ✅ Ziemlich stabil | Schnell | Niedrig–Mittel |
| Selenium / Playwright | ✅ Ja | ⚠️ Fragil | Langsam | Mittel–Hoch |
| Thunderbit (No-Code, 2 Klicks) | ✅ Ja (KI liest die Seite) | ✅ KI passt sich automatisch an | Schnell | Keine |
CSS-Klassennamen wie ipc-metadata-list-summary-item erzeugt das React-Komponentensystem von IMDb automatisch, und sie wechseln mit jedem Redesign. Das JSON-LD-Schema dagegen bildet das eigentliche Datenmodell ab, nicht die Darstellungsschicht. Das ist ungefähr so, als läsest du das Inhaltsverzeichnis eines Buches, statt Kapitel über ihre Schriftgröße zu erraten.
Schritt für Schritt: IMDb-Daten aus JSON-LD extrahieren
Schritt 1: Seite abrufen
Wie zuvor – requests mit einem passenden User-Agent-Header.
import requests
from bs4 import BeautifulSoup
import json
import pandas as pd
url = "https://www.imdb.com/chart/top/"
headers = {
"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",
"Accept-Language": "en-US,en;q=0.9"
}
response = requests.get(url, headers=headers)
soup = BeautifulSoup(response.text, "lxml")
Schritt 2: Den JSON-LD-Script-Tag finden
script_tag = soup.find("script", {"type": "application/ld+json"})
if not script_tag:
print("Auf dieser Seite wurde kein JSON-LD gefunden")
else:
data = json.loads(script_tag.string)
print(f"JSON-LD gefunden mit Typ: {data.get('@type', 'unbekannt')}")
Schritt 3: Die strukturierten Daten parsen
Auf der Top-250-Seite enthält das JSON-LD ein itemListElement-Array mit allen 250 Filmen. Jeder Eintrag liefert Position, Name, URL, aggregateRating, datePublished, Genre, Beschreibung sowie Regisseur- und Schauspieler-Arrays.
movies = []
for item in data.get("itemListElement", []):
movie = item.get("item", {})
rating_info = movie.get("aggregateRating", {})
movies.append({
"rank": item.get("position"),
"title": movie.get("name"),
"url": movie.get("url"),
"rating": rating_info.get("ratingValue"),
"vote_count": rating_info.get("ratingCount"),
"date_published": movie.get("datePublished"),
"genre": ", ".join(movie.get("genre", [])),
"description": movie.get("description"),
})
Schritt 4: Als CSV exportieren
df = pd.DataFrame(movies)
df.to_csv("imdb_top_250_json_ld.csv", index=False)
print(df.head())
Beispielausgabe:
rank title url rating vote_count date_published genre
0 1 The Shawshank Redemption https://www.imdb.com/title/tt0111161/ 9.3 2900000 1994-10-14 Drama
1 2 The Godfather https://www.imdb.com/title/tt0068646/ 9.2 2000000 1972-03-24 Crime, Drama
2 3 The Dark Knight https://www.imdb.com/title/tt0468569/ 9.0 2800000 2008-07-18 Action, Crime, Drama
Alle 250 Filme. Sauber, strukturiert, ganz ohne CSS-Selektor-Akrobatik. Und weil diese Daten dem Schema.org-Standard folgen, auf den Google für seine Suchergebnisse angewiesen ist, werden sie viel seltener angefasst als das visuelle Layout.
Bonus: __NEXT_DATA__ für einzelne Filmseiten
Für reichhaltigere Daten von einzelnen Titelseiten (Laufzeit, vollständige Besetzung, Handlung, Posterbilder) bettet IMDb zusätzlich ein __NEXT_DATA__-JSON-Objekt ein. Das sind genau die Daten, mit denen React die Seite hydriert – entfernen lassen sie sich nicht, ohne die Website lahmzulegen.
# Auf einer einzelnen Filmseite wie /title/tt0111161/
next_data_tag = soup.find("script", {"id": "__NEXT_DATA__"})
if next_data_tag:
next_data = json.loads(next_data_tag.string)
above_fold = next_data["props"]["pageProps"]["aboveTheFoldData"]
title = above_fold["titleText"]["text"]
year = above_fold["releaseYear"]["year"]
rating = above_fold["ratingsSummary"]["aggregateRating"]
runtime_seconds = above_fold.get("runtime", {}).get("seconds", 0)
genres = [g["text"] for g in above_fold["genres"]["genres"]]
plot = above_fold["plot"]["plotText"]["plainText"]
Nimm JSON-LD für Listen- und Chart-Seiten und __NEXT_DATA__ für einzelne Titelseiten. Das ist der produktionsreife Ansatz.
Warum dein IMDb-Scraper ständig kaputtgeht — und wie du es behebst
Das ist mit Abstand die am häufigsten gemeldete Schwachstelle in sämtlichen IMDb-Scraping-Foren, die ich durchgesehen habe. Die Nutzer schreiben: „Ein Teil des Codes ist wegen UI-Änderungen kaputtgegangen“ und „Funktioniert 2024 nicht!“ – und als Antwort kommt meist Schweigen oder „Probier Selenium.“
Die Ursache ist Imdbs fortlaufende Migration zu einem React-/Next.js-Frontend. Hier die Zeitleiste der wichtigsten Breaking Changes:
| Datum | Was sich geändert hat | Was kaputtging |
|---|---|---|
| Nov. 2022 | Namensseiten neu gestaltet | Alte Scraper für Namensseiten |
| Juni 2023 | Top-250-Seite neu gestaltet | Alle Selektoren td.titleColumn / td.ratingColumn |
| April 2023 | Unterseiten der Titel neu gestaltet | Bio-, Award- und News-Scraper |
| Okt. 2023 | Erweiterte Suche neu gestaltet | Suchbasierte Scraper |
| Juni 2025 | /reference-Seiten neu gestaltet | Cinemagoer-Bibliothek (die meisten Parser) |
Das bedeutet ungefähr alle 6–12 Monate eine größere Breaking Change. Steht dein Scraper auf CSS-Klassennamen, läufst du dabei 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 heißt, BeautifulSoup hat das gesuchte Element nicht gefunden – 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 bereits in der initialen HTML-Antwort, JavaScript ist nicht nötig.
403 Forbidden
IMDb setzt AWS WAF ein, um Bots zu erkennen und zu blockieren. Häufigster Auslöser ist ein fehlender oder offensichtlich gefälschter User-Agent-Header. Das ist in mehreren Open-Source-Projekten dokumentiert und auch in Imdbs eigenen Community-Foren, wo ein IMDb-Mitarbeiter das Problem bestätigt hat.
Lösung: Immer einen realistischen Browser-User-Agent und den Header Accept-Language: en-US mitschicken. Für Connection Pooling requests.Session() verwenden.
Nur 25 Ergebnisse zurückgegeben
IMDb-Suchseiten und „Most Popular“-Listen arbeiten mit Lazy Loading – anfangs rendern sie nur rund 25 Ergebnisse und laden beim Scrollen per AJAX weitere nach.
Lösung: URL-Parameter-Paginierung nutzen (im nächsten Abschnitt erklärt) oder zur Top-250-Seite wechseln, die alle 250 Filme in einer einzigen Antwort lädt.
Selektoren funktionieren plötzlich nicht mehr
Alte, nicht mehr funktionierende Selektoren: td.titleColumn, td.ratingColumn, .lister-item-header, .inline-block.ratings-imdb-rating. Verwendet dein Code einen davon, ist er hinüber.
Lösung: data-testid-Attribute (z. B. h1[data-testid="hero-title-block__title"]) automatisch generierten Klassennamen vorziehen. Noch besser: JSON-LD nutzen.
Ein Entscheidungsrahmen: kurzfristige vs. langfristige Fixes
- Sofortlösung:
try/except-Blöcke um jeden Selektor, HTTP-Statuscodes prüfen, Fehler protokollieren statt Abstürze zu riskieren - Mittelfristige Lösung: Von CSS-Selektoren auf JSON-LD-Extraktion umstellen (Methode 2)
- Langfristige Lösung: Für Analysen im großen Maßstab die offiziellen IMDb-Bulk-Datasets nutzen oder ein Tool wie Thunderbit, das die Seitenstruktur jedes Mal per KI frisch ausliest – keine Selektoren zu pflegen, die KI fängt Layoutänderungen automatisch ab
Über die 25-Ergebnisse-Grenze hinaus: IMDb-Paginierung und große Datensätze scrapen
Jedes geprüfte Konkurrenz-Tutorial scrapt genau eine Seite. Paginierung behandelt niemand. Wer aber mehr braucht als eine einzelne Liste, stößt rasch an Grenzen.
Seiten, die keine Paginierung brauchen
Die 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 vollständigen Datensatz. Paginierung ist hier überflüssig.
So funktioniert die IMDb-Suchpaginierung
IMDb-Suchseiten nutzen einen start=-URL-Parameter, der in 50er-Schritten hochgezählt wird:
https://www.imdb.com/search/title/?groups=top_1000&start=1
https://www.imdb.com/search/title/?groups=top_1000&start=51
https://www.imdb.com/search/title/?groups=top_1000&start=101
Hier eine Python-Schleife, die durch die Ergebnisse blättert:
import time
all_movies = []
for start in range(1, 1001, 50): # Blättert durch die Top 1000
url = f"https://www.imdb.com/search/title/?groups=top_1000&start={start}"
response = requests.get(url, headers=headers)
if response.status_code != 200:
print(f"Fehler bei start={start}: {response.status_code}")
break
soup = BeautifulSoup(response.text, "lxml")
# Filme mit deiner bevorzugten Methode extrahieren
# ...
print(f"Seite ab start={start} gescraped")
time.sleep(3) # Rücksichtsvoll sein — IMDb blockiert nach ~50 schnellen Anfragen
Dieses time.sleep(3) ist wichtig. Community-Berichten zufolge blockiert IMDb IPs nach etwa 50 schnellen Anfragen. Eine zufällige Verzögerung zwischen 2 und 5 Sekunden ist hier guter Stil.
Wann du Scraping ganz überspringen solltest: die offiziellen Bulk-Datasets von IMDb
Wer wirklich Daten im großen Maßstab braucht, findet bei IMDb 7 kostenlose, täglich aktualisierte TSV-Dateien auf datasets.imdbws.com:
| Datei | Inhalt | Größe |
|---|---|---|
| title.basics.tsv.gz | Titel, Typen, Genres, Laufzeit, Jahr | ~800 MB |
| title.ratings.tsv.gz | Durchschnittsbewertung, Anzahl der Stimmen | ~25 MB |
| title.crew.tsv.gz | Regisseure, Autoren | ~300 MB |
| title.principals.tsv.gz | Hauptbesetzung / Crew | ~2 GB |
| title.akas.tsv.gz | Alternative Titel nach Region | ~1,5 GB |
| title.episode.tsv.gz | TV-Episodeninfos | ~200 MB |
| name.basics.tsv.gz | Personen: Name, Geburtsjahr, bekannte Titel | ~700 MB |
Das Laden in Pandas ist unkompliziert:
ratings = pd.read_csv("title.ratings.tsv.gz", sep="\t", compression="gzip")
basics = pd.read_csv("title.basics.tsv.gz", sep="\t", compression="gzip", low_memory=False)
# Über tconst zusammenführen (IMDb-Titel-ID)
merged = basics.merge(ratings, on="tconst")
top_movies = merged[merged["titleType"] == "movie"].nlargest(250, "averageRating")
Diese Datensätze umfassen über 26 Millionen Titel. Keine Paginierung, keine Selektoren, keine 403-Fehler. Die Lizenz gilt allerdings nur für persönliche und nicht-kommerzielle Nutzung – weiterveröffentlichen oder verkaufen darfst du die Daten nicht.
Der No-Code-Kurzweg: Thunderbit übernimmt die Paginierung für dich
Wer IMDb-Daten mit Paginierung braucht, aber keine Paginierungslogik schreiben möchte, ist bei Thunderbit richtig: Das Tool beherrscht klickbasierte Paginierung und Infinite Scroll nativ. Du sagst ihm, es soll scrapen, den Rest erledigt es – inklusive des Scrollens durch lazy geladenen Inhalt.
Thunderbit für paginierte IMDb-Daten testen
IMDb mit Python scrapen: Der vollständige funktionierende Code (zum Kopieren)
Hier zwei in sich geschlossene Skripte, die du sofort ausführen kannst.
Skript A: BeautifulSoup-Methode (CSS-Selektoren)
import requests
from bs4 import BeautifulSoup
import pandas as pd
url = "https://www.imdb.com/chart/top/"
headers = {
"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",
"Accept-Language": "en-US,en;q=0.9"
}
response = requests.get(url, headers=headers)
if response.status_code != 200:
print(f"Fehler: {response.status_code}")
exit()
soup = BeautifulSoup(response.text, "lxml")
movie_items = soup.select("li.ipc-metadata-list-summary-item")
movies = []
for item in movie_items:
try:
title = item.select_one("h3.ipc-title__text")
year = item.select_one("span.cli-title-metadata-item")
rating = item.select_one("span.ipc-rating-star--rating")
movies.append({
"title": title.text.strip() if title else "N/A",
"year": year.text.strip() if year else "N/A",
"rating": rating.text.strip() if rating else "N/A",
})
except Exception as e:
print(f"Film wegen Fehler übersprungen: {e}")
df = pd.DataFrame(movies)
df.to_csv("imdb_top250_bs4.csv", index=False)
print(f"{len(df)} Filme gespeichert")
print(df.head())
Skript B: JSON-LD-Methode (empfohlen)
import requests
from bs4 import BeautifulSoup
import json
import pandas as pd
url = "https://www.imdb.com/chart/top/"
headers = {
"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",
"Accept-Language": "en-US,en;q=0.9"
}
response = requests.get(url, headers=headers)
if response.status_code != 200:
print(f"Fehler: {response.status_code}")
exit()
soup = BeautifulSoup(response.text, "lxml")
script_tag = soup.find("script", {"type": "application/ld+json"})
if not script_tag:
print("Keine JSON-LD-Daten gefunden")
exit()
data = json.loads(script_tag.string)
movies = []
for item in data.get("itemListElement", []):
movie = item.get("item", {})
rating_info = movie.get("aggregateRating", {})
directors = movie.get("director", [])
director_names = ", ".join(
d.get("name", "") for d in (directors if isinstance(directors, list) else [directors])
)
movies.append({
"rank": item.get("position"),
"title": movie.get("name"),
"url": movie.get("url"),
"rating": rating_info.get("ratingValue"),
"votes": rating_info.get("ratingCount"),
"year": movie.get("datePublished", "")[:4],
"genre": ", ".join(movie.get("genre", [])),
"director": director_names,
"description": movie.get("description"),
})
df = pd.DataFrame(movies)
df.to_csv("imdb_top250_jsonld.csv", index=False)
print(f"{len(df)} Filme gespeichert")
print(df.head())
Beide Skripte bringen Fehlerbehandlung mit und erzeugen saubere CSV-Ausgaben. Skript B liefert dir die reichhaltigeren Daten – Regisseur, Beschreibung, URL – und steckt Layoutänderungen besser weg.
Wie du IMDb ohne Code scrapen kannst (mit Thunderbit)
Nicht jeder braucht oder will Python schreiben. Vielleicht bist du Operations-Analyst und brauchst einfach die bestbewerteten Filme dieser Woche in einer Tabelle. Vielleicht bist du Content-Stratege und willst Genre-Trends über mehrere Jahre vergleichen. In solchen Fällen ist ein eigener Scraper schlicht überdimensioniert.
So bekommst du dieselben Daten mit Thunderbit:
Bevor du startest:
- Schwierigkeit: Anfänger
- Benötigte Zeit: ca. 2 Minuten
- Was du brauchst: Chrome-Browser, Thunderbit Chrome Extension (Free-Tier reicht)
Schritt 1: Öffne die IMDb-Seite, die du scrapen möchtest. Ruf die IMDb Top 250 (oder eine andere IMDb-Liste/Suchseite) in Chrome auf.
Schritt 2: Klicke in der Thunderbit-Seitenleiste auf „KI-Felder vorschlagen“. Die KI scannt die Seite und empfiehlt Spalten – typischerweise Titel, Jahr, Bewertung, Genre und je nach Seite noch ein paar mehr. Du bekommst eine Vorschautabelle mit den vorgeschlagenen Feldern.
Schritt 3: Felder bei Bedarf anpassen. Entferne Spalten, die du nicht brauchst, oder ergänze eigene über „+ Spalte hinzufügen“, indem du in normalem Englisch beschreibst, was du willst (z. B. „Name des Regisseurs“ oder „Anzahl der Stimmen“).
Schritt 4: Auf „Scrape“ klicken. Thunderbit extrahiert die Daten. Bei Seiten mit Infinite Scroll oder Paginierung ü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 wenigen Sekunden am Ziel.
Der entscheidende Vorteil ist nicht nur die Bequemlichkeit – Thunderbits KI liest die Seitenstruktur jedes Mal frisch neu. Stellt IMDb das Layout um (und das wird passieren), passt sich die KI an. Keine Selektoren zu aktualisieren, kein Code zu reparieren. Für jeden, der schon einmal um 2 Uhr morgens kurz vor Deadline von einem kaputten Scraper im Stich gelassen wurde, ist das viel wert.
Thunderbit beherrscht auch das Scrapen von Unterseiten – du klickst in jede Film-Detailseite hinein und reicherst deine Tabelle mit Besetzung, Regisseur, Laufzeit und weiteren Feldern an, die auf der Listen-Seite nicht zu sehen sind. Wenn du das in Aktion erleben willst, schau auf dem Thunderbit YouTube-Kanal vorbei.
Ist es legal, IMDb zu scrapen? Das musst du wissen
In Foren wird genau das offen gefragt: „Ist so etwas legal?... IMDb will nicht, dass Leute ihre Website scrapen.“ Eine berechtigte Frage – und kein Konkurrenzartikel geht darauf ein.
IMDb-robots.txt: Die Top-250-Ansicht (/chart/top/), einzelne Titelseiten (/title/ttXXXXXXX/) und Namensseiten (/name/nmXXXXXXX/) sind in robots.txt NICHT gesperrt. Zu den blockierten Pfaden zählen unter anderem /find, /_json/*, /search/name-text, /user/ur*/ratings und diverse AJAX-Endpunkte. Eine Crawl-delay-Anweisung ist nicht hinterlegt.
Imdbs Nutzungsbedingungen: Die einschlägige Klausel lautet: „You may not use data mining, robots, screen scraping, or similar data gathering and extraction tools on this site, except with our express written consent.“ Eine weitere Klausel untersagt den Wiederverkauf oder die kommerzielle Nutzung gescrapter Daten.
Was das praktisch bedeutet: Jüngere Gerichtsentscheidungen aus 2024 (Meta v. Bright Data, X Corp v. Bright Data) kamen zu dem Schluss, dass Nutzungsbedingungen für Nutzer, die ihnen nie zugestimmt haben, womöglich nicht bindend sind – scrapest du öffentlich zugängliche Daten ohne Login, ist die Durchsetzbarkeit der ToS juristisch umstritten. Dieser Rechtsbereich ist allerdings weiter in Bewegung.
Sichere Alternativen: Die offiziellen herunterladbaren IMDb-Datensätze sind ausdrücklich für die persönliche und nicht-kommerzielle Nutzung freigegeben. Die TMDb-API lässt sich mit einem kostenlosen API-Key großzügig nutzen. Beides sind solide Optionen, wenn du ganz auf der sicheren Seite bleiben willst.
Praktische Empfehlung: Wenn du trotzdem scrapen willst, arbeite mit einer respektvollen Abrufrate (time.sleep(3) zwischen Anfragen), setze ordentliche Header und meide Pfade, die in robots.txt gesperrt sind. Für kommerzielle Projekte hol dir juristischen Rat oder nutze gleich die offiziellen Datensätze bzw. die API.
Die rechtlichen Auswirkungen von Web-Scraping haben wir 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–12 Monate kaputtgeht. Fehlerbehandlung immer einbauen.
- JSON-LD-Extraktion: Der Ansatz, den ich für jedes laufende Python-Projekt empfehlen würde. Folgt dem Schema.org-Standard, ändert sich viel seltener als CSS-Klassen und liefert saubere strukturierte Daten ohne JavaScript-Rendering.
__NEXT_DATA__-JSON: Ergänzend nutzen, wenn du auf einzelnen Titelseiten reichere Daten brauchst (Laufzeit, vollständige Besetzung, Handlung, Posterbilder).- IMDb Official Datasets: Die beste Wahl für Analysen im großen Maßstab. 26M+ Titel, täglich aktualisiert, kein Scraping nötig. Nur für persönliche/nicht-kommerzielle Nutzung.
- Thunderbit: Die beste Wahl für Nicht-Coder oder alle, die schnell Daten brauchen, ohne Code zu pflegen. Die KI fängt Layoutänderungen ab, übernimmt die Paginierung und exportiert nach Excel/Sheets/Airtable/Notion.
Setz dir ein Lesezeichen auf diesen Leitfaden – ich aktualisiere ihn, sobald sich die Struktur von IMDb erneut ändert. Und wenn du den Code ganz umgehen willst, probier Thunderbits kostenlosen Tarif aus und sieh, wie schnell du von einer IMDb-Seite zu einer sauberen Tabelle kommst. Wer auch mit anderen Websites arbeitet, findet im Leitfaden zum Scrapen von Daten von Websites in Excel den breiteren Workflow.
KI-Web-Scraper für IMDb und mehr testen Get Started Free
FAQs
Ist es legal, IMDb zu scrapen?
Die Nutzungsbedingungen von IMDb verbieten Scraping ohne Zustimmung, doch die rechtliche Durchsetzbarkeit solcher Bedingungen bei öffentlich zugänglichen Daten ist nach jüngeren Gerichtsentscheidungen aus 2024 juristisch umstritten. Die sichersten Optionen sind die offiziellen kostenlosen IMDb-Datensätze (persönliche/nicht-kommerzielle Nutzung) oder die TMDb-API (kostenloser Key). Wenn du trotzdem scrapest, halte dich an robots.txt, lege angemessene Pausen zwischen den Anfragen ein und meide gesperrte Pfade. Für kommerzielle Nutzung solltest du einen Rechtsanwalt konsultieren.
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 Klassen mit dem Präfix ipc- anpassen. Prüfe außerdem, ob du einen korrekten User-Agent-Header sendest, denn ein fehlender Header löst einen 403-Fehler aus, der wie leere Ergebnisse 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 Paginierung nötig. Für Suchergebnisse nutzt du den URL-Parameter start= (in 50er-Schritten), um durch die Ergebnisse zu blättern. Beispiel: start=1, start=51, start=101. Zwischen den Anfragen time.sleep(3) einbauen, damit du nicht blockiert wirst. Alternativ enthalten die offiziellen IMDb-Datensätze auf datasets.imdbws.com über 26 Millionen Titel ganz ohne Paginierung.
Was ist __NEXT_DATA__ und warum sollte ich es zum Scrapen von IMDb verwenden?
__NEXT_DATA__ ist ein JSON-Objekt, das in einem <script id="__NEXT_DATA__">-Tag auf den React-/Next.js-Seiten von IMDb 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 statt des visuellen Layouts abbildet, ist es robuster gegenüber 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) Lade die offiziellen IMDb-Bulk-Datasets herunter – 7 TSV-Dateien mit über 26 Millionen Titeln, täglich aktualisiert, kostenlos für nicht-kommerzielle Nutzung. (2) Nutze Thunderbits KI-Web-Scraper, der die IMDb-Seite liest, die Extraktionsfelder automatisch vorschlägt und in zwei Klicks nach Excel, Google Sheets oder CSV exportiert – ohne Code und ohne zu pflegende Selektoren.
Mehr erfahren
