Extrage IMDb cu Python: cod care chiar funcționează

Dacă ai căutat recent „scrape IMDb with Python”, probabil ai observat ceva: majoritatea tutorialelor pe care le găsești sunt rupte. Nu „puțin învechite” — ci mai degrabă de genul „returnează zero rezultate și o avalanșă de erori NoneType” rupte.

Am petrecut ultimele săptămâni testând fiecare tutorial important de scraping IMDb pe care l-am găsit — GeeksforGeeks, Medium, freeCodeCamp, notebook-uri Kaggle, orice. Din etichetate pentru scraping IMDb, marea majoritate folosesc selectori CSS (td.titleColumn, td.ratingColumn) care nu mai există din iunie 2023, când IMDb și-a redesenat pagina Top 250. Rezultatul? Forumuri pline de dezvoltatori care întreabă „de ce returnează codul meu nimic?” și întreținători ai unor biblioteci populare precum „Nu prea avem ce să facem în afară de a repara fiecare parser”. Acest ghid acoperă două metode Python care chiar funcționează acum, cum să gestionezi paginarea și erorile comune, când Python nu este nici măcar instrumentul potrivit și cum să-ți faci scraperul mai rezistent, ca să nu ajungă și el în cimitirul soluțiilor abandonate.

Ce înseamnă să extragi IMDb cu Python?

Web scraping înseamnă procesul de a extrage programatic date din pagini web — în loc să copiezi și să lipești manual, scrii un script care face asta pentru tine. Când vorbim despre „scraping IMDb”, ne referim la extragerea de date structurate despre filme (titluri, ratinguri, genuri, distribuție, durată, număr de voturi) din paginile IMDb folosind Python.

Stack-ul Python tipic pentru asta implică trei biblioteci: requests (ca să descarce pagina web), BeautifulSoup (ca să parcurgă HTML-ul și să găsească datele) și pandas (ca să organizeze și să exporte rezultatele). Unele tutoriale folosesc și Selenium sau Playwright pentru pagini care necesită randare JavaScript, dar, după cum vei vedea, există și abordări mai rapide.

Un avertisment important: tot ce este în acest ghid a fost verificat pe baza structurii actuale a paginilor IMDb, la mijlocul lui 2025. IMDb schimbă lucrurile aproximativ o dată la 6–12 luni, așa că, dacă citești asta în 2027, e posibil ca unii selectori să se fi schimbat. (Îți voi explica și cum să gestionezi asta.)

De ce să extragi IMDb cu Python? Cazuri reale de utilizare

Înainte să scrii măcar o linie de cod, ce ai face de fapt cu datele IMDb? Răspunsul depinde de cine ești.

Setul de date cu recenzii IMDb este unul dintre cele mai folosite benchmark-uri NLP din lume — lucrarea de bază semnată de Maas et al. (2011) a acumulat , iar setul de date este integrat în TensorFlow, Keras și PyTorch. Pe Hugging Face, setul stanfordnlp/imdb primește 213.321 de descărcări pe lună și a fost folosit la antrenarea a peste 1.500 de modele. Așadar, dacă lucrezi în machine learning, probabil ești deja familiarizat cu datele IMDb.

Dar cazurile de utilizare merg mult dincolo de mediul academic:

Doar piața turismului cinematografic este estimată la . Netflix a cheltuit peste 17 miliarde de dolari pe conținut în 2024, iar este alimentată de recomandări personalizate. Ideea este simplă: datele IMDb susțin decizii reale în mai multe industrii.

Opțiunile tale pentru a obține date IMDb (înainte să scrii o linie de cod)

Aceasta este secțiunea pe care majoritatea tutorialelor o sar. Sar direct la pip install beautifulsoup4 fără să întrebe dacă scrapingul cu Python este, de fapt, abordarea potrivită pentru situația ta.

Iată peisajul complet:

Câteva observații despre aceste opțiuni. Cinemagoer nu a mai avut un release pe PyPI din mai 2023, iar majoritatea parserelor sale s-au rupt după redesignul IMDb din iunie 2025 — nu l-aș recomanda pentru producție acum. TMDb este excelent, dar folosește propriul sistem de rating, nu ratingurile IMDb. Iar API-ul enterprise oficial IMDb costă peste prin AWS Data Exchange, deci nu este o opțiune pentru cei mai mulți dintre noi.

Pentru cititorii care nu vor să scrie deloc cod, citește pagina IMDb, sugerează automat câmpurile de extragere (titlu, rating, an, gen) și exportă în Excel, Google Sheets, Airtable sau Notion în două clicuri. AI-ul se adaptează când IMDb își schimbă aspectul, așa că nu ai selectori de întreținut. Revin la asta mai târziu.

Acum, pentru cei care chiar vor să scrie Python — iată două metode care funcționează.

Metoda 1: Extrage IMDb cu Python folosind BeautifulSoup (abordarea tradițională)

Aceasta este abordarea clasică pe care o vei găsi în majoritatea tutorialelor. Funcționează, dar vreau să fiu sincer: este cea mai fragilă dintre metodele acoperite aici. Numele claselor CSS de pe IMDb sunt generate automat și se schimbă la redesign. Totuși, este cea mai bună metodă ca să înveți fundamentele web scraping-ului.

Pasul 1: Instalează și importă bibliotecile Python

Ai nevoie de patru pachete:

1pip install requests beautifulsoup4 pandas lxml

Ce face fiecare:

• requests — trimite cereri HTTP ca să descarce pagina web
• beautifulsoup4 — parsează HTML-ul, astfel încât să poți căuta elemente specifice
• pandas — organizează datele extrase în tabele și le exportă în CSV/Excel
• lxml — un parser HTML rapid (BeautifulSoup îl poate folosi ca backend)

Blocul de import:

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

Pasul 2: Trimite o cerere HTTP către IMDb

Aici se lovește de primul zid majoritatea începătorilor. IMDb blochează cererile care nu includ un header User-Agent adecvat — vei primi o eroare 403 Forbidden. Șirul implicit de user-agent al Python Requests (python-requests/2.31.0) este detectat imediat.

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"Eșec la obținerea paginii: {response.status_code}")
9else:
10    print("Pagina a fost obținută cu succes")

Headerul Accept-Language contează și el — fără el, IMDb poate returna conținut într-o altă limbă, în funcție de geolocația IP-ului tău.

Pasul 3: Parsează HTML-ul cu BeautifulSoup

După ce ai HTML-ul, creează un obiect BeautifulSoup și începe să cauți elementele potrivite. Deschide pagina IMDb Top 250 în Chrome, dă click dreapta pe un titlu de film și apasă „Inspect” pentru a vedea structura HTML de bază.

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

La mijlocul lui 2025, pagina Top 250 folosește acești selectori:

• Container film: li.ipc-metadata-list-summary-item
• Titlu: h3.ipc-title__text
• An: span.cli-title-metadata-item (primul span)
• Rating: span.ipc-rating-star--rating

Atenție: clasele acelea cu prefixul ipc- sunt generate de sistemul de componente al IMDb. Au fost stabile de la redesignul din iunie 2023, dar nu există nicio garanție că nu se vor schimba din nou.

Pasul 4: Extrage datele despre filme (titlu, an, rating)

Aici mă diferențiez de majoritatea tutorialelor: includ gestionarea erorilor cu try/except. Niciunul dintre ghidurile concurente pe care le-am analizat nu face asta, și exact de aceea codul lor se rupe în tăcere când se schimbă un selector.

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"Eroare la parsarea filmului: {e}")
18        continue
19print(f"Au fost extrase {len(movies)} filme")

Pasul 5: Salvează în CSV sau Excel cu 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())

Exemplu de 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

Funcționează. Dar se bazează pe selectori CSS care se pot rupe oricând — iar asta ne duce la abordarea pe care o recomand cu adevărat.

Metoda 2: Trucul JSON-LD — sari complet peste parsarea HTML

Aceasta este tehnica pe care niciun articol concurent nu o acoperă și cea pe care aș folosi-o pentru orice proiect serios. IMDb încorporează date structurate ca (JavaScript Object Notation for Linked Data) în tag-uri <script type="application/ld+json"> pe fiecare pagină. Aceste date urmează standardul Schema.org, sunt folosite de Google pentru rezultate bogate în căutare și se schimbă mult mai rar decât numele claselor CSS.

Apify IMDb Scraper, un instrument de nivel de producție, folosește ordinea de prioritate a extragerii: „JSON-LD > NEXT_DATA > DOM.” Aceeași ierarhie o recomand și eu.

De ce JSON-LD este mai fiabil decât selectorii CSS

Clase CSS precum ipc-metadata-list-summary-item sunt generate automat de sistemul de componente React al IMDb și se schimbă la fiecare redesign. Schema JSON-LD reprezintă modelul real de date, nu stratul de prezentare. E diferența dintre a citi cuprinsul unei cărți și a încerca să identifici capitolele după dimensiunea fontului.

Pas cu pas: extragerea datelor IMDb din JSON-LD

Pasul 1: Preia pagina

La fel ca înainte — folosește requests cu un header User-Agent adecvat.

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

Pasul 2: Găsește tag-ul script JSON-LD

1script_tag = soup.find("script", {"type": "application/ld+json"})
2if not script_tag:
3    print("Nu s-a găsit JSON-LD pe această pagină")
4else:
5    data = json.loads(script_tag.string)
6    print(f"JSON-LD găsit cu tipul: {data.get('@type', 'necunoscut')}")

Pasul 3: Parsează datele structurate

Pe pagina Top 250, JSON-LD conține un array itemListElement cu toate cele 250 de filme. Fiecare intrare include poziția, numele, URL-ul, aggregateRating, datePublished, genre, description, director și array-uri de actori.

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

Pasul 4: Exportă în CSV

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

Exemplu de 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

Toate cele 250 de filme. Curat, structurat, fără jonglerii cu selectori CSS. Și pentru că aceste date urmează standardul Schema.org (de care Google depinde pentru rezultatele de căutare), este mult mai puțin probabil să se schimbe decât aspectul vizual.

Bonus: __NEXT_DATA__ pentru paginile individuale de film

Pentru date mai bogate din paginile individuale ale titlurilor (durată, distribuție completă, rezumat, imagini de poster), IMDb încorporează și un obiect JSON __NEXT_DATA__. Acestea sunt datele pe care React le folosește pentru a hidrata pagina — nu pot fi eliminate fără să strice site-ul.

1# Pe o pagină individuală de film, cum ar fi /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"]

Folosește JSON-LD pentru paginile de tip listă/tabel, __NEXT_DATA__ pentru paginile individuale de titlu. Aceasta este abordarea de nivel producție.

De ce se tot strică scraperul tău IMDb (și cum îl repari)

Acesta este, de departe, cel mai raportat punct dureros în fiecare forum de scraping IMDb pe care l-am verificat. Utilizatorii scriu: „Unele dintre coduri s-au stricat din cauza schimbărilor de UI” și „Nu mai funcționează în 2024!” — iar răspunsul este, de obicei, liniște sau „încearcă Selenium”.

Cauza principală este migrarea continuă a IMDb către un frontend React/Next.js. Iată cronologia schimbărilor majore care au rupt coduri:

Asta înseamnă aproximativ o schimbare majoră care rupe codul la fiecare 6–12 luni. Dacă scraperul tău depinde de nume de clase CSS, ești pe o bandă rulantă.

Erori comune și cum le repari

Rezultate goale / erori NoneType

Cea mai comună eroare. Vei vedea AttributeError: 'NoneType' object has no attribute 'text'. Asta înseamnă că BeautifulSoup nu a găsit elementul pe care îl căutai — de obicei pentru că numele clasei CSS s-a schimbat sau conținutul este randat de JavaScript.

Remediere: Treci la extragerea JSON-LD (Metoda 2 de mai sus). Datele sunt în răspunsul HTML inițial, fără a fi nevoie de JavaScript.

403 Forbidden

IMDb folosește pentru a detecta și bloca boții. Principalul declanșator este lipsa unui header User-Agent sau unul evident fals. Acest lucru este documentat în proiecte open-source și în , unde un angajat IMDb a recunoscut problema.

Remediere: Include întotdeauna un șir realist de User-Agent de browser și headerul Accept-Language: en-US. Folosește requests.Session() pentru pooling de conexiuni.

Sunt returnate doar 25 de rezultate

Paginile de căutare IMDb și listele „Most Popular” folosesc lazy loading — randă inițial doar aproximativ 25 de rezultate și încarcă restul prin AJAX pe măsură ce derulezi.

Remediere: Folosește paginarea cu parametru URL (acoperită în secțiunea următoare) sau treci la pagina Top 250, care încarcă toate cele 250 de filme într-un singur răspuns.

Selectorii nu mai funcționează dintr-odată

Selectori vechi care nu mai funcționează: td.titleColumn, td.ratingColumn, .lister-item-header, .inline-block.ratings-imdb-rating. Dacă codul tău folosește oricare dintre aceștia, este rupt.

Remediere: Preferă atributele data-testid (precum h1[data-testid="hero-title-block__title"]) în locul claselor generate automat. Și mai bine: folosește JSON-LD.

Un cadru de decizie: remedieri pe termen scurt vs. pe termen lung

• Remediere rapidă: adaugă blocuri try/except în jurul fiecărui selector, validează codurile de status HTTP, loghează erorile în loc să oprești execuția
• Remediere pe termen mediu: treci de la selectori CSS la extragerea JSON-LD (Metoda 2)
• Remediere pe termen lung: folosește pentru analize la scară mare sau un instrument precum care folosește AI pentru a reciti structura paginii de fiecare dată — fără selectori de întreținut, AI-ul se adaptează automat la schimbările de layout

Dincolo de limita de 25 de rezultate: scrapingul paginării IMDb și al seturilor mari de date

Fiecare tutorial concurent pe care l-am analizat extrage exact o singură pagină. Nimeni nu acoperă paginarea. Dar dacă ai nevoie de mai mult decât o singură listă, vei întâlni rapid limite.

Pagini care nu au nevoie de paginare

Veste bună: pagina Top 250 încarcă toate cele 250 de filme într-un singur răspuns randat pe server. Atât JSON-LD, cât și __NEXT_DATA__ conțin setul complet de date. Nu este nevoie de paginare.

Cum funcționează paginarea căutărilor IMDb

Paginile de căutare IMDb folosesc un parametru URL start=, care crește cu 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

Iată o buclă Python care parcurge rezultatele pe pagini:

1import time
2all_movies = []
3for start in range(1, 1001, 50):  # Parcurge 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"Eșec la start={start}: {response.status_code}")
8        break
9    soup = BeautifulSoup(response.text, "lxml")
10    # Extrage filmele folosind metoda preferată
11    # ...
12    print(f"Pagina extrasă, începând cu {start}")
13    time.sleep(3)  # Fii rezonabil — IMDb blochează după ~50 de cereri rapide

time.sleep(3) chiar contează. Rapoartele din comunitate sugerează că IMDb începe să blocheze IP-urile după aproximativ 50 de cereri rapide. O întârziere aleatorie între 2–5 secunde este o practică bună.

Când să sari complet peste scraping: seturile oficiale de date IMDb

Pentru nevoi cu adevărat mari, IMDb oferă 7 fișiere TSV gratuite la , actualizate zilnic:

Încărcarea lor în Pandas este simplă:

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# Unește pe tconst (ID-ul titlului IMDb)
4merged = basics.merge(ratings, on="tconst")
5top_movies = merged[merged["titleType"] == "movie"].nlargest(250, "averageRating")

Aceste seturi de date acoperă peste 26 de milioane de titluri. Fără paginare, fără selectori, fără erori 403. Licența este doar pentru uz personal și necomercial — nu poți republica sau revinde datele.

Scurtătura no-code: Thunderbit gestionează paginarea pentru tine

Pentru cititorii care au nevoie de date IMDb paginate, dar nu vor să scrie logică de paginare, acceptă nativ atât paginarea prin clic, cât și infinite scroll. Îi spui ce să extragă, iar el se ocupă de restul — inclusiv de derularea conținutului încărcat lazy.

Extrage IMDb cu Python: codul complet care funcționează (gata de copy-paste)

Iată două scripturi autonome pe care le poți rula chiar acum.

Scriptul A: metoda BeautifulSoup (selectori CSS)

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"Eroare: {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"Sar filmul din cauza erorii: {e}")
28df = pd.DataFrame(movies)
29df.to_csv("imdb_top250_bs4.csv", index=False)
30print(f"Au fost salvate {len(df)} filme")
31print(df.head())

Scriptul B: metoda JSON-LD (recomandată)

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"Eroare: {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("Nu s-au găsit date JSON-LD")
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"Au fost salvate {len(df)} filme")
42print(df.head())

Ambele scripturi includ gestionarea erorilor și produc un output CSV curat. Scriptul B îți oferă date mai bogate — regizor, descriere, URL — și este mai rezistent la schimbările de layout.

Cum să extragi IMDb fără să scrii niciun cod (folosind Thunderbit)

Nu toată lumea are nevoie sau vrea să scrie Python. Poate ești analist operațional și ai nevoie doar de filmele cu ratingul cel mai mare din săptămâna aceasta într-un spreadsheet. Poate ești strategist de conținut și vrei să compari tendințele de gen pe ani. În astfel de cazuri, să scrii un scraper este prea mult.

Iată cum obții aceleași date folosind :

Înainte să începi:

• Dificultate: Începător
• Timp necesar: ~2 minute
• Ce îți trebuie: browser Chrome, (funcționează și varianta gratuită)

Pasul 1: navighează la pagina IMDb pe care vrei s-o extragi. Deschide IMDb Top 250 (sau orice altă pagină de listă/căutare IMDb) în Chrome.

Pasul 2: apasă „AI Suggest Fields” în bara laterală Thunderbit. AI-ul scanează pagina și recomandă coloane — de obicei Titlu, An, Rating, Gen și câteva altele, în funcție de pagină. Vei vedea un tabel de previzualizare cu câmpurile sugerate.

Pasul 3: ajustează câmpurile dacă este nevoie. Elimină coloanele de care nu ai nevoie sau adaugă unele personalizate apăsând „+ Add Column” și descriind în limbaj natural ce vrei (de exemplu, „numele regizorului” sau „numărul de voturi”).

Pasul 4: apasă „Scrape”. Thunderbit extrage datele. Pentru pagini cu infinite scroll sau paginare, se ocupă automat de derulare.

Pasul 5: exportă. Apasă butonul de export și alege formatul — Excel, Google Sheets, CSV, Airtable sau Notion. Datele ajung în destinație în câteva secunde.

Avantajul principal nu este doar comoditatea — ci faptul că AI-ul Thunderbit citește structura paginii de fiecare dată de la zero. Când IMDb își schimbă layoutul (și o va face), AI-ul se adaptează. Fără selectori de actualizat, fără cod de reparat. Pentru oricine a fost pățit de un scraper rupt la 2 dimineața, înainte de un deadline, asta valorează mult.

Thunderbit suportă și scrapingul subpaginilor — poți intra în pagina de detalii a fiecărui film și poți îmbogăți tabelul cu distribuție, regizor, durată și alte câmpuri care nu sunt vizibile pe pagina de listă. Dacă vrei să-l vezi în acțiune, verifică .

Este legal să extragi IMDb? Ce trebuie să știi

Utilizatorii întreabă explicit asta în forumuri: „E ceva de genul ăsta legal?... IMDb nu vrea ca oamenii să-i extragă datele de pe site.” Este o întrebare corectă, iar niciun articol concurent nu abordează subiectul.

robots.txt de la IMDb: graficul Top 250 (/chart/top/), paginile individuale de titlu (/title/ttXXXXXXX/) și paginile de nume (/name/nmXXXXXXX/) NU sunt blocate de robots.txt. Căile blocate includ /find, /_json/*, /search/name-text, /user/ur*/ratings și diverse endpoint-uri AJAX. Nu există nicio directivă Crawl-delay specificată.

Termenii de utilizare IMDb: clauza relevantă spune: „Nu aveți voie să folosiți data mining, roboți, screen scraping sau instrumente similare de colectare și extragere de date pe acest site, cu excepția cazului în care avem consimțământul nostru scris explicit.” O altă clauză interzice revânzarea sau utilizarea comercială a datelor extrase.

Ce înseamnă asta în practică: hotărâri recente din 2024 (Meta v. Bright Data, X Corp v. Bright Data) au arătat că Termenii de utilizare s-ar putea să nu fie opozabili utilizatorilor care nu au acceptat niciodată acei termeni — dacă extragi date disponibile public fără autentificare, aplicabilitatea ToS este discutabilă. Dar acest domeniu juridic este în continuă evoluție.

Alternative sigure: seturile de date descărcabile oficial de la IMDb sunt explicit aprobate pentru uz personal și necomercial. API-ul TMDb este permisiv cu o cheie API gratuită. Ambele sunt opțiuni solide dacă vrei să rămâi în zona sigură.

Recomandare practică: dacă totuși extragi, folosește o rată de crawling respectuoasă (time.sleep(3) între cereri), setează header-ele corecte și nu accesa căile blocate de robots.txt. Pentru proiecte comerciale, consultă un specialist juridic sau folosește seturile oficiale de date/API-ul.

Am acoperit în detaliu pe blogul Thunderbit.

Concluzie: alege metoda potrivită pentru extragerea IMDb cu Python

Pe scurt:

• BeautifulSoup + selectori CSS: bun pentru a învăța fundamentele. Așteaptă-te să se rupă la fiecare 6–12 luni. Include mereu gestionarea erorilor.
• Extragere JSON-LD: abordarea pe care o recomand pentru orice proiect Python în desfășurare. Urmează standardul Schema.org, se schimbă mult mai rar decât clasele CSS și oferă date structurate curate fără randare JavaScript.
• JSON __NEXT_DATA__: folosește-l ca supliment pentru date mai bogate pe paginile individuale de titlu (durată, distribuție completă, plot, imagini poster).
• Seturile oficiale de date IMDb: cea mai bună alegere pentru analiză la scară mare. Peste 26M de titluri, actualizare zilnică, fără scraping. Doar uz personal/necomercial.
• : cea mai bună alegere pentru cei fără cod sau pentru oricine vrea date rapid, fără să întrețină cod. AI-ul se adaptează la schimbările de layout, gestionează paginarea și exportă în Excel/Sheets/Airtable/Notion.

Salvează acest ghid la favorite — îl voi actualiza când structura IMDb se schimbă din nou. Și dacă vrei să sari complet peste cod, și vezi cât de repede poți trece de la o pagină IMDb la un spreadsheet curat. Dacă lucrezi și cu alte site-uri, ghidul nostru despre acoperă fluxul de lucru mai amplu.

Întrebări frecvente

Este legal să extragi date din IMDb?

Termenii de utilizare IMDb interzic scrapingul fără consimțământ, dar aplicabilitatea acestor termeni asupra datelor accesibile public este discutabilă juridic după hotărâri recente din 2024. Cele mai sigure opțiuni sunt (uz personal/necomercial) sau API-ul TMDb (cheie gratuită). Dacă totuși extragi date, respectă robots.txt, folosește întârzieri rezonabile între cereri și evită căile blocate. Pentru uz comercial, consultă un specialist juridic.

De ce scraperul meu IMDb returnează rezultate goale?

Aproape întotdeauna cauza sunt selectori CSS învechiți — clase precum td.titleColumn și td.ratingColumn nu mai există din iunie 2023. Soluția este să treci la extragerea JSON-LD (să parsezi tag-ul <script type="application/ld+json">) sau să actualizezi selectorii la clasele actuale cu prefix ipc-. Verifică și dacă trimiți un header User-Agent corect, deoarece lipsa lui declanșează o eroare 403 care poate părea un rezultat gol.

Cum extrag mai mult de 25 de rezultate din IMDb?

Pagina Top 250 încarcă toate cele 250 de filme într-un singur răspuns — nu ai nevoie de paginare. Pentru rezultatele de căutare, folosește parametrul URL start= (incrementat cu 50) ca să navighezi printre pagini. De exemplu: start=1, start=51, start=101. Adaugă time.sleep(3) între cereri ca să eviți blocarea. Alternativ, seturile oficiale de date IMDb de la conțin peste 26M de titluri și nu necesită paginare.

Ce este __NEXT_DATA__ și de ce ar trebui să-l folosesc pentru scraping IMDb?

__NEXT_DATA__ este un obiect JSON încorporat într-un tag <script id="__NEXT_DATA__"> pe paginile React/Next.js ale IMDb. Conține datele structurate complete pe care React le folosește pentru a reda pagina — titluri, ratinguri, distribuție, genuri, durată și altele. Pentru că reprezintă modelul de date de bază, nu layoutul vizual, este mai rezistent la redesign-uri UI decât selectorii CSS. Folosește-l împreună cu JSON-LD pentru cea mai robustă abordare de extracție.

Pot extrage IMDb fără să programez?

Da. Două opțiuni principale: (1) descarcă — 7 fișiere TSV care acoperă peste 26M de titluri, actualizate zilnic, gratuite pentru uz necomercial. (2) folosește , care citește pagina IMDb, sugerează automat câmpurile de extragere și exportă în Excel, Google Sheets sau CSV în două clicuri — fără cod, fără selectori de întreținut.

Află mai multe