IMDb scrapen met Python: code die echt werkt

Als je de laatste tijd hebt gezocht op "IMDb scrapen met Python", is je waarschijnlijk iets opgevallen: veel van de tutorials die je vindt, werken niet meer. Niet een beetje verouderd — eerder zo kapot dat ze nul resultaten teruggeven en je overspoelen met NoneType-fouten.

Ik heb de afgelopen weken elke grote IMDb-scrapingtutorial getest die ik kon vinden — GeeksforGeeks, Medium, freeCodeCamp, Kaggle-notebooks, noem maar op. Van de die zijn getagd voor IMDb-scraping, verwijst het overgrote deel nog naar CSS-selectors (td.titleColumn, td.ratingColumn) die sinds juni 2023 niet meer bestaan, toen IMDb de Top 250-pagina opnieuw ontwierp. Het gevolg? Forums vol ontwikkelaars die vragen: "waarom geeft mijn code lege resultaten?" en beheerders van populaire libraries zoals "We kunnen er niet veel aan doen, behalve elke parser repareren." Deze gids behandelt twee Python-methodes die nu echt werken, hoe je omgaat met paginering en veelvoorkomende fouten, wanneer Python eigenlijk niet de juiste tool is, en hoe je je scraper toekomstbestendig maakt zodat hij niet eindigt op de digitale begraafplaats.

Wat betekent IMDb scrapen met Python?

Webscraping is het automatisch ophalen van gegevens van webpagina's — in plaats van handmatig kopiëren en plakken, schrijf je een script dat het werk voor je doet. Wanneer we het hebben over "IMDb scrapen", bedoelen we het verzamelen van gestructureerde filmdata (titels, beoordelingen, genres, cast, speelduur, stemtotalen) van IMDb-webpagina's met Python.

De gebruikelijke Python-stack hiervoor bestaat uit drie libraries: requests (om de webpagina op te halen), BeautifulSoup (om de HTML te parsen en de data te vinden) en pandas (om de resultaten te ordenen en exporteren). Sommige tutorials gebruiken ook Selenium of Playwright voor pagina's die JavaScript-rendering nodig hebben, maar zoals je zult zien, zijn er snellere alternatieven.

Een belangrijke kanttekening: alles in deze gids is getest tegen de huidige paginastuctuur van IMDb, midden 2025. IMDb verandert ongeveer elke 6–12 maanden iets, dus als je dit in 2027 leest, kunnen sommige selectors zijn verschoven. (Ik leg ook uit hoe je daarmee omgaat.)

Waarom IMDb scrapen met Python? Praktische toepassingen

Voordat je ook maar één regel code schrijft: wat ga je eigenlijk doen met IMDb-data? Het antwoord hangt af van wie je bent.

De IMDb-reviewdataset is een van de meest gebruikte NLP-benchmarks ter wereld — het baanbrekende paper van Maas et al. (2011) heeft al verzameld, en de dataset is ingebouwd in TensorFlow, Keras en PyTorch. Op Hugging Face krijgt de stanfordnlp/imdb-dataset 213.321 downloads per maand en is hij gebruikt om meer dan 1.500 modellen te trainen. Dus als je met machine learning werkt, ben je waarschijnlijk al bekend met IMDb-data.

Maar de toepassingen gaan veel verder dan de academische wereld:

Alleen al de markt voor filmtourisme wordt in 2025 wereldwijd geschat op . Netflix gaf in 2024 ruim $17 miljard uit aan content, waarbij werd aangestuurd door gepersonaliseerde aanbevelingen. Kortom: IMDb-data voedt echte beslissingen in allerlei sectoren.

Je opties om IMDb-data te krijgen (voordat je code schrijft)

Dit is het gedeelte dat de meeste tutorials volledig overslaan. Ze springen direct naar pip install beautifulsoup4 zonder zich af te vragen of Python-scraping in jouw situatie überhaupt de juiste aanpak is.

Hier is het volledige landschap:

Een paar opmerkingen bij deze opties. Cinemagoer heeft sinds mei 2023 geen PyPI-release meer gehad en veel parsers gingen kapot na de IMDb-redesign van juni 2025 — voor productiegebruik zou ik het nu niet aanraden. TMDb is uitstekend, maar gebruikt een eigen ratingsysteem, niet dat van IMDb. En de officiële enterprise API van IMDb kost via AWS Data Exchange , dus dat is voor de meesten van ons geen realistische optie.

Voor lezers die helemaal geen code willen schrijven, leest de IMDb-pagina, stelt automatisch extractievelden voor (titel, rating, jaar, genre) en exporteert in twee klikken naar Excel, Google Sheets, Airtable of Notion. De AI past zich aan wanneer IMDb de lay-out wijzigt, dus er zijn geen selectors die je moet onderhouden. Daarover later meer.

Voor wie wél Python wil gebruiken: hier zijn twee methodes die werken.

Methode 1: IMDb scrapen met Python via BeautifulSoup (traditionele aanpak)

Dit is de klassieke aanpak die je in de meeste tutorials tegenkomt. Het werkt, maar ik wil meteen eerlijk zijn: dit is de fragielste methode van alles wat ik hier bespreek. De CSS-klassen van IMDb worden automatisch gegenereerd en veranderen bij redesigns. Toch is dit wel de beste manier om de basisprincipes van webscraping te leren.

Stap 1: Installeer en importeer je Python-libraries

Je hebt vier pakketten nodig:

1pip install requests beautifulsoup4 pandas lxml

Dit doet elk pakket:

• requests — verstuurt HTTP-verzoeken om de webpagina op te halen
• beautifulsoup4 — parseert de HTML zodat je specifieke elementen kunt zoeken
• pandas — zet de geëxtraheerde data in tabellen en exporteert naar CSV/Excel
• lxml — een snelle HTML-parser (BeautifulSoup kan het als backend gebruiken)

Je importblok:

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

Stap 2: Stuur een HTTP-verzoek naar IMDb

Hier lopen veel beginners meteen vast. IMDb blokkeert verzoeken zonder een correcte User-Agent header — je krijgt dan een 403 Forbidden-fout. De standaard user-agent van Python Requests (python-requests/2.31.0) wordt direct herkend.

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"Kon pagina niet ophalen: {response.status_code}")
9else:
10    print("Pagina succesvol opgehaald")

De Accept-Language header is ook belangrijk — zonder die header kan IMDb content in een andere taal teruggeven, afhankelijk van de geolocatie van je IP-adres.

Stap 3: Parse de HTML met BeautifulSoup

Zodra je de HTML hebt, maak je een BeautifulSoup-object aan en ga je op zoek naar de juiste elementen. Open de IMDb Top 250-pagina in Chrome, klik met rechts op een filmtitel en kies "Inspecteren" om de onderliggende HTML-structuur te bekijken.

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

Vanaf midden 2025 gebruikt de Top 250-pagina deze selectors:

• Filmcontainer: li.ipc-metadata-list-summary-item
• Titel: h3.ipc-title__text
• Jaar: span.cli-title-metadata-item (eerste span)
• Rating: span.ipc-rating-star--rating

Let op: die klasse-namen met ipc- worden automatisch gegenereerd door IMDb's componentsysteem. Ze zijn stabiel gebleven sinds de redesign van juni 2023, maar er is geen garantie dat dat zo blijft.

Stap 4: Filmdata extraheren (titel, jaar, rating)

Hier wijk ik af van de meeste tutorials: ik voeg try/except-foutafhandeling toe. Geen van de concurrerende gidsen die ik heb bekeken doet dat, en precies daarom breekt hun code stilletjes zodra een selector verandert.

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"Fout bij het parsen van film: {e}")
18        continue
19print(f"{len(movies)} films geëxtraheerd")

Stap 5: Sla op als CSV of Excel met Pandas

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

Voorbeeldoutput:

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

Dat werkt. Maar het hangt aan CSS-selectors die morgen al stuk kunnen gaan — en dat brengt ons bij de aanpak die ik echt aanbeveel.

Methode 2: De JSON-LD-truc — sla HTML-parsing volledig over

Dit is de techniek die geen enkel concurrerend artikel behandelt, en het is degene die ik voor elk serieus project zou gebruiken. IMDb verwerkt gestructureerde data als (JavaScript Object Notation for Linked Data) in <script type="application/ld+json">-tags op elke pagina. Deze data volgt de Schema.org-standaard, wordt door Google gebruikt voor rich search results en verandert veel minder vaak dan CSS-klassen.

De Apify IMDb Scraper, een tool van productiekwaliteit, gebruikt de volgorde: "JSON-LD > NEXT_DATA > DOM" als prioriteit voor extractie. Die volgorde zou ik ook aanraden.

Waarom JSON-LD betrouwbaarder is dan CSS-selectors

CSS-klassen zoals ipc-metadata-list-summary-item worden automatisch gegenereerd door IMDb’s React-componentsysteem en veranderen bij elke redesign. Het JSON-LD-schema representeert het echte datamodel, niet de visuele weergave. Het verschil is alsof je de inhoudsopgave van een boek leest versus hoofdstukken proberen te herkennen aan de lettergrootte.

Stap voor stap: IMDb-data extraheren uit JSON-LD

Stap 1: Haal de pagina op

Zoals eerder: gebruik requests met een correcte 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")

Stap 2: Zoek de JSON-LD-script-tag

1script_tag = soup.find("script", {"type": "application/ld+json"})
2if not script_tag:
3    print("Geen JSON-LD gevonden op deze pagina")
4else:
5    data = json.loads(script_tag.string)
6    print(f"JSON-LD gevonden met type: {data.get('@type', 'onbekend')}")

Stap 3: Parse de gestructureerde data

Op de Top 250-pagina bevat de JSON-LD een itemListElement-array met alle 250 films. Elk item bevat positie, naam, URL, aggregateRating, datePublished, genre, description, director en actor-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    })

Stap 4: Exporteer naar CSV

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

Voorbeeldoutput:

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 films. Netjes, gestructureerd, zonder CSS-selector-gepruts. En omdat deze data de Schema.org-standaard volgt (waar Google op leunt voor zoekresultaten), is het veel minder waarschijnlijk dat het verandert dan de visuele lay-out.

Bonus: __NEXT_DATA__ voor individuele film-pagina's

Voor rijkere data van individuele titelpagina's (speelduur, volledige cast, plotsamenvatting, posterafbeeldingen) verwerkt IMDb ook een __NEXT_DATA__ JSON-object. Dit is de data die React gebruikt om de pagina te hydrateren — die kun je niet zomaar verwijderen zonder de site te breken.

1# Op een individuele film-pagina zoals /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"]

Gebruik JSON-LD voor overzichts- en lijstenpagina's, en __NEXT_DATA__ voor individuele titelpagina's. Dat is de productieklare aanpak.

Waarom je IMDb-scraper blijft breken (en hoe je dat oplost)

Dit is veruit het meest gemelde probleem in elk IMDb-scrapingforum dat ik heb bekeken. Gebruikers schrijven: "Sommige code is stuk gegaan door UI-wijzigingen" en "Werkt niet in 2024!" — en het antwoord is meestal stilte of "probeer Selenium."

De hoofdoorzaak is IMDb’s voortdurende overstap naar een React/Next.js-frontend. Hier is de tijdlijn van belangrijke brekende wijzigingen:

Dat is ongeveer één grote brekende wijziging per 6–12 maanden. Als je scraper afhankelijk is van CSS-klassen, loop je op een loopband.

Veelvoorkomende fouten en hoe je ze oplost

Lege resultaten / NoneType-fouten

De meest voorkomende fout. Je ziet AttributeError: 'NoneType' object has no attribute 'text'. Dat betekent dat BeautifulSoup het element dat je zoekt niet heeft gevonden — meestal omdat de CSS-klassenaam is veranderd of omdat de content via JavaScript wordt gerenderd.

Oplossing: Schakel over naar JSON-LD-extractie (Methode 2 hierboven). De data zit in de eerste HTML-respons; JavaScript is niet nodig.

403 Forbidden

IMDb gebruikt om bots te detecteren en te blokkeren. De belangrijkste trigger is een ontbrekende of duidelijk neppe User-Agent header. Dit is gedocumenteerd in open-sourceprojecten en in waar een IMDb-medewerker het probleem bevestigde.

Oplossing: Voeg altijd een realistische browser-User-Agent toe en een Accept-Language: en-US header. Gebruik requests.Session() voor connection pooling.

Slechts 25 resultaten teruggekregen

IMDb-zoekpagina's en "Most Popular"-lijsten gebruiken lazy loading — ze tonen aanvankelijk maar ongeveer 25 resultaten en laden de rest via AJAX wanneer je scrolt.

Oplossing: Gebruik URL-parameter-paginering (behandeld in de volgende sectie) of schakel over naar de Top 250-pagina, die alle 250 films in één enkele respons laadt.

Selectors werken ineens niet meer

Oude selectors die niet meer werken: td.titleColumn, td.ratingColumn, .lister-item-header, .inline-block.ratings-imdb-rating. Als je code een van deze gebruikt, is hij stuk.

Oplossing: Geef de voorkeur aan data-testid-attributen (zoals h1[data-testid="hero-title-block__title"]) boven automatisch gegenereerde class-namen. Nog beter: gebruik JSON-LD.

Besliskader: korte termijn vs. lange termijn oplossingen

• Snelle oplossing: Voeg try/except-blokken toe rond elke selector, valideer HTTP-statuscodes, log fouten in plaats van te crashen
• Middellange termijn: Schakel over van CSS-selectors naar JSON-LD-extractie (Methode 2)
• Lange termijn: Gebruik voor analyse op grote schaal, of een tool zoals die AI gebruikt om de paginastuctuur telkens opnieuw te lezen — geen selectors om te onderhouden, de AI past zich automatisch aan lay-outwijzigingen aan

Verder dan de 25-resultaten-grens: IMDb-paginering en grote datasets scrapen

Elke concurrerende tutorial die ik heb bekeken, scrape precies één pagina. Niemand behandelt paginering. Maar als je meer nodig hebt dan één lijst, loop je al snel tegen beperkingen aan.

Pagina's die geen paginering nodig hebben

Goed nieuws: de Top 250-pagina laadt alle 250 films in één server-side gerenderde respons. Zowel de JSON-LD als __NEXT_DATA__ bevatten de volledige dataset. Geen paginering nodig.

Hoe IMDb-zoekpaginering werkt

IMDb-zoekpagina's gebruiken een start=-URL-parameter, oplopend per 50:

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 is een Python-loop die door de resultaten bladert:

1import time
2all_movies = []
3for start in range(1, 1001, 50):  # Bladert door 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"Mislukt bij start={start}: {response.status_code}")
8        break
9    soup = BeautifulSoup(response.text, "lxml")
10    # Extraheer films met je voorkeursmethode
11    # ...
12    print(f"Pagina vanaf {start} gescrapet")
13    time.sleep(3)  # Wees respectvol — IMDb blokkeert na ongeveer 50 snelle verzoeken

Die time.sleep(3) is belangrijk. Uit community-rapporten blijkt dat IMDb IP-adressen begint te blokkeren na ongeveer 50 snelle verzoeken. Een willekeurige vertraging van 2–5 seconden is een goede praktijk.

Wanneer je scraping helemaal kunt overslaan: IMDb's officiële bulk datasets

Voor echt grootschalige behoeften biedt IMDb 7 gratis TSV-bestanden op , dagelijks ververst:

Ze inladen in Pandas is eenvoudig:

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

Deze datasets dekken meer dan 26 miljoen titels. Geen paginering, geen selectors, geen 403-fouten. De licentie is alleen voor persoonlijk en niet-commercieel gebruik — je mag de data niet opnieuw publiceren of doorverkopen.

De no-code snelweg: Thunderbit regelt paginering voor je

Voor lezers die IMDb-data met paginering nodig hebben maar geen pagineringlogica willen schrijven, ondersteunt zowel klikken door pagina’s als infinite scroll standaard. Jij geeft aan wat er gescrapet moet worden, de rest wordt afgehandeld — inclusief scrollen door lazy-loaded content.

IMDb scrapen met Python: de complete werkende code (klaar om te plakken)

Hier zijn twee zelfstandige scripts die je meteen kunt draaien.

Script A: BeautifulSoup-methode (CSS-selectors)

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"Fout: {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 overgeslagen door fout: {e}")
28df = pd.DataFrame(movies)
29df.to_csv("imdb_top250_bs4.csv", index=False)
30print(f"{len(df)} films opgeslagen")
31print(df.head())

Script B: JSON-LD-methode (aanbevolen)

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"Fout: {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("Geen JSON-LD-data gevonden")
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)} films opgeslagen")
42print(df.head())

Beide scripts bevatten foutafhandeling en leveren een nette CSV-output op. Script B geeft je rijkere data — regisseur, beschrijving, URL — en is beter bestand tegen lay-outwijzigingen.

Hoe je IMDb kunt scrapen zonder code te schrijven (met Thunderbit)

Niet iedereen hoeft of wil Python schrijven. Misschien ben je een operations-analist die alleen de best beoordeelde films van deze week in een spreadsheet nodig heeft. Misschien ben je een contentstrateeg die genretrends over jaren wil vergelijken. In zulke gevallen is een scraper bouwen overdreven.

Zo haal je dezelfde data binnen met :

Voordat je begint:

• Moeilijkheid: Beginner
• Benodigde tijd: ~2 minuten
• Wat je nodig hebt: Chrome-browser, (gratis versie werkt)

Stap 1: Ga naar de IMDb-pagina die je wilt scrapen. Open de IMDb Top 250 (of een andere IMDb-lijst/zoekpagina) in Chrome.

Stap 2: Klik in de Thunderbit-zijbalk op "AI Suggest Fields". De AI scant de pagina en stelt kolommen voor — meestal Titel, Jaar, Rating, Genre en nog enkele andere, afhankelijk van de pagina. Je ziet een previewtabel met de voorgestelde velden.

Stap 3: Pas velden aan indien nodig. Verwijder kolommen die je niet nodig hebt, of voeg aangepaste kolommen toe door op "+ Add Column" te klikken en in gewone taal te beschrijven wat je wilt (bijv. "Naam van regisseur" of "Aantal stemmen").

Stap 4: Klik op "Scrape". Thunderbit haalt de data op. Voor pagina's met infinite scroll of paginering regelt het automatisch het scrollen.

Stap 5: Exporteer. Klik op de exportknop en kies je formaat — Excel, Google Sheets, CSV, Airtable of Notion. De data staat binnen seconden op de gewenste plek.

Het grote voordeel hier is niet alleen gemak — het is dat Thunderbit’s AI de paginastuctuur elke keer opnieuw leest. Wanneer IMDb de lay-out wijzigt (en dat zal gebeuren), past de AI zich aan. Geen selectors bijwerken, geen code repareren. Voor iedereen die ooit om 2 uur 's nachts, vlak voor een deadline, met een kapotte scraper heeft geworsteld, is dat goud waard.

Thunderbit ondersteunt ook subpage-scraping — je kunt doorklikken naar de detailpagina van elke film en je tabel verrijken met cast, regisseur, speelduur en andere velden die niet zichtbaar zijn op de lijstpagina. Als je het in actie wilt zien, bekijk dan het .

Is IMDb scrapen legaal? Dit moet je weten

Gebruikers vragen dit expliciet in forums: "Is iets als dit legaal?... IMDb wil niet dat mensen hun website scrapen." Dat is een terechte vraag, en geen enkel concurrerend artikel gaat hier echt op in.

IMDb's robots.txt: De Top 250-chart (/chart/top/), individuele titelpagina's (/title/ttXXXXXXX/) en naam-pagina's (/name/nmXXXXXXX/) zijn NIET geblokkeerd door robots.txt. Geblokkeerde paden zijn onder meer /find, /_json/*, /search/name-text, /user/ur*/ratings en diverse AJAX-endpoints. Er is geen Crawl-delay-directive ingesteld.

IMDb's Gebruiksvoorwaarden: De relevante bepaling luidt: "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." Een extra bepaling verbiedt wederverkoop of commercieel gebruik van gescrapete data.

Wat dit in de praktijk betekent: Recente rechtszaken uit 2024 (Meta v. Bright Data, X Corp v. Bright Data) oordeelden dat Terms of Service mogelijk niet bindend zijn voor gebruikers die er nooit expliciet mee akkoord zijn gegaan — als je publiek beschikbare data scrapt zonder in te loggen, is de afdwingbaarheid van de ToS juridisch discussieerbaar. Maar dit rechtsgebied is in beweging.

Veilige alternatieven: De van IMDb zijn expliciet toegestaan voor persoonlijk en niet-commercieel gebruik. De API van TMDb is ruim toegestaan met een gratis API-key. Beide zijn sterke opties als je graag duidelijk binnen de regels blijft.

Praktisch advies: Als je toch gaat scrapen, gebruik dan een respectvolle crawl-snelheid (time.sleep(3) tussen verzoeken), stel correcte headers in en raak geen paden aan die door robots.txt zijn geblokkeerd. Voor commerciële projecten: raadpleeg een juridisch professional of gebruik de officiële datasets/API.

We hebben de uitgebreid behandeld op de Thunderbit-blog.

Conclusie: kies de juiste manier om IMDb met Python te scrapen

De korte versie:

• BeautifulSoup + CSS-selectors: Goed om de basis te leren. Verwacht dat dit elke 6–12 maanden stukgaat. Voeg altijd foutafhandeling toe.
• JSON-LD-extractie: De methode die ik zou aanraden voor elk doorlopend Python-project. Volgt de Schema.org-standaard, verandert veel minder vaak dan CSS-klassen en geeft je schone gestructureerde data zonder JavaScript-rendering.
• __NEXT_DATA__ JSON: Gebruik dit als aanvulling voor rijkere data op individuele titelpagina's (speelduur, volledige cast, plot, posterafbeeldingen).
• IMDb Official Datasets: De beste keuze voor analyse op grote schaal. 26M+ titels, dagelijks bijgewerkt, geen scraping nodig. Alleen voor persoonlijk/niet-commercieel gebruik.
• : De beste keuze voor niet-technische gebruikers of iedereen die snel data wil zonder code te onderhouden. AI past zich aan lay-outwijzigingen aan, verwerkt paginering en exporteert naar Excel/Sheets/Airtable/Notion.

Sla deze gids op — ik werk hem bij wanneer de structuur van IMDb weer verandert. En als je de code helemaal wilt overslaan, en ontdek hoe snel je van een IMDb-pagina naar een nette spreadsheet gaat. Werk je ook met andere websites? Onze gids over behandelt de bredere workflow.

FAQ's

Is IMDb scrapen legaal?

De gebruiksvoorwaarden van IMDb verbieden scrapen zonder toestemming, maar de afdwingbaarheid daarvan bij publiek toegankelijke data is juridisch onderwerp van discussie na recente uitspraken in 2024. De veiligste opties zijn IMDb's (voor persoonlijk/niet-commercieel gebruik) of de TMDb API (gratis sleutel). Als je toch scrapt: respecteer robots.txt, houd redelijke pauzes tussen verzoeken en vermijd geblokkeerde paden. Voor commercieel gebruik: raadpleeg een juridisch professional.

Waarom geeft mijn IMDb-scraper lege resultaten terug?

Bijna altijd komt dat door verouderde CSS-selectors — class-namen zoals td.titleColumn en td.ratingColumn bestaan sinds juni 2023 niet meer. De oplossing is overstappen op JSON-LD-extractie (parse de <script type="application/ld+json">-tag) of je selectors bijwerken naar de huidige ipc--prefixed classes. Controleer ook of je een correcte User-Agent header meestuurt, want een ontbrekende header veroorzaakt een 403-fout die eruit kan zien als lege resultaten.

Hoe scrape ik meer dan 25 resultaten van IMDb?

De Top 250-pagina laadt alle 250 films in één respons — geen paginering nodig. Voor zoekresultaten gebruik je de start=-URL-parameter (oplopend per 50) om door de resultaten te bladeren. Bijvoorbeeld: start=1, start=51, start=101. Voeg time.sleep(3) toe tussen verzoeken om blokkering te voorkomen. Als alternatief bevatten IMDb’s officiële datasets op meer dan 26 miljoen titels zonder dat paginering nodig is.

Wat is __NEXT_DATA__ en waarom zou ik het gebruiken om IMDb te scrapen?

__NEXT_DATA__ is een JSON-object in een <script id="__NEXT_DATA__">-tag op IMDb’s React/Next.js-pagina's. Het bevat de volledige gestructureerde data die React gebruikt om de pagina te renderen — titels, ratings, cast, genres, speelduur en meer. Omdat het het onderliggende datamodel weergeeft in plaats van de visuele lay-out, is het beter bestand tegen UI-redesigns dan CSS-selectors. Gebruik het samen met JSON-LD voor de meest robuuste aanpak.

Kan ik IMDb scrapen zonder te coderen?

Ja. Twee hoofdopties: (1) Download IMDb’s — 7 TSV-bestanden met gegevens over 26M+ titels, dagelijks bijgewerkt, gratis voor niet-commercieel gebruik. (2) Gebruik , die de IMDb-pagina leest, automatisch velden voorstelt en in twee klikken exporteert naar Excel, Google Sheets of CSV — geen code, geen selectors om te onderhouden.

Meer weten