Scrape IMDb med Python: Kode, der faktisk virker

Hvis du for nylig har søgt på "scrape IMDb med Python", har du sikkert lagt mærke til én ting: De fleste vejledninger, du finder, er i stykker. Ikke bare "lidt forældede" i stykker — mere i retning af "giver nul resultater og en mur af NoneType-fejl" i stykker.

Jeg har brugt de sidste par uger på at teste hver større IMDb-scraping-vejledning, jeg kunne finde — GeeksforGeeks, Medium, freeCodeCamp, Kaggle notebooks, you name it. Ud af mærket til IMDb scraping henviser langt de fleste til CSS-selectors (td.titleColumn, td.ratingColumn), som ikke har eksisteret siden juni 2023, da IMDb redesignede deres Top 250-side. Resultatet? Fora fyldt med udviklere, der spørger "hvorfor returnerer min kode tomt?", og vedligeholdere af populære biblioteker som "Ikke meget, vi kan gøre ved det, ud over at rette hver eneste parser." Denne guide dækker to Python-metoder, der faktisk virker lige nu, hvordan du håndterer pagination og almindelige fejl, hvornår Python slet ikke er det rigtige værktøj, og hvordan du fremtidssikrer din scraper, så den ikke ender på kirkegården.

Hvad betyder det at scrape IMDb med Python?

Web scraping er processen med programmatisk at udtrække data fra websider — i stedet for manuelt at kopiere og indsætte skriver du et script, der gør det for dig. Når vi taler om at "scrape IMDb", mener vi at hente strukturerede filmdata (titler, ratings, genrer, medvirkende, spilletid, stemmetal) fra IMDb's websider ved hjælp af Python.

Den typiske Python-stack til det her består af tre biblioteker: requests (til at hente websiden), BeautifulSoup (til at parse HTML'en og finde dataene) og pandas (til at organisere og eksportere resultaterne). Nogle vejledninger bruger også Selenium eller Playwright til sider, der kræver JavaScript-rendering, men som du vil se, findes der hurtigere metoder.

En vigtig bemærkning: Alt i denne guide er verificeret mod IMDb's nuværende sidstruktur pr. midten af 2025. IMDb ændrer tingene cirka hver 6.–12. måned, så hvis du læser dette i 2027, kan nogle selectors være ændret. (Jeg forklarer også, hvordan du håndterer det.)

Hvorfor scrape IMDb med Python? Brugsscenarier i den virkelige verden

Før du skriver en eneste linje kode, hvad ville du egentlig bruge IMDb-data til? Svaret afhænger af, hvem du er.

IMDb-anmeldelsesdatasættet er et af verdens mest brugte NLP-benchmarks — det grundlæggende paper af Maas et al. (2011) har samlet , og datasættet er indbygget i TensorFlow, Keras og PyTorch. På Hugging Face får datasættet stanfordnlp/imdb 213.321 downloads om måneden og er blevet brugt til at træne over 1.500 modeller. Så hvis du arbejder med machine learning, kender du sandsynligvis allerede IMDb-data.

Men brugsscenarierne rækker langt ud over akademia:

Bare markedet for filmturisme er anslået til . Netflix brugte over 17 mia. USD på indhold i 2024, og blev drevet af personlige anbefalinger. Pointen er: IMDb-data driver reelle beslutninger på tværs af brancher.

Dine muligheder for at få IMDb-data, før du skriver en linje kode

Det her er den del, de fleste vejledninger springer helt over. De går direkte til pip install beautifulsoup4 uden at spørge, om Python scraping overhovedet er den rigtige tilgang i din situation.

Her er det fulde overblik:

Et par bemærkninger til de her muligheder. Cinemagoer har ikke haft en PyPI-udgivelse siden maj 2023, og de fleste af deres parsers gik i stykker efter IMDb's redesign i juni 2025 — jeg ville ikke anbefale det til produktionsbrug lige nu. TMDb er fremragende, men bruger sit eget ratingsystem, ikke IMDb's. Og IMDb's officielle enterprise API koster via AWS Data Exchange, så det er ikke en mulighed for de fleste af os.

For læsere, der slet ikke vil skrive kode, læser IMDb-siden, foreslår automatisk udtræksfelter (titel, rating, år, genre) og eksporterer til Excel, Google Sheets, Airtable eller Notion på to klik. AI'en tilpasser sig, når IMDb ændrer layout, så der er ingen selectors at vedligeholde. Mere om det senere.

Nu til dem, der faktisk vil skrive Python — her er to metoder, der virker.

Metode 1: Scrape IMDb med Python ved hjælp af BeautifulSoup (traditionel tilgang)

Det her er den klassiske tilgang, du finder i de fleste vejledninger. Den virker, men jeg vil være helt ærlig: Den er den mest skrøbelige af de metoder, jeg gennemgår. IMDb's CSS-klassenavne er automatisk genererede og ændrer sig ved redesigns. Når det er sagt, er det den bedste måde at lære grundprincipperne i web scraping på.

Trin 1: Installer og importer dine Python-biblioteker

Du skal bruge fire pakker:

1pip install requests beautifulsoup4 pandas lxml

Her er, hvad hver især gør:

• requests — sender HTTP-anmodninger for at hente websiden
• beautifulsoup4 — parser HTML'en, så du kan søge efter specifikke elementer
• pandas — organiserer de udtrukne data i tabeller og eksporterer til CSV/Excel
• lxml — en hurtig HTML-parser (BeautifulSoup kan bruge den som backend)

Din importblok:

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

Trin 2: Send en HTTP-anmodning til IMDb

Det er her, de fleste begyndere rammer den første mur. IMDb blokerer anmodninger, der ikke indeholder en korrekt User-Agent-header — du får en 403 Forbidden-fejl. Den standardiserede Python Requests user-agent-streng (python-requests/2.31.0) bliver markeret med det samme.

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"Kunne ikke hente siden: {response.status_code}")
9else:
10    print("Siden blev hentet successfuldt")

Accept-Language-headeren er også vigtig — uden den kan IMDb returnere indhold på et andet sprog baseret på din IP's geolokation.

Trin 3: Parse HTML'en med BeautifulSoup

Når du har HTML'en, opretter du et BeautifulSoup-objekt og begynder at lede efter de rigtige elementer. Åbn IMDb Top 250-siden i Chrome, højreklik på en filmtitel, og klik på "Inspect" for at se den underliggende HTML-struktur.

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

Pr. midten af 2025 bruger Top 250-siden disse selectors:

• Filmcontainer: li.ipc-metadata-list-summary-item
• Titel: h3.ipc-title__text
• År: span.cli-title-metadata-item (første span)
• Rating: span.ipc-rating-star--rating

Vær opmærksom: de ipc--præfiksede klassenavne er genereret af IMDb's komponent-system. De har været stabile siden redesignen i juni 2023, men der er ingen garanti for, at de ikke ændrer sig igen.

Trin 4: Udtræk filmdata (titel, år, rating)

Her adskiller jeg mig fra de fleste vejledninger: Jeg inkluderer try/except-fejlhåndtering. Ingen af de konkurrentguides, jeg gennemgik, gør det, og det er præcis derfor, deres kode fejler stille og roligt, når en selector ændrer sig.

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"Fejl ved parsing af film: {e}")
18        continue
19print(f"Udtrak {len(movies)} film")

Trin 5: Gem til CSV eller Excel med 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())

Eksempel på output:

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

Det virker. Men det hænger sammen med CSS-selectors, der kan gå i stykker fra dag til dag — og det bringer os til den tilgang, jeg faktisk anbefaler.

Metode 2: JSON-LD-tricket — spring HTML-parsing helt over

Det her er den teknik, som ingen konkurrentartikel dækker, og det er den, jeg ville bruge til ethvert seriøst projekt. IMDb indlejrer strukturerede data som (JavaScript Object Notation for Linked Data) i <script type="application/ld+json">-tags på hver side. Disse data følger Schema.org-standarden, bruges af Google til rige søgeresultater og ændrer sig langt sjældnere end CSS-klassenavne.

Apify IMDb Scraper, et produktionsklart værktøj, bruger følgende prioriterede udtræksrækkefølge: "JSON-LD > NEXT_DATA > DOM." Det er også det hierarki, jeg vil anbefale.

Hvorfor JSON-LD er mere pålideligt end CSS-selectors

CSS-klassenavne som ipc-metadata-list-summary-item er automatisk genereret af IMDb's React-komponentsystem og ændrer sig ved hvert redesign. JSON-LD-schemaet repræsenterer selve datamodellen, ikke præsentationslaget. Det er som forskellen på at læse en bogs indholdsfortegnelse versus at forsøge at identificere kapitler ud fra skrifttypestørrelsen.

Trin for trin: Udtræk IMDb-data fra JSON-LD

Trin 1: Hent siden

Som før — brug requests med en korrekt 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")

Trin 2: Find JSON-LD-script-tagget

1script_tag = soup.find("script", {"type": "application/ld+json"})
2if not script_tag:
3    print("Ingen JSON-LD fundet på denne side")
4else:
5    data = json.loads(script_tag.string)
6    print(f"Fandt JSON-LD med type: {data.get('@type', 'ukendt')}")

Trin 3: Parse de strukturerede data

På Top 250-siden indeholder JSON-LD en itemListElement-array med alle 250 film. Hver post indeholder position, navn, URL, aggregateRating, datePublished, genre, description, director- og 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    })

Trin 4: Eksporter til CSV

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

Eksempel på output:

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 film. Rent, struktureret og uden CSS-selector-krumspring. Og fordi disse data følger Schema.org-standarden (som Google afhænger af til søgeresultater), er de langt mindre tilbøjelige til at ændre sig end det visuelle layout.

Ekstra: __NEXT_DATA__ til individuelle filmsider

For rigere data fra individuelle titlesider (spilletid, fuld cast, plot-sammendrag, plakater) indlejrer IMDb også et __NEXT_DATA__-JSON-objekt. Det er de data, React bruger til at hydrere siden — de kan ikke fjernes uden at ødelægge sitet.

1# På en individuel filmside som /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"]

Brug JSON-LD til chart-/listsider, __NEXT_DATA__ til individuelle title-sider. Det er den produktionsklare tilgang.

Hvorfor din IMDb scraper bliver ved med at gå i stykker (og hvordan du fikser det)

Det er det mest rapporterede smertepunkt på tværs af alle IMDb scraping-fora, jeg har gennemgået. Brugere skriver: "Noget af koden gik i stykker på grund af UI-ændringer" og "Virker ikke i 2024!" — og svaret er som regel tavshed eller "prøv Selenium."

Den grundlæggende årsag er IMDb's igangværende migration til en React/Next.js-frontend. Her er tidslinjen for de største breaking changes:

Det er omtrent én større breaking change hver 6.–12. måned. Hvis din scraper er afhængig af CSS-klassenavne, løber du i et hamsterhjul.

Almindelige fejl og hvordan du løser dem

Tomme resultater / NoneType-fejl

Den mest almindelige fejl. Du ser AttributeError: 'NoneType' object has no attribute 'text'. Det betyder, at BeautifulSoup ikke kunne finde det element, du leder efter — typisk fordi CSS-klassenavnet ændrede sig, eller fordi indholdet gengives via JavaScript.

Løsning: Skift til JSON-LD-udtræk (Metode 2 ovenfor). Dataene ligger i det oprindelige HTML-svar, uden at JavaScript er nødvendigt.

403 Forbidden

IMDb bruger til at opdage og blokere bots. Den største trigger er en manglende eller tydeligt falsk User-Agent-header. Det er dokumenteret på tværs af open source-projekter og , hvor en IMDb-medarbejder anerkendte problemet.

Løsning: Inkludér altid en realistisk browser-User-Agent-streng og headeren Accept-Language: en-US. Brug requests.Session() til connection pooling.

Kun 25 resultater returneret

IMDb's søgeresultatsider og "Mest populære"-lister bruger lazy loading — de viser kun omkring 25 resultater i første omgang og indlæser flere via AJAX, mens du scroller.

Løsning: Brug URL-parameter-pagination (dækket i næste afsnit), eller skift til Top 250-siden, som indlæser alle 250 film i ét enkelt svar.

Selectors holder pludselig op med at virke

Gamle selectors, der ikke længere virker: td.titleColumn, td.ratingColumn, .lister-item-header, .inline-block.ratings-imdb-rating. Hvis din kode bruger nogen af disse, er den i stykker.

Løsning: Foretræk data-testid-attributter (som h1[data-testid="hero-title-block__title"]) frem for automatisk genererede klassenavne. Endnu bedre: brug JSON-LD.

Et beslutningsframework: Kortfristede vs. langsigtede løsninger

• Hurtig løsning: Tilføj try/except-blokke omkring hver selector, valider HTTP-statuskoder, log fejl i stedet for at crashe
• Mellemlang løsning: Skift fra CSS-selectors til JSON-LD-udtræk (Metode 2)
• Langsigtet løsning: Brug til analyse i stor skala, eller et værktøj som , der bruger AI til at læse sidestrukturen på ny hver gang — ingen selectors at vedligeholde, AI'en tilpasser sig automatisk layoutændringer

Udover 25-resultatsgrænsen: Scraping af IMDb pagination og store datasæt

Hver konkurrentvejledning, jeg gennemgik, scraper præcis én side. Ingen dækker pagination. Men hvis du har brug for mere end én liste, rammer du hurtigt en mur.

Sider, der ikke behøver pagination

Gode nyheder: Top 250-siden indlæser alle 250 film i ét enkelt server-renderet svar. Både JSON-LD og __NEXT_DATA__ indeholder det komplette datasæt. Ingen pagination nødvendig.

Sådan fungerer IMDb's søge-pagination

IMDb's søgesider bruger en start=-URL-parameter, der øges med 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

Her er en Python-løkke, der bladrer gennem resultaterne:

1import time
2all_movies = []
3for start in range(1, 1001, 50):  # Bladrer gennem 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"Fejl ved start={start}: {response.status_code}")
8        break
9    soup = BeautifulSoup(response.text, "lxml")
10    # Udtræk film ved hjælp af din foretrukne metode
11    # ...
12    print(f"Scrapede side med start ved {start}")
13    time.sleep(3)  # Vær hensynsfuld — IMDb blokerer efter ~50 hurtige anmodninger

Den time.sleep(3) er vigtig. Community-rapporter tyder på, at IMDb begynder at blokere IP'er efter cirka 50 hurtige anmodninger. En tilfældig forsinkelse mellem 2–5 sekunder er god praksis.

Hvornår du helt skal springe scraping over: IMDb's officielle bulk-datasæt

Til virkelig store behov stiller IMDb 7 gratis TSV-filer til rådighed på , opdateret dagligt:

Det er ligetil at indlæse dem i Pandas:

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

Disse datasæt dækker 26+ millioner titler. Ingen pagination, ingen selectors, ingen 403-fejl. Licensen er kun til personlig og ikke-kommerciel brug — du må ikke genudgive eller videresælge dataene.

No-code-genvejen: Thunderbit håndterer pagination for dig

For læsere, der har brug for paginerede IMDb-data, men ikke vil skrive pagination-logik, understøtter både klikbaseret pagination og infinite scroll som standard. Du beder det om at scrape, og det klarer resten — inklusive scrolling gennem lazy-loaded indhold.

Scrape IMDb med Python: Den komplette fungerende kode (klar til copy-paste)

Her er to selvstændige scripts, du kan køre med det samme.

Script A: BeautifulSoup-metoden (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"Fejl: {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"Springer film over på grund af fejl: {e}")
28df = pd.DataFrame(movies)
29df.to_csv("imdb_top250_bs4.csv", index=False)
30print(f"Gemte {len(df)} film")
31print(df.head())

Script B: JSON-LD-metoden (anbefalet)

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"Fejl: {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("Ingen JSON-LD-data fundet")
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"Gemte {len(df)} film")
42print(df.head())

Begge scripts indeholder fejlhåndtering og producerer et rent CSV-output. Script B giver dig rigere data — instruktør, beskrivelse, URL — og er mere robust over for layoutændringer.

Sådan scraper du IMDb uden at skrive kode (med Thunderbit)

Ikke alle har brug for eller lyst til at skrive Python. Måske er du operationsanalytiker og skal bare bruge ugens højest bedømte film i et regneark. Måske er du content strategist og vil sammenligne genretrends på tværs af år. I de tilfælde er det overkill at skrive en scraper.

Sådan får du de samme data med :

Før du starter:

• Sværhedsgrad: Begynder
• Tidsforbrug: ~2 minutter
• Det skal du bruge: Chrome-browser, (gratisversionen virker)

Trin 1: Gå til den IMDb-side, du vil scrape. Åbn IMDb Top 250 (eller en hvilken som helst anden IMDb-liste-/søgeside) i Chrome.

Trin 2: Klik på "AI Suggest Fields" i Thunderbit-sidepanelet. AI'en scanner siden og foreslår kolonner — typisk Titel, År, Rating, Genre og et par andre afhængigt af siden. Du ser en forhåndsvisningstabel med de foreslåede felter.

Trin 3: Juster felterne, hvis nødvendigt. Fjern kolonner, du ikke har brug for, eller tilføj brugerdefinerede ved at klikke på "+ Add Column" og beskrive, hvad du vil have, på almindeligt engelsk (f.eks. "Director name" eller "Number of votes").

Trin 4: Klik på "Scrape." Thunderbit udtrækker dataene. For sider med infinite scroll eller pagination håndterer det scrollingen automatisk.

Trin 5: Eksportér. Klik på eksportknappen, og vælg format — Excel, Google Sheets, CSV, Airtable eller Notion. Dataene lander i din destination på få sekunder.

Den vigtigste fordel er ikke bare bekvemmelighed — det er, at Thunderbit's AI læser sidestrukturen fra bunden hver gang. Når IMDb ændrer layout (og det vil de), tilpasser AI'en sig. Ingen selectors at opdatere, ingen kode at rette. For alle, der har prøvet en ødelagt scraper kl. 2 om natten før en deadline, er det meget værd.

Thunderbit understøtter også scraping af undersider — du kan åbne hver films detaljeside og berige din tabel med cast, instruktør, spilletid og andre felter, som ikke er synlige på listesiden. Hvis du vil se det i praksis, så tjek .

Er det lovligt at scrape IMDb? Det skal du vide

Brugere spørger det direkte i fora: "Er noget som dette lovligt?… IMDb vil ikke have folk til at scrape deres website." Det er et fair spørgsmål, og ingen konkurrentartikel tager det ordentligt op.

IMDb's robots.txt: Top 250-chartet (/chart/top/), individuelle titlesider (/title/ttXXXXXXX/) og name pages (/name/nmXXXXXXX/) er IKKE blokeret af robots.txt. Blokerede stier inkluderer /find, /_json/*, /search/name-text, /user/ur*/ratings og forskellige AJAX-endpoints. Der er ingen Crawl-delay-direktiv angivet.

IMDb's Conditions of Use: Den relevante klausul lyder: "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." En ekstra klausul forbyder videresalg eller kommerciel brug af scrappede data.

Hvad det betyder i praksis: Nylige domme fra 2024 (Meta v. Bright Data, X Corp v. Bright Data) har fastslået, at Terms of Service muligvis ikke binder brugere, der aldrig har accepteret dem — hvis du scraper offentligt tilgængelige data uden at logge ind, er håndhævelsen af ToS juridisk omdiskuteret. Men det juridiske område er i udvikling.

Sikre alternativer: IMDb's er udtrykkeligt godkendt til personlig og ikke-kommerciel brug. TMDb's API er permissiv med en gratis API-nøgle. Begge er solide valg, hvis du vil holde dig tydeligt på den sikre side.

Praktisk vejledning: Hvis du scraper, så brug en hensynsfuld crawl-rate (time.sleep(3) mellem anmodninger), sæt korrekte headers, og ram ikke stier, som robots.txt blokerer. Til kommercielle projekter bør du rådføre dig med en juridisk fagperson eller bruge de officielle datasæt/API'et.

Vi har dækket i dybden på Thunderbit-bloggen.

Konklusion: Vælg den rigtige måde at scrape IMDb med Python på

Den korte version:

• BeautifulSoup + CSS-selectors: God til at lære grundprincipperne. Forvent, at den går i stykker hver 6.–12. måned. Inkludér altid fejlhåndtering.
• JSON-LD-udtræk: Den tilgang, jeg vil anbefale til ethvert løbende Python-projekt. Følger Schema.org-standarden, ændrer sig langt sjældnere end CSS-klasser og giver dig rene, strukturerede data uden JavaScript-rendering.
• __NEXT_DATA__ JSON: Brug det som supplement til rigere data på individuelle titlesider (spilletid, fuld cast, plot, billeder).
• IMDb Official Datasets: Det bedste valg til analyse i stor skala. 26 mio.+ titler, opdateret dagligt, ingen scraping nødvendig. Kun til personlig/ikke-kommerciel brug.
• : Det bedste valg for ikke-kodere eller alle, der vil have data hurtigt uden at vedligeholde kode. AI tilpasser sig layoutændringer, håndterer pagination og eksporterer til Excel/Sheets/Airtable/Notion.

Bogmærk denne guide — jeg opdaterer den, når IMDb's struktur ændrer sig næste gang. Og hvis du vil springe koden helt over, så og se, hvor hurtigt du kan gå fra en IMDb-side til et rent regneark. Hvis du også arbejder med andre sites, dækker vores guide om den bredere arbejdsgang.

Ofte stillede spørgsmål

Er det lovligt at scrape IMDb?

IMDb's vilkår for brug forbyder scraping uden samtykke, men håndhævelsen af ToS på offentligt tilgængelige data er juridisk omdiskuteret efter nylige domme fra 2024. De sikreste muligheder er IMDb's (personlig/ikke-kommerciel brug) eller TMDb API'et (gratis nøgle). Hvis du scraper, så respekter robots.txt, brug rimelige pauser mellem anmodninger og undgå blokerede stier. Ved kommerciel brug bør du rådføre dig med en juridisk fagperson.

Hvorfor returnerer min IMDb scraper tomme resultater?

Næsten altid skyldes det forældede CSS-selectors — klassenavne som td.titleColumn og td.ratingColumn har ikke eksisteret siden juni 2023. Løsningen er at skifte til JSON-LD-udtræk (pars <script type="application/ld+json">-tagget) eller opdatere dine selectors til de nuværende ipc--præfiksede klasser. Kontrollér også, at du sender en korrekt User-Agent-header, da en manglende header udløser en 403-fejl, som kan se ud som tomme resultater.

Hvordan scraper jeg mere end 25 resultater fra IMDb?

Top 250-siden indlæser alle 250 film i ét svar — ingen pagination nødvendig. For søgeresultater bruger du URL-parameteren start= (øges med 50) til at bladre gennem resultaterne. For eksempel: start=1, start=51, start=101. Tilføj time.sleep(3) mellem anmodninger for at undgå at blive blokeret. Alternativt indeholder IMDb's officielle datasæt på 26 mio.+ titler uden behov for pagination.

Hvad er __NEXT_DATA__, og hvorfor bør jeg bruge det til at scrape IMDb?

__NEXT_DATA__ er et JSON-objekt, der er indlejret i et <script id="__NEXT_DATA__">-tag på IMDb's React/Next.js-sider. Det indeholder de komplette strukturerede data, som React bruger til at gengive siden — titler, ratings, cast, genrer, spilletid og mere. Fordi det repræsenterer den underliggende datamodel frem for det visuelle layout, er det mere robust over for redesigns end CSS-selectors. Brug det sammen med JSON-LD for den mest robuste udtræksmetode.

Kan jeg scrape IMDb uden at kode?

Ja. To hovedmuligheder: (1) Download IMDb's — 7 TSV-filer, der dækker 26 mio.+ titler, opdateret dagligt og gratis til ikke-kommerciel brug. (2) Brug , som læser IMDb-siden, foreslår udtræksfelter automatisk og eksporterer til Excel, Google Sheets eller CSV på to klik — ingen kode, ingen selectors at vedligeholde.

Læs mere