IMDb mit Python scrapen: Code, der wirklich funktioniert

Wenn du kürzlich nach „IMDb mit Python scrapen“ gesucht hast, ist dir wahrscheinlich etwas aufgefallen: Die meisten Tutorials, die du findest, sind kaputt. Nicht nur „leicht veraltet“ – eher im Sinne von „liefert null Ergebnisse und eine Wand aus NoneType-Fehlern“ kaputt.

Ich habe in den letzten Wochen jedes größere IMDb-Scraping-Tutorial getestet, das ich finden konnte — GeeksforGeeks, Medium, freeCodeCamp, Kaggle-Notebooks, alles dabei. Von , die für IMDb-Scraping getaggt sind, verweisen die allermeisten auf CSS-Selektoren (td.titleColumn, td.ratingColumn), die es seit dem Redesign der Top-250-Seite im Juni 2023 nicht mehr gibt. Das Ergebnis? Foren voller Entwickler, die fragen: „Warum gibt mein Code leere Ergebnisse zurück?“, und Maintainer beliebter Bibliotheken wie : „Viel können wir nicht tun, außer jeden Parser zu reparieren.“ Dieser Leitfaden zeigt zwei Python-Methoden, die derzeit wirklich funktionieren, erklärt den Umgang mit Paginierung und typischen Fehlern, wann Python nicht einmal das richtige Werkzeug ist, und wie du deinen Scraper so absicherst, dass er nicht auf dem Friedhof landet.

Was bedeutet es, IMDb mit Python zu scrapen?

Web-Scraping ist der Prozess, Daten programmgesteuert aus Webseiten zu extrahieren — statt manuell zu kopieren und einzufügen, schreibst du ein Skript, das das für dich erledigt. Wenn wir von „IMDb scrapen“ sprechen, meinen wir, strukturierte Filmdaten (Titel, Bewertungen, Genres, Besetzung, Laufzeit, Stimmenzahlen) mit Python aus den IMDb-Webseiten zu ziehen.

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 auch Selenium oder Playwright für Seiten, die JavaScript-Rendering brauchen, aber wie du gleich sehen wirst, gibt es schnellere Wege.

Ein wichtiger Hinweis: Alles in diesem Leitfaden wurde gegen die aktuelle Seitenstruktur von IMDb Mitte 2025 überprüft. IMDb verändert Dinge ungefähr alle 6–12 Monate, also können sich einige Selektoren verschoben haben, wenn du das hier 2027 liest. (Ich erkläre auch, wie du damit umgehst.)

Warum IMDb mit Python scrapen? Praxisbeispiele aus der echten Welt

Bevor du auch nur eine Zeile Code schreibst: Was würdest du mit IMDb-Daten eigentlich tun? Die Antwort hängt davon ab, wer du bist.

Der IMDb-Bewertungsdatensatz ist eines der am häufigsten verwendeten NLP-Benchmarks der Welt — die grundlegende Arbeit von Maas et al. (2011) hat inzwischen gesammelt, und der Datensatz ist in TensorFlow, Keras und PyTorch integriert. Auf Hugging Face wird der Datensatz stanfordnlp/imdb monatlich 213.321 Mal heruntergeladen und wurde zum Training von über 1.500 Modellen verwendet. Wenn du also im Machine Learning arbeitest, kennst du IMDb-Daten vermutlich schon.

Die Anwendungsfälle gehen aber weit über die Wissenschaft hinaus:

Allein der Filmtourismus-Markt hat 2025 ein geschätztes Volumen 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 vielen Branchen in echte Entscheidungen ein.

Deine Optionen, um an IMDb-Daten zu kommen (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 fragen, ob Python-Scraping für deine Situation überhaupt der richtige Ansatz ist.

Hier ist die komplette Landschaft:

Ein paar Hinweise zu diesen Optionen: Cinemagoer hatte seit Mai 2023 kein PyPI-Release mehr, und die meisten Parser sind nach dem IMDb-Redesign im Juni 2025 kaputtgegangen — für den Produktionseinsatz würde ich es derzeit nicht empfehlen. TMDb ist ausgezeichnet, verwendet aber sein eigenes Bewertungssystem und nicht IMDb-Bewertungen. Und die offizielle Enterprise-API von IMDb kostet über über AWS Data Exchange — also für die meisten von uns keine Option.

Für Leser, die überhaupt keinen Code schreiben wollen, liest die IMDb-Seite aus, schlägt Extraktionsfelder automatisch vor (Titel, Bewertung, Jahr, Genre) und exportiert in zwei Klicks nach Excel, Google Sheets, Airtable oder Notion. Die KI passt sich an, wenn IMDb das Layout ändert, sodass es keine Selektoren gibt, die du pflegen musst. Mehr dazu später.

Für alle, die Python schreiben möchten, gibt es hier zwei funktionierende Methoden.

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

Das ist der klassische Ansatz, den du in den meisten Tutorials findest. Er funktioniert, aber ich sage es ganz offen: Er ist die fragilste Methode von allen, die ich hier behandle. Die CSS-Klassennamen von IMDb werden automatisch generiert und ändern sich bei Redesigns. Trotzdem ist das der beste Weg, um die Grundlagen des Web-Scrapings zu lernen.

Schritt 1: Deine Python-Bibliotheken installieren und importieren

Du brauchst vier Pakete:

1pip install requests beautifulsoup4 pandas lxml

Das macht jedes einzelne:

• 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 nach CSV/Excel
• lxml — ein schneller HTML-Parser (BeautifulSoup kann ihn als Backend nutzen)

Dein Import-Block:

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

Schritt 2: Eine HTTP-Anfrage an IMDb senden

Hier stoßen die meisten Einsteiger auf ihre erste Hürde. IMDb blockiert Anfragen ohne einen passenden User-Agent-Header — du bekommst dann einen 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 abgerufen werden: {response.status_code}")
9else:
10    print("Seite erfolgreich abgerufen")

Auch der Accept-Language-Header ist wichtig — ohne ihn kann IMDb Inhalte in einer anderen Sprache zurückgeben, abhängig von der Geolokalisierung deiner IP.

Schritt 3: Das HTML mit BeautifulSoup parsen

Sobald du das HTML hast, erstellst du ein BeautifulSoup-Objekt und beginnst, nach den richtigen Elementen zu suchen. Ö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 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

Achtung: Diese Klassen mit dem Präfix ipc- werden vom Komponenten-System von IMDb generiert. 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 baue try/except-Fehlerbehandlung ein. Keine der Konkurrenz-Anleitungen, die ich geprüft habe, macht das — und genau deshalb bricht ihr Code lautlos, 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 des 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 hängt an CSS-Selektoren, die morgen schon kaputt sein können — und genau deshalb kommen wir zur Methode, die ich tatsächlich empfehle.

Methode 2: Der JSON-LD-Trick — HTML-Parsing komplett überspringen

Das ist die Technik, die kein Konkurrenzartikel behandelt, und die ich für jedes ernsthafte Projekt verwenden würde. IMDb bettet 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 viel seltener als CSS-Klassennamen.

Der Apify IMDb Scraper, ein produktionsreifes Tool, verwendet die Prioritätsreihenfolge bei der Extraktion: „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-Komponentensystem von IMDb automatisch erzeugt und ändern sich mit jedem Redesign. Das JSON-LD-Schema repräsentiert das eigentliche Datenmodell, nicht die Darstellungsschicht. Das ist ungefähr so, als würdest du das Inhaltsverzeichnis eines Buches lesen, statt Kapitel über ihre Schriftgröße zu identifizieren.

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

Schritt 1: Seite abrufen

Wie zuvor — requests mit einem passenden User-Agent-Header verwenden.

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: Den JSON-LD-Script-Tag finden

1script_tag = soup.find("script", {"type": "application/ld+json"})
2if not script_tag:
3    print("Auf dieser Seite wurde kein JSON-LD 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 parsen

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, werden sie viel seltener geändert 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 außerdem ein __NEXT_DATA__-JSON-Objekt ein. Das sind die Daten, die React zum Hydrieren der Seite verwendet — sie können nicht entfernt werden, ohne die Website kaputt zu machen.

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 es behebst

Das ist der mit Abstand am häufigsten gemeldete Schmerzpunkt in allen IMDb-Scraping-Foren, die ich geprüft habe. Nutzer schreiben: „Ein Teil des Codes ist wegen UI-Änderungen kaputtgegangen“ und „Funktioniert 2024 nicht!“ — und die Antwort ist meist Schweigen oder „Probier Selenium.“

Die Ursache ist Imdbs laufende Migration zu einem React-/Next.js-Frontend. Hier ist die Zeitleiste der wichtigsten Breaking Changes:

Das ist ungefähr alle 6–12 Monate eine größere Breaking Change. 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 gesuchte 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 erforderlich.

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. Verwende requests.Session() für Connection Pooling.

Nur 25 Ergebnisse zurückgegeben

IMDb-Suchseiten und „Most Popular“-Listen verwenden Lazy Loading — sie rendern anfangs nur etwa 25 Ergebnisse und laden beim Scrollen per AJAX weitere nach.

Lösung: URL-Parameter-Paginierung verwenden (im nächsten Abschnitt beschrieben) oder zur Top-250-Seite wechseln, 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 (z. B. h1[data-testid="hero-title-block__title"]) statt automatisch generierter Klassennamen. Noch besser: nutze JSON-LD.

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 provozieren
• 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 nutzen oder ein Tool wie , das die Seitenstruktur mit KI jedes Mal frisch neu liest — keine Selektoren zu pflegen, die KI passt sich Layoutänderungen automatisch an

Über die 25-Ergebnisse-Grenze hinaus: IMDb-Paginierung und große Datensätze scrapen

Jedes Konkurrenz-Tutorial, das ich geprüft habe, scraped genau eine Seite. Niemand behandelt Paginierung. Wenn du aber mehr als nur eine Liste brauchst, stößt du schnell an Grenzen.

Seiten, die keine Paginierung 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 vollständigen Datensatz. Keine Paginierung nötig.

So funktioniert die IMDb-Suchpaginierung

IMDb-Suchseiten verwenden einen start=-URL-Parameter, der in 50er-Schritten hochgezählt 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 blättert:

1import time
2all_movies = []
3for start in range(1, 1001, 50):  # Blättert durch die 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 ab start={start} gescraped")
13    time.sleep(3)  # Rücksichtsvoll sein — IMDb blockiert nach ~50 schnellen Anfragen

Dieses time.sleep(3) ist wichtig. Community-Berichte deuten darauf hin, dass IMDb IPs nach ungefähr 50 schnellen Anfragen blockiert. Eine zufällige Verzögerung zwischen 2 und 5 Sekunden ist gute Praxis.

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

Wenn du wirklich Daten im großen Maßstab brauchst, stellt IMDb 7 kostenlose TSV-Dateien auf bereit, die täglich aktualisiert werden:

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

Diese Datensätze decken über 26 Millionen Titel ab. Keine Paginierung, 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.

Der No-Code-Kurzweg: Thunderbit übernimmt die Paginierung für dich

Für Leser, die IMDb-Daten mit Paginierung brauchen, aber keine Paginierungslogik schreiben möchten, unterstützt sowohl klickbasierte Paginierung als auch Infinite Scroll nativ. Du sagst ihm, dass es scrapen soll, den Rest erledigt es — einschließlich des Scrollens durch lazy geladenen Inhalt.

IMDb mit Python scrapen: Der vollständige funktionierende Code (zum Kopieren)

Hier sind zwei in sich geschlossene 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 wegen Fehler übersprungen: {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 reichhaltigere Daten — Regisseur, Beschreibung, URL — und ist robuster gegenüber Layoutänderungen.

Wie du IMDb ohne Code scrapen kannst (mit Thunderbit)

Nicht jeder braucht oder möchte Python schreiben. Vielleicht bist du Operations-Analyst und brauchst nur die bestbewerteten Filme dieser Woche in einer Tabelle. Vielleicht bist du Content-Stratege und willst Genre-Trends über Jahre vergleichen. In solchen Fällen ist es überdimensioniert, einen Scraper zu schreiben.

So bekommst du dieselben Daten mit :

Bevor du startest:

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

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

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 einige weitere. Du siehst eine Vorschautabelle mit den vorgeschlagenen Feldern.

Schritt 3: Felder bei Bedarf anpassen. Entferne Spalten, die du nicht brauchst, oder füge eigene hinzu, indem du auf „+ Spalte hinzufügen“ klickst und in normalem Englisch beschreibst, was du möchtest (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. Wenn IMDb sein Layout ändert (und das wird passieren), passt sich die KI an. Keine Selektoren, die du aktualisieren musst, kein Code, den du reparieren musst. Für alle, die schon einmal um 2 Uhr morgens vor einer Deadline von einem kaputten Scraper verbrannt wurden, ist das enorm wertvoll.

Thunderbit unterstützt auch das Scrapen von Unterseiten — du kannst in jede Film-Detailseite hineinklicken und deine Tabelle mit Besetzung, Regisseur, Laufzeit und anderen Feldern anreichern, die auf der Listen-Seite nicht sichtbar sind. Wenn du es in Aktion sehen willst, schau dir den an.

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

Nutzer fragen das in Foren ausdrücklich: „Ist so etwas legal?... IMDb will nicht, dass Leute ihre Website scrapen.“ Das ist 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 blockiert. Blockierte Pfade sind unter anderem /find, /_json/*, /search/name-text, /user/ur*/ratings und verschiedene AJAX-Endpunkte. Eine Crawl-delay-Anweisung ist nicht angegeben.

Imdbs Nutzungsbedingungen: Die relevante 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 zusätzliche Klausel verbietet den Wiederverkauf oder die kommerzielle Nutzung gescrapter Daten.

Was das praktisch bedeutet: Jüngste Gerichtsentscheidungen aus 2024 (Meta v. Bright Data, X Corp v. Bright Data) kamen zu dem Schluss, dass Nutzungsbedingungen möglicherweise nicht bindend sind für Nutzer, die ihnen nie zugestimmt haben — wenn du öffentlich zugängliche Daten ohne Login scrapest, ist die Durchsetzbarkeit der ToS juristisch umstritten. Aber dieser Rechtsbereich entwickelt sich weiter.

Sichere Alternativen: Die sind ausdrücklich für die persönliche und nicht-kommerzielle Nutzung freigegeben. Die TMDb-API ist mit einem kostenlosen API-Key großzügig nutzbar. Beides sind solide Optionen, wenn du eindeutig 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 greife nicht auf Pfade zu, die in robots.txt blockiert sind. Für kommerzielle Projekte solltest du rechtlichen Rat einholen oder die offiziellen Datensätze bzw. die API verwenden.

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–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 verwenden, 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.
• : Die beste Wahl für Nicht-Coder oder alle, die schnell Daten brauchen, ohne Code zu pflegen. KI passt sich Layoutänderungen an, übernimmt Paginierung und exportiert nach Excel/Sheets/Airtable/Notion.

Setz dir ein Lesezeichen für diesen Leitfaden — ich aktualisiere ihn, sobald sich die Struktur von IMDb wieder ändert. Und wenn du den Code ganz überspringen willst, aus und sieh, wie schnell du von einer IMDb-Seite zu einer sauberen Tabelle kommst. Wenn du auch mit anderen Websites arbeitest, deckt unser Leitfaden zum den breiteren Workflow ab.

FAQs

Ist es legal, IMDb zu scrapen?

Die Nutzungsbedingungen von IMDb verbieten Scraping ohne Zustimmung, aber die rechtliche Durchsetzbarkeit solcher Bedingungen bei öffentlich zugänglichen Daten ist nach jüngsten Gerichtsentscheidungen aus 2024 juristisch umstritten. Die sichersten Optionen sind die (persönliche/nicht-kommerzielle Nutzung) oder die TMDb-API (kostenloser Key). Wenn du trotzdem scrapest, halte dich an robots.txt, verwende angemessene Pausen zwischen Anfragen und vermeide blockierte 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 ist, auf JSON-LD-Extraktion umzusteigen (den <script type="application/ld+json">-Tag parsen) oder die Selektoren auf die aktuellen Klassen mit dem Präfix ipc- anzupassen. 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 wirken 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 verwendest du den URL-Parameter start= (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, damit du nicht blockiert wirst. Alternativ enthalten die offiziellen IMDb-Datensätze auf über 26 Millionen Titel 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, die React zum Rendern der Seite nutzt — Titel, Bewertungen, Besetzung, Genres, Laufzeit und mehr. Weil es das zugrunde liegende Datenmodell statt des visuellen Layouts repräsentiert, ist es robuster gegenüber UI-Redesigns als CSS-Selektoren. Verwende es zusammen mit JSON-LD für den robustesten Extraktionsansatz.

Kann ich IMDb ohne Programmieren scrapen?

Ja. Zwei Hauptoptionen: (1) Lade die herunter — 7 TSV-Dateien mit über 26 Millionen Titeln, täglich aktualisiert, kostenlos für nicht-kommerzielle Nutzung. (2) Nutze , der die IMDb-Seite liest, Extraktionsfelder automatisch vorschlägt und in zwei Klicks nach Excel, Google Sheets oder CSV exportiert — ohne Code und ohne zu pflegende Selektoren.

Mehr erfahren