Scrapa IMDb med Python: Kod som faktiskt fungerar

Om du nyligen har sökt på "scrape IMDb with Python" har du säkert märkt en sak: de flesta guider du hittar är trasiga. Inte bara "lite utdaterade" trasiga — mer som "ger noll resultat och en vägg av NoneType-fel" trasiga.

Jag har ägnat de senaste veckorna åt att testa varenda större IMDb-scrapingguide jag kunde hitta — GeeksforGeeks, Medium, freeCodeCamp, Kaggle-notebooks, allt möjligt. Av märkta för IMDb-scraping hänvisar majoriteten till CSS-selektorer (td.titleColumn, td.ratingColumn) som inte har funnits sedan juni 2023, då IMDb gjorde om sin Top 250-sida. Resultatet? Forum fulla av utvecklare som frågar "varför blir min kod tom?" och underhållare av populära bibliotek som "Inte mycket vi kan göra åt det, förutom att fixa varje parser." Den här guiden täcker två Python-metoder som faktiskt fungerar just nu, hur du hanterar paginering och vanliga fel, när Python inte ens är rätt verktyg, och hur du framtidssäkrar din scraper så att den inte hamnar på skrothögen.

Vad betyder det att scrapa IMDb med Python?

Web scraping är processen att programmatiskt extrahera data från webbsidor — i stället för att manuellt kopiera och klistra in skriver du ett skript som gör jobbet åt dig. När vi pratar om att "scrapa IMDb" menar vi att hämta strukturerad filmdata (titlar, betyg, genrer, rollista, speltid, röstantal) från IMDb:s webbsidor med Python.

Den vanliga Python-stack som används här består av tre bibliotek: requests (för att hämta webbsidan), BeautifulSoup (för att tolka HTML och hitta datan) och pandas (för att organisera och exportera resultaten). Vissa guider använder också Selenium eller Playwright för sidor som kräver JavaScript-rendering, men som du snart ska se finns det snabbare metoder.

En viktig brasklapp: allt i den här guiden är verifierat mot IMDb:s nuvarande sidstruktur per mitten av 2025. IMDb ändrar ungefär var 6–12:e månad, så om du läser detta 2027 kan vissa selektorer ha ändrats. (Jag förklarar också hur du hanterar det.)

Varför scrapa IMDb med Python? Verkliga användningsområden

Innan du skriver en enda rad kod: vad skulle du faktiskt göra med IMDb-data? Svaret beror på vem du är.

IMDb:s recensionsdataset är ett av de mest använda NLP-benchmarksen i världen — den ursprungliga artikeln av Maas et al. (2011) har samlat , och datasetet är inbyggt i TensorFlow, Keras och PyTorch. På Hugging Face får datasetet stanfordnlp/imdb 213 321 nedladdningar per månad och har använts för att träna över 1 500 modeller. Så om du arbetar med maskininlärning är du förmodligen redan bekant med IMDb-data.

Men användningsområdena sträcker sig långt bortom akademin:

Bara marknaden för filmturism värderas till uppskattningsvis . Netflix spenderade över 17 miljarder dollar på innehåll under 2024, och drevs av personliga rekommendationer. Poängen är: IMDb-data påverkar verkliga beslut i många branscher.

Dina alternativ för att få IMDb-data (innan du skriver en rad kod)

Det här är avsnittet de flesta guider hoppar över helt. De går direkt till pip install beautifulsoup4 utan att fråga om Python-scraping ens är rätt angreppssätt för din situation.

Här är hela landskapet:

Några kommentarer om alternativen. Cinemagoer har inte haft någon PyPI-release sedan maj 2023 och de flesta parsers gick sönder efter IMDb:s redesign i juni 2025 — jag skulle inte rekommendera det för produktionsbruk just nu. TMDb är utmärkt men använder sitt eget betygssystem, inte IMDb:s. Och IMDb:s officiella enterprise-API kostar via AWS Data Exchange, så det är inte ett alternativ för de flesta av oss.

För läsare som inte vill skriva någon kod alls läser IMDb-sidan, föreslår extraheringsfält automatiskt (titel, betyg, år, genre) och exporterar till Excel, Google Sheets, Airtable eller Notion i två klick. AI:n anpassar sig när IMDb ändrar layouten, så det finns inga selektorer att underhålla. Mer om det senare.

Nu, för dig som faktiskt vill skriva Python — här är två metoder som fungerar.

Metod 1: Scrapa IMDb med Python med BeautifulSoup (traditionell metod)

Det här är den klassiska metoden du hittar i de flesta guider. Den fungerar, men jag vill vara tydlig: den är den sköraste av metoderna jag går igenom. IMDb:s CSS-klassnamn genereras automatiskt och ändras vid redesigns. Med det sagt är det fortfarande det bästa sättet att lära sig grunderna i web scraping.

Steg 1: Installera och importera dina Python-bibliotek

Du behöver fyra paket:

1pip install requests beautifulsoup4 pandas lxml

Så här används de:

• requests — skickar HTTP-förfrågningar för att hämta webbsidan
• beautifulsoup4 — tolkar HTML så att du kan söka efter specifika element
• pandas — organiserar den extraherade datan i tabeller och exporterar till CSV/Excel
• lxml — en snabb HTML-parser (BeautifulSoup kan använda den som backend)

Din import-block:

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

Steg 2: Skicka en HTTP-förfrågan till IMDb

Det är här de flesta nybörjare stöter på sin första vägg. IMDb blockerar förfrågningar som inte inkluderar en korrekt User-Agent-header — du får ett 403 Forbidden-fel. Standardsträngen för Python Requests (python-requests/2.31.0) flaggas direkt.

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"Misslyckades med att hämta sidan: {response.status_code}")
9else:
10    print("Sidan hämtades success")

Accept-Language-headern spelar också roll — utan den kan IMDb returnera innehåll på ett annat språk beroende på IP-adressens geografiska plats.

Steg 3: Tolka HTML med BeautifulSoup

När du har HTML-koden skapar du ett BeautifulSoup-objekt och börjar leta efter rätt element. Öppna IMDb Top 250-sidan i Chrome, högerklicka på en filmtitel och klicka på "Inspektera" för att se den underliggande HTML-strukturen.

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

Per mitten av 2025 använder Top 250-sidan dessa selektorer:

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

Varning: dessa ipc--prefixade klassnamn genereras av IMDb:s komponent-system. De har varit stabila sedan redesignen i juni 2023, men det finns ingen garanti för att de inte ändras igen.

Steg 4: Extrahera filmdata (titel, år, betyg)

Här skiljer jag mig från de flesta guider: jag lägger in felhantering med try/except. Ingen av konkurrentguiderna jag granskade gör det, vilket är exakt varför deras kod tyst går sönder när en selektor ändras.

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"Fel vid tolkning av film: {e}")
18        continue
19print(f"Extraherade {len(movies)} filmer")

Steg 5: Spara till 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())

Exempelutdata:

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 fungerar. Men det hålls ihop av CSS-selektorer som kan gå sönder när som helst — vilket leder oss till metoden jag faktiskt rekommenderar.

Metod 2: JSON-LD-tricket — hoppa över HTML-tolkningen helt

Det här är tekniken som ingen konkurrerande artikel tar upp, och den är den jag skulle använda för alla seriösa projekt. IMDb bäddar in strukturerad data som (JavaScript Object Notation for Linked Data) i <script type="application/ld+json">-taggar på varje sida. Den här datan följer Schema.org-standarden, används av Google för rika sökresultat och ändras mycket mer sällan än CSS-klassnamn.

Apify IMDb Scraper, ett produktionsklart verktyg, använder denna extraheringsprioritet: "JSON-LD > NEXT_DATA > DOM." Det är den hierarkin jag också skulle rekommendera.

Varför JSON-LD är mer tillförlitligt än CSS-selektorer

CSS-klassnamn som ipc-metadata-list-summary-item genereras automatiskt av IMDb:s React-komponentsystem och ändras vid varje redesign. JSON-LD-schemat representerar den faktiska datamodellen, inte presentationslagret. Det är som skillnaden mellan att läsa innehållsförteckningen i en bok och att försöka identifiera kapitlen utifrån typsnittsstorlek.

Steg för steg: Extrahera IMDb-data från JSON-LD

Steg 1: Hämta sidan

Samma som tidigare — använd 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")

Steg 2: Hitta JSON-LD-script-taggen

1script_tag = soup.find("script", {"type": "application/ld+json"})
2if not script_tag:
3    print("Ingen JSON-LD hittades på den här sidan")
4else:
5    data = json.loads(script_tag.string)
6    print(f"Hittade JSON-LD med typ: {data.get('@type', 'okänd')}")

Steg 3: Tolka den strukturerade datan

På Top 250-sidan innehåller JSON-LD ett itemListElement-array med alla 250 filmer. Varje post innehåller position, namn, URL, aggregateRating, datePublished, genre, description, director och actor-arrayer.

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

Steg 4: Exportera till CSV

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

Exempelutdata:

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

Alla 250 filmer. Rent, strukturerat, inga CSS-selektorgymnastiska övningar. Och eftersom den här datan följer Schema.org-standarden (som Google är beroende av för sökresultat) är den betydligt mindre benägen att ändras än den visuella layouten.

Bonus: __NEXT_DATA__ för enskilda filmsidor

För rikare data från enskilda titelsidor (speltid, full rollista, synopsis, affischbilder) bäddar IMDb också in ett __NEXT_DATA__-JSON-objekt. Det här är datan som React använder för att ladda sidan — den kan inte tas bort utan att sidan går sönder.

1# På en enskild filmsida 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"]

Använd JSON-LD för list- och chartsidor, __NEXT_DATA__ för enskilda titelsidor. Det är den produktionsklara metoden.

Varför din IMDb-scraper hela tiden går sönder (och hur du fixar det)

Det här är det enskilt vanligaste problemet som rapporteras i alla IMDb-scrapingforum jag kollade. Användare skriver: "En del av koden gick sönder på grund av UI-ändringar" och "Fungerar inte 2024!" — och svaret är oftast tystnad eller "prova Selenium."

Rotorsaken är IMDb:s pågående migrering till ett React/Next.js-frontend. Här är tidslinjen för större förändringar som orsakat problem:

Det blir ungefär en stor brytande ändring var 6–12:e månad. Om din scraper bygger på CSS-klassnamn sitter du på ett löpande band.

Vanliga fel och hur du fixar dem

Tomma resultat / NoneType-fel

Det vanligaste felet. Du ser AttributeError: 'NoneType' object has no attribute 'text'. Det betyder att BeautifulSoup inte hittade elementet du letade efter — oftast för att CSS-klassnamnet har ändrats eller för att innehållet renderas av JavaScript.

Lösning: Byt till JSON-LD-extrahering (Metod 2 ovan). Datan finns i det initiala HTML-svaret, inget JavaScript behövs.

403 Forbidden

IMDb använder för att upptäcka och blockera bots. Den vanligaste orsaken är en saknad eller uppenbart fejkad User-Agent-header. Det här har dokumenterats i öppen källkod-projekt och i där en IMDb-anställd bekräftade problemet.

Lösning: Inkludera alltid en realistisk webbläsarsträng för User-Agent och headern Accept-Language: en-US. Använd requests.Session() för connection pooling.

Endast 25 resultat returneras

IMDb:s söksidor och listor för "Most Popular" använder lazy loading — de renderar bara runt 25 resultat initialt och laddar fler via AJAX när du scrollar.

Lösning: Använd URL-parametern för paginering (som vi går igenom i nästa avsnitt) eller byt till Top 250-sidan, som laddar alla 250 filmer i ett enda svar.

Selektorer slutar plötsligt fungera

Gamla selektorer som inte längre fungerar: td.titleColumn, td.ratingColumn, .lister-item-header, .inline-block.ratings-imdb-rating. Om din kod använder någon av dessa är den trasig.

Lösning: Föredra data-testid-attribut (som h1[data-testid="hero-title-block__title"]) framför automatiskt genererade klassnamn. Ännu bättre: använd JSON-LD.

Ett beslutsramverk: kortsiktiga vs. långsiktiga lösningar

• Snabb fix: Lägg try/except runt varje selektor, validera HTTP-statuskoder, logga fel i stället för att krascha
• Medellång lösning: Byt från CSS-selektorer till JSON-LD-extrahering (Metod 2)
• Långsiktig lösning: Använd för storskalig analys, eller ett verktyg som som använder AI för att läsa om sidstrukturen från grunden varje gång — inga selektorer att underhålla, AI:n anpassar sig automatiskt till layoutändringar

Förbi 25-resultatsväggen: paginering och stora datamängder på IMDb

Varenda konkurrerande guide jag gick igenom scrape:ar exakt en sida. Ingen tar upp paginering. Men om du behöver mer än en enda lista stöter du snabbt på väggar.

Sidor som inte behöver paginering

Bra nyheter: Top 250-sidan laddar alla 250 filmer i ett enda server-renderat svar. Både JSON-LD och __NEXT_DATA__ innehåller hela datasetet. Ingen paginering krävs.

Så fungerar IMDb:s sökpaginering

IMDb:s söksidor använder URL-parametern start=, som ökas 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

Här är en Python-loop som bläddrar genom resultaten:

1import time
2all_movies = []
3for start in range(1, 1001, 50):  # Bläddrar genom 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"Misslyckades vid start={start}: {response.status_code}")
8        break
9    soup = BeautifulSoup(response.text, "lxml")
10    # Extrahera filmer med din föredragna metod
11    # ...
12    print(f"Scrapade sida som började vid {start}")
13    time.sleep(3)  # Var hänsynsfull — IMDb blockerar efter ~50 snabba förfrågningar

Den där time.sleep(3)-raden spelar roll. Communityrapporter tyder på att IMDb börjar blockera IP-adresser efter ungefär 50 snabba förfrågningar. En slumpmässig fördröjning mellan 2–5 sekunder är god praxis.

När du ska hoppa över scraping helt: IMDb:s officiella bulkdataset

För riktigt stora behov erbjuder IMDb 7 gratis TSV-filer på , uppdaterade dagligen:

Att läsa in dem i Pandas är enkelt:

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

Dessa dataset täcker över 26 miljoner titlar. Ingen paginering, inga selektorer, inga 403-fel. Licensen gäller endast för personligt och icke-kommersiellt bruk — du får inte återpublicera eller sälja datan vidare.

No-code-genvägen: Thunderbit hanterar paginering åt dig

För läsare som behöver IMDb-data med paginering men inte vill skriva pagineringslogik stöder både klickbaserad paginering och oändlig scroll direkt. Du säger åt den att scrapa, så sköter den resten — inklusive att scrolla genom lazy-loaded innehåll.

Scrapa IMDb med Python: den kompletta fungerande koden (redo att klistra in)

Här är två självständiga skript som du kan köra direkt.

Skript A: BeautifulSoup-metoden (CSS-selektorer)

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"Fel: {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"Hoppar över film på grund av fel: {e}")
28df = pd.DataFrame(movies)
29df.to_csv("imdb_top250_bs4.csv", index=False)
30print(f"Sparade {len(df)} filmer")
31print(df.head())

Skript B: JSON-LD-metoden (rekommenderad)

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"Fel: {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 hittades")
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"Sparade {len(df)} filmer")
42print(df.head())

Båda skripten innehåller felhantering och producerar ren CSV-utdata. Skript B ger dig rikare data — regissör, beskrivning, URL — och är mer tåligt mot layoutändringar.

Hur du scrapar IMDb utan att skriva någon kod alls (med Thunderbit)

Alla vill inte eller behöver inte skriva Python. Kanske är du en operationsanalytiker som bara behöver veckans högst rankade filmer i ett kalkylark. Kanske är du en content strategist som vill jämföra genretrender över tid. I sådana fall är det överdrivet att bygga en scraper.

Så här får du samma data med :

Innan du börjar:

• Svårighetsgrad: Nybörjare
• Tidsåtgång: ~2 minuter
• Det du behöver: Chrome-webbläsare, (gratisnivån fungerar)

Steg 1: Gå till IMDb-sidan du vill scrapa. Öppna IMDb Top 250 (eller någon annan IMDb-lista/söksida) i Chrome.

Steg 2: Klicka på "AI Suggest Fields" i Thunderbits sidopanel. AI:n skannar sidan och föreslår kolumner — vanligtvis titel, år, betyg, genre och några fler beroende på sida. Du ser en förhandsgransknings-tabell med de föreslagna fälten.

Steg 3: Justera fälten vid behov. Ta bort kolumner du inte behöver, eller lägg till egna genom att klicka på "+ Add Column" och beskriva vad du vill ha på vanlig engelska (t.ex. "Director name" eller "Number of votes").

Steg 4: Klicka på "Scrape." Thunderbit extraherar datan. För sidor med oändlig scroll eller paginering hanterar den scrollningen automatiskt.

Steg 5: Exportera. Klicka på exportknappen och välj format — Excel, Google Sheets, CSV, Airtable eller Notion. Datan hamnar på sin plats på några sekunder.

Den viktigaste fördelen här är inte bara bekvämlighet — det är att Thunderbit:s AI läser om sidstrukturen varje gång. När IMDb ändrar layouten (och det kommer att hända) anpassar sig AI:n. Inga selektorer att uppdatera, ingen kod att fixa. För alla som någon gång blivit brända av en trasig scraper klockan 2 på natten före en deadline är det värt mycket.

Thunderbit stöder också scraping av undersidor — du kan klicka dig in på varje films detaljsida och berika din tabell med rollista, regissör, speltid och andra fält som inte syns på list-sidan. Om du vill se det i praktiken kan du kolla in .

Är det lagligt att scrapa IMDb? Det här behöver du veta

Användare frågar uttryckligen om detta i forum: "Är något sånt här lagligt?... IMDb vill inte att folk scrape:ar deras webbplats." Det är en rimlig fråga, och ingen konkurrerande artikel tar upp den.

IMDb:s robots.txt: Top 250-listan (/chart/top/), enskilda titelsidor (/title/ttXXXXXXX/) och namnsidor (/name/nmXXXXXXX/) är INTE blockerade av robots.txt. Blockerade sökvägar inkluderar /find, /_json/*, /search/name-text, /user/ur*/ratings och olika AJAX-endpoints. Det finns ingen angiven Crawl-delay.

IMDb:s användarvillkor: Den relevanta klausulen säger: "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 ytterligare klausul förbjuder vidareförsäljning eller kommersiell användning av scrapad data.

Vad detta betyder i praktiken: Nyliga domar från 2024 (Meta v. Bright Data, X Corp v. Bright Data) slog fast att användarvillkor kanske inte binder användare som aldrig godkänt dem — om du scrapar offentligt tillgänglig data utan att logga in är verkställbarheten av ToS omtvistad. Men det här är ett rättsområde som fortfarande utvecklas.

Säkra alternativ: IMDb:s är uttryckligen godkända för personligt och icke-kommersiellt bruk. TMDb:s API är tillåtet med en gratis API-nyckel. Båda är stabila alternativ om du vill hålla dig på den säkra sidan.

Praktisk vägledning: Om du ändå scrapar, använd en hänsynsfull takt (time.sleep(3) mellan förfrågningar), sätt korrekta headers och träffa inte sökvägar som blockeras av robots.txt. För kommersiella projekt, rådgör med en jurist eller använd de officiella dataseten/API:t.

Vi har gått igenom på djupet i Thunderbit-bloggen.

Slutsats: Välj rätt sätt att scrapa IMDb med Python

Den korta versionen:

• BeautifulSoup + CSS-selektorer: Bra för att lära sig grunderna. Räkna med att det går sönder var 6–12:e månad. Ha alltid felhantering.
• JSON-LD-extrahering: Den metod jag skulle rekommendera för alla pågående Python-projekt. Följer Schema.org-standarden, ändras mycket mer sällan än CSS-klasser och ger ren strukturerad data utan JavaScript-rendering.
• __NEXT_DATA__-JSON: Använd detta som komplement för rikare data på enskilda titelsidor (speltid, full rollista, plot, affischbilder).
• IMDb Official Datasets: Bästa valet för storskalig analys. 26M+ titlar, uppdateras dagligen, ingen scraping krävs. Endast för personligt/icke-kommersiellt bruk.
• : Bästa valet för icke-utvecklare eller alla som vill ha data snabbt utan att underhålla kod. AI anpassar sig till layoutändringar, hanterar paginering och exporterar till Excel/Sheets/Airtable/Notion.

Bokmärk den här guiden — jag uppdaterar den när IMDb:s struktur ändras nästa gång. Och om du vill hoppa över koden helt, och se hur snabbt du kan gå från en IMDb-sida till ett rent kalkylark. Om du också jobbar med andra sajter täcker vår guide om hela arbetsflödet.

Vanliga frågor

Är det lagligt att scrapa IMDb?

IMDb:s användarvillkor förbjuder scraping utan medgivande, men om villkoren faktiskt är verkställbara för offentligt tillgänglig data är juridiskt omtvistat efter nyliga domar från 2024. De säkraste alternativen är IMDb:s (personligt/icke-kommersiellt bruk) eller TMDb API (gratis nyckel). Om du ändå scrapar, respektera robots.txt, använd rimliga pauser mellan förfrågningar och undvik blockerade sökvägar. För kommersiellt bruk, rådgör med en jurist.

Varför returnerar min IMDb-scraper tomma resultat?

Nästan alltid beror det på utdaterade CSS-selektorer — klassnamn som td.titleColumn och td.ratingColumn har inte funnits sedan juni 2023. Lösningen är att byta till JSON-LD-extrahering (tolka taggen <script type="application/ld+json">) eller uppdatera dina selektorer till de nuvarande ipc--prefixade klasserna. Kontrollera också att du skickar med en korrekt User-Agent-header, eftersom en saknad header utlöser ett 403-fel som kan se ut som tomma resultat.

Hur scrapar jag mer än 25 resultat från IMDb?

Top 250-sidan laddar alla 250 filmer i ett enda svar — ingen paginering behövs. För sökresultat använder du URL-parametern start= (ökas med 50) för att bläddra genom resultaten. Till exempel: start=1, start=51, start=101. Lägg till time.sleep(3) mellan förfrågningar för att undvika blockering. Alternativt innehåller IMDb:s officiella dataset på över 26 miljoner titlar utan att paginering krävs.

Vad är __NEXT_DATA__ och varför ska jag använda det för att scrapa IMDb?

__NEXT_DATA__ är ett JSON-objekt som bäddas in i en <script id="__NEXT_DATA__">-tagg på IMDb:s React/Next.js-sidor. Det innehåller all strukturerad data som React använder för att rendera sidan — titlar, betyg, rollista, genrer, speltid med mera. Eftersom det representerar den underliggande datamodellen snarare än den visuella layouten är det mer tåligt mot omdesign än CSS-selektorer. Använd det tillsammans med JSON-LD för den mest robusta extraheringen.

Kan jag scrapa IMDb utan att koda?

Ja. Två huvudalternativ: (1) ladda ner IMDb:s — 7 TSV-filer som täcker 26M+ titlar, uppdateras dagligen och är gratis för icke-kommersiellt bruk. (2) Använd , som läser IMDb-sidan, föreslår extraheringsfält automatiskt och exporterar till Excel, Google Sheets eller CSV i två klick — ingen kod, inga selektorer att underhålla.

Läs mer