Scrape IMDb pomocí Pythonu: Kód, který opravdu funguje

Pokud jste v poslední době hledali „scrape IMDb with Python“, nejspíš jste si všimli jedné věci: většina návodů, na které narazíte, je rozbitá. Ne ve smyslu „trochu zastaralá“ — spíš ve stylu „vrací nula výsledků a hromadu chyb NoneType“.

Posledních pár týdnů jsem testoval každý větší návod na scraping IMDb, který jsem našel — GeeksforGeeks, Medium, freeCodeCamp, Kaggle notebooky, prostě všechno. Z označených pro scraping IMDb většina odkazuje na CSS selektory (td.titleColumn, td.ratingColumn), které už od června 2023, kdy IMDb přepracovalo stránku Top 250, neexistují. Výsledek? Fóra plná vývojářů, kteří se ptají „proč můj kód vrací prázdno?“, a správci populárních knihoven jako , že „moc s tím nenaděláme, kromě opravy každého parseru“. Tento průvodce pokrývá dvě Python metody, které dnes opravdu fungují, jak řešit stránkování a běžné chyby, kdy Python vlastně není správný nástroj a jak si scraper připravit na budoucí změny, aby neskončil na hřbitově nástrojů, které přestaly fungovat.

Co znamená scrapovat IMDb pomocí Pythonu?

Web scraping je proces programového získávání dat z webových stránek — místo ručního kopírování a vkládání napíšete skript, který to udělá za vás. Když mluvíme o „scrapování IMDb“, myslíme tím získávání strukturovaných filmových dat (názvy, hodnocení, žánry, herecké obsazení, délka, počet hlasů) z webových stránek IMDb pomocí Pythonu.

Typický Python stack pro tenhle úkol tvoří tři knihovny: requests (pro načtení stránky), BeautifulSoup (pro parsování HTML a vyhledání dat) a pandas (pro organizaci a export výsledků). Některé návody také používají Selenium nebo Playwright pro stránky, které vyžadují renderování JavaScriptem, ale jak uvidíte, existují rychlejší přístupy.

Jedno důležité upozornění: vše v tomto průvodci je ověřeno podle aktuální struktury stránek IMDb k polovině roku 2025. IMDb mění rozvržení zhruba každých 6–12 měsíců, takže pokud tohle čtete v roce 2027, některé selektory se mohly změnit. (I tohle si ukážeme, jak řešit.)

Proč scrapovat IMDb pomocí Pythonu? Reálné scénáře použití

Než napíšete jediný řádek kódu, co byste vlastně s daty z IMDb dělali? Odpověď záleží na tom, kdo jste.

Datový soubor recenzí IMDb je jedním z nejpoužívanějších benchmarků pro NLP na světě — zásadní práce Maas et al. (2011) nasbírala a dataset je přímo součástí TensorFlow, Keras i PyTorch. Na Hugging Face dostává dataset stanfordnlp/imdb 213 321 stažení měsíčně a byl použit k tréninku více než 1 500 modelů. Pokud se pohybujete v machine learningu, s daty IMDb už jste pravděpodobně přišli do styku.

Ale využití sahá mnohem dál než do akademie:

Jen trh filmové turistiky má odhadovanou hodnotu . Netflix v roce 2024 utratil za obsah přes 17 miliard dolarů a bylo poháněno personalizovanými doporučeními. Pointa je jednoduchá: data z IMDb ovlivňují skutečná rozhodnutí napříč obory.

Možnosti, jak získat data z IMDb (než napíšete jediný řádek kódu)

Tohle je část, kterou většina návodů úplně přeskočí. Hned skočí na pip install beautifulsoup4, aniž by se zeptaly, jestli je scraping v Pythonu vůbec správná cesta pro vaši situaci.

Tady je kompletní přehled:

K těmto možnostem pár poznámek. Cinemagoer neměl vydání na PyPI od května 2023 a většina jeho parserů se po červnovém redesignu IMDb v roce 2025 rozbila — pro produkční použití bych ho teď nedoporučil. TMDb je výborné, ale používá vlastní systém hodnocení, ne hodnocení IMDb. A oficiální enterprise API IMDb stojí přes přes AWS Data Exchange, takže to pro většinu z nás není realistická volba.

Pro čtenáře, kteří nechtějí psát žádný kód, načte stránku IMDb, automaticky navrhne extrakční pole (název, hodnocení, rok, žánr) a exportuje do Excelu, Google Sheets, Airtable nebo Notionu na dvě kliknutí. AI se přizpůsobí, když IMDb změní rozvržení, takže není potřeba udržovat žádné selektory. Více o tom za chvíli.

A teď pro ty, kdo Python psát chtějí — tady jsou dvě metody, které fungují.

Metoda 1: Scraping IMDb v Pythonu pomocí BeautifulSoup (tradiční přístup)

Tohle je klasický postup, který najdete ve většině návodů. Funguje, ale řeknu to na rovinu: je to nejkřehčí z metod, které tu popisuji. CSS názvy tříd IMDb se generují automaticky a s redesigny se mění. Na druhou stranu je to nejlepší způsob, jak se naučit základy web scrapingu.

Krok 1: Nainstalujte a importujte Python knihovny

Potřebujete čtyři balíčky:

1pip install requests beautifulsoup4 pandas lxml

Co dělá každý z nich:

• requests — posílá HTTP požadavky a načítá webovou stránku
• beautifulsoup4 — parsuje HTML, abyste mohli hledat konkrétní prvky
• pandas — organizuje získaná data do tabulek a exportuje je do CSV/Excelu
• lxml — rychlý HTML parser (BeautifulSoup ho může použít jako backend)

Importy:

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

Krok 2: Pošlete HTTP požadavek na IMDb

Tady většina začátečníků narazí na první problém. IMDb blokuje požadavky, které nemají správnou hlavičku User-Agent — dostanete chybu 403 Forbidden. Výchozí user-agent string v Python Requests (python-requests/2.31.0) je okamžitě označen.

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"Failed to fetch page: {response.status_code}")
9else:
10    print("Page fetched successfully")

Hlavička Accept-Language je důležitá taky — bez ní může IMDb vrátit obsah v jiném jazyce podle geolokace vaší IP adresy.

Krok 3: Parsujte HTML pomocí BeautifulSoup

Jakmile máte HTML, vytvořte objekt BeautifulSoup a začněte hledat správné prvky. Otevřete stránku IMDb Top 250 v Chromu, klikněte pravým tlačítkem na název filmu a zvolte „Inspect“, abyste viděli podkladovou HTML strukturu.

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

K polovině roku 2025 stránka Top 250 používá tyto selektory:

• Kontejner filmu: li.ipc-metadata-list-summary-item
• Název: h3.ipc-title__text
• Rok: span.cli-title-metadata-item (první span)
• Hodnocení: span.ipc-rating-star--rating

Malé varování: tyto názvy tříd začínající ipc- generuje systém komponent IMDb. Od redesignu v červnu 2023 jsou stabilní, ale žádná záruka, že se znovu nezmění, neexistuje.

Krok 4: Extrahujte data o filmech (název, rok, hodnocení)

Tady se liším od většiny návodů: přidávám ošetření chyb pomocí try/except. Žádný z konkurenčních průvodců, které jsem prošel, to nedělá, a právě proto jejich kód potichu selže, jakmile se změní selektor.

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"Error parsing movie: {e}")
18        continue
19print(f"Extracted {len(movies)} movies")

Krok 5: Uložte do CSV nebo Excelu pomocí 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())

Ukázkový výstup:

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

To funguje. Ale drží to pohromadě díky CSS selektorům, které se můžou rozpadnout kdykoli — a právě proto se dostáváme k přístupu, který ve skutečnosti doporučuji.

Metoda 2: Trik s JSON-LD — vynechte parsování HTML úplně

Tohle je technika, kterou žádný konkurenční článek nepokrývá, a je to metoda, kterou bych použil u jakéhokoli seriózního projektu. IMDb vkládá strukturovaná data jako (JavaScript Object Notation for Linked Data) do značek <script type="application/ld+json"> na každé stránce. Tato data odpovídají standardu Schema.org, Google je používá pro rozšířené výsledky vyhledávání a mění se mnohem méně často než CSS názvy tříd.

Apify IMDb Scraper, nástroj pro produkční nasazení, používá pořadí priorit extrakce: „JSON-LD > NEXT_DATA > DOM“. Přesně tuhle hierarchii bych doporučil taky.

Proč je JSON-LD spolehlivější než CSS selektory

CSS názvy tříd jako ipc-metadata-list-summary-item IMDb generuje automaticky v systému React komponent a mění je s každým redesignem. Schema JSON-LD představuje skutečný datový model, ne vizuální vrstvu. Je to podobné jako rozdíl mezi čtením obsahu knihy a pokusem určit kapitoly podle velikosti písma.

Krok za krokem: Získání dat z IMDb přes JSON-LD

Krok 1: Načtěte stránku

Stejně jako předtím — použijte requests se správnou hlavičkou User-Agent.

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

Krok 2: Najděte značku script s JSON-LD

1script_tag = soup.find("script", {"type": "application/ld+json"})
2if not script_tag:
3    print("Na této stránce se nenašlo JSON-LD")
4else:
5    data = json.loads(script_tag.string)
6    print(f"Nalezeno JSON-LD s typem: {data.get('@type', 'unknown')}")

Krok 3: Parsujte strukturovaná data

Na stránce Top 250 obsahuje JSON-LD pole itemListElement se všemi 250 filmy. Každá položka obsahuje pozici, název, URL, aggregateRating, datePublished, genre, description, director a pole actor.

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

Krok 4: Exportujte do CSV

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

Ukázkový výstup:

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

Všech 250 filmů. Čistě, strukturovaně, bez gymnastiky s CSS selektory. A protože tato data vycházejí ze standardu Schema.org (na kterém Google staví výsledky vyhledávání), je mnohem méně pravděpodobné, že se změní oproti vizuálnímu rozvržení.

Bonus: __NEXT_DATA__ pro jednotlivé stránky filmů

Pro bohatší data z detailních stránek titulů (délka, kompletní obsazení, děj, plakáty) vkládá IMDb také JSON objekt __NEXT_DATA__. To jsou data, která React používá k „hydrataci“ stránky — nelze je odstranit, aniž by se rozbily samotné stránky.

1# Na stránce konkrétního filmu, například /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"]

Pro seznamové a žebříčkové stránky používejte JSON-LD, pro jednotlivé stránky titulů __NEXT_DATA__. To je produkčně použitelný přístup.

Proč se vám scraper IMDb pořád rozbíjí (a jak to opravit)

Tohle je jednoznačně nejčastěji hlášený problém ve všech fórech o scrapingu IMDb, která jsem kontroloval. Uživatelé píšou: „Část kódu se rozbila kvůli změnám UI“ a „V roce 2024 to nefunguje!“ — a odpověď bývá většinou ticho nebo „zkuste Selenium“.

Kořen problému je neustálý přechod IMDb na frontend v React/Next.js. Tady je časová osa hlavních změn, které rozbily původní scrapers:

To je zhruba jedna zásadní změna každých 6–12 měsíců. Pokud váš scraper stojí na názvech CSS tříd, běžíte na běžícím pásu.

Běžné chyby a jak je opravit

Prázdné výsledky / chyby NoneType

Nejčastější chyba. Uvidíte AttributeError: 'NoneType' object has no attribute 'text'. To znamená, že BeautifulSoup nenašel prvek, který hledáte — obvykle proto, že se změnil název CSS třídy nebo je obsah vykreslován JavaScriptem.

Řešení: Přepněte na extrakci JSON-LD (metoda 2 výše). Data jsou v úvodní HTML odpovědi, bez potřeby JavaScriptu.

403 Forbidden

IMDb používá k detekci a blokování botů. Nejčastější spouštěč je chybějící nebo zjevně falešná hlavička User-Agent. Je to zdokumentované napříč open-source projekty i , kde zaměstnanec IMDb problém potvrdil.

Řešení: Vždy přidávejte realistický browserový User-Agent a hlavičku Accept-Language: en-US. Používejte requests.Session() pro pooling spojení.

Vrací se jen 25 výsledků

Vyhledávací stránky IMDb a seznamy „Most Popular“ používají lazy loading — zpočátku vykreslí jen asi 25 výsledků a další načítají přes AJAX při scrollování.

Řešení: Použijte stránkování přes URL parametr (popsané v další části), nebo přepněte na stránku Top 250, která načte všech 250 filmů v jediné odpovědi.

Selektory najednou přestanou fungovat

Staré selektory, které už nefungují: td.titleColumn, td.ratingColumn, .lister-item-header, .inline-block.ratings-imdb-rating. Pokud váš kód používá některý z nich, je rozbitý.

Řešení: Preferujte atributy data-testid (například h1[data-testid="hero-title-block__title"]) před automaticky generovanými názvy tříd. Ještě lépe: použijte JSON-LD.

Rozhodovací rámec: krátkodobé vs. dlouhodobé opravy

• Rychlá oprava: Přidejte kolem každého selektoru bloky try/except, ověřujte HTTP status kódy, logujte chyby místo pádu programu
• Střednědobá oprava: Přepněte z CSS selektorů na extrakci JSON-LD (metoda 2)
• Dlouhodobá oprava: Pro rozsáhlé analýzy použijte , nebo nástroj jako , který pomocí AI při každém spuštění znovu přečte strukturu stránky — bez selektorů, které byste museli udržovat; AI se na změny rozvržení přizpůsobí automaticky

Za hranici 25 výsledků: stránkování IMDb a velké datasety

Každý konkurenční návod, který jsem prošel, scrapuje přesně jednu stránku. Nikdo neřeší stránkování. Ale pokud potřebujete víc než jeden seznam, narazíte rychle na limity.

Stránky, které stránkování nepotřebují

Dobrá zpráva: stránka Top 250 načítá všech 250 filmů v jediné serverově generované odpovědi. JSON-LD i __NEXT_DATA__ obsahují kompletní dataset. Žádné stránkování není potřeba.

Jak funguje stránkování ve vyhledávání IMDb

Vyhledávací stránky IMDb používají URL parametr start=, který se zvyšuje po 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

Tady je Python smyčka, která prochází výsledky stránku po stránce:

1import time
2all_movies = []
3for start in range(1, 1001, 50):  # Prochází 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"Failed at start={start}: {response.status_code}")
8        break
9    soup = BeautifulSoup(response.text, "lxml")
10    # Vyextrahujte filmy pomocí metody, kterou preferujete
11    # ...
12    print(f"Scraped page starting at {start}")
13    time.sleep(3)  # Buďte ohleduplní — IMDb blokuje po ~50 rychlých požadavcích

time.sleep(3) je důležitý. Zkušenosti komunity naznačují, že IMDb začíná blokovat IP adresy po zhruba 50 rychlých požadavcích. Náhodná prodleva 2–5 sekund je dobrá praxe.

Kdy scrapování přeskočit úplně: oficiální bulk datasety IMDb

Pro opravdu rozsáhlé potřeby poskytuje IMDb 7 bezplatných TSV souborů na , aktualizovaných denně:

Načtení do Pandas je jednoduché:

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# Sloučení přes tconst (IMDb ID titulu)
4merged = basics.merge(ratings, on="tconst")
5top_movies = merged[merged["titleType"] == "movie"].nlargest(250, "averageRating")

Tyto datasety pokrývají více než 26 milionů titulů. Žádné stránkování, žádné selektory, žádné chyby 403. Licence je pouze pro osobní a nekomerční použití — data nesmíte znovu publikovat ani prodávat.

Zkratka bez kódu: Thunderbit za vás zvládne stránkování

Pro čtenáře, kteří potřebují data z IMDb po stránkách, ale nechtějí psát logiku stránkování, nativně podporuje jak stránkování přes klikání, tak infinite scroll. Vy řeknete, co má scrapovat, a on udělá zbytek — včetně procházení lazy-loaded obsahu.

Scraping IMDb v Pythonu: kompletní funkční kód připravený ke kopírování

Tady jsou dva samostatné skripty, které můžete spustit hned teď.

Skript A: metoda BeautifulSoup (CSS selektory)

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"Chyba: {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"Přeskakuji film kvůli chybě: {e}")
28df = pd.DataFrame(movies)
29df.to_csv("imdb_top250_bs4.csv", index=False)
30print(f"Uloženo {len(df)} filmů")
31print(df.head())

Skript B: metoda JSON-LD (doporučeno)

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"Chyba: {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("Nenašla se žádná data 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"Uloženo {len(df)} filmů")
42print(df.head())

Oba skripty obsahují ošetření chyb a vytvářejí čistý CSV výstup. Skript B vám dá bohatší data — režiséra, popis, URL — a je odolnější vůči změnám rozvržení.

Jak scrapovat IMDb bez psaní kódu (s Thunderbitem)

Ne každý potřebuje nebo chce psát Python. Možná jste provozní analytik a jen potřebujete hodnocení top filmů tohoto týdne v tabulce. Možná jste content stratég a chcete porovnat trendy žánrů napříč roky. V takových případech je psaní vlastního scraperu zbytečné.

Takhle získáte stejná data pomocí :

Než začnete:

• Obtížnost: Začátečník
• Čas potřebný: ~2 minuty
• Co budete potřebovat: Prohlížeč Chrome, (funguje i zdarma)

Krok 1: Otevřete stránku IMDb, kterou chcete scrapovat. Otevřete Top 250 IMDb (nebo jakoukoli jinou stránku se seznamem/vyhledáváním IMDb) v Chromu.

Krok 2: Klikněte na „AI Suggest Fields“ v bočním panelu Thunderbitu. AI projde stránku a navrhne sloupce — obvykle Název, Rok, Hodnocení, Žánr a podle stránky i několik dalších. Uvidíte náhled tabulky s navrženými poli.

Krok 3: Upravte pole podle potřeby. Odstraňte sloupce, které nepotřebujete, nebo přidejte vlastní kliknutím na „+ Add Column“ a popisem požadovaného pole obyčejnou angličtinou (např. „Director name“ nebo „Number of votes“).

Krok 4: Klikněte na „Scrape“. Thunderbit data vytáhne. U stránek s infinite scroll nebo stránkováním zvládne posouvání automaticky.

Krok 5: Exportujte. Klikněte na tlačítko exportu a zvolte formát — Excel, Google Sheets, CSV, Airtable nebo Notion. Data se do cíle dostanou během několika sekund.

Hlavní výhoda není jen pohodlí — je to to, že AI Thunderbitu při každém spuštění znovu čte strukturu stránky. Když IMDb změní rozvržení (a změní), AI se přizpůsobí. Žádné selektory, které by bylo nutné upravovat, žádný kód k opravování. Pro každého, komu se rozbitý scraper rozpadl ve dvě ráno před deadlinem, je to k nezaplacení.

Thunderbit navíc podporuje scrapování podstránek — můžete kliknout na detail každého filmu a obohatit tabulku o obsazení, režiséra, délku a další pole, která na seznamové stránce nejsou vidět. Pokud to chcete vidět v akci, mrkněte na .

Je scrapování IMDb legální? Co potřebujete vědět

Uživatelé se na to ve fórech ptají napřímo: „Je něco takového legální?… IMDb nechce, aby lidé scrapovali jejich web.“ Je to férová otázka a žádný konkurenční článek ji pořádně neřeší.

robots.txt IMDb: Top 250 chart (/chart/top/), jednotlivé stránky titulů (/title/ttXXXXXXX/) a stránky osob (/name/nmXXXXXXX/) nejsou v robots.txt blokované. Mezi blokované cesty patří /find, /_json/*, /search/name-text, /user/ur*/ratings a různé AJAX endpointy. Není zde uveden direktiv Crawl-delay.

Podmínky použití IMDb: Příslušná klauzule říká: „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.“ Další klauzule zakazuje přeprodej nebo komerční použití získaných dat.

Co to znamená v praxi: Nedávná soudní rozhodnutí z roku 2024 (Meta v. Bright Data, X Corp v. Bright Data) dospěla k závěru, že podmínky používání nemusí zavazovat uživatele, kteří je nikdy výslovně nepřijali — pokud scrapujete veřejně dostupná data bez přihlášení, vymahatelnost ToS je sporná. Jde ale o právní oblast, která se stále vyvíjí.

Bezpečnější alternativy: Oficiální jsou výslovně schválené pro osobní a nekomerční použití. API TMDb je s bezplatným API klíčem velmi vstřícné. Obojí jsou solidní možnosti, pokud se chcete držet zcela bezpečně.

Praktické doporučení: Pokud scrapujete, používejte ohleduplné tempo (time.sleep(3) mezi požadavky), nastavte správné hlavičky a nevolejte cesty blokované v robots.txt. U komerčních projektů se poraďte s právníkem nebo použijte oficiální datasety/API.

Právní dopady web scrapingu jsme na blogu Thunderbitu rozebrali podrobně v článku .

Závěr: Zvolte správný způsob, jak scrapovat IMDb pomocí Pythonu

Stručná verze:

• BeautifulSoup + CSS selektory: Dobré pro naučení základů. Počítejte s tím, že se to rozbije každých 6–12 měsíců. Vždy přidejte ošetření chyb.
• Extrakce JSON-LD: Přístup, který bych doporučil pro jakýkoli dlouhodobější Python projekt. Vychází ze standardu Schema.org, mění se mnohem méně často než CSS třídy a dá vám čistá strukturovaná data bez renderování JavaScriptem.
• JSON __NEXT_DATA__: Používejte jako doplněk pro bohatší data na jednotlivých stránkách titulů (délka, kompletní obsazení, děj, plakáty).
• Oficiální datasety IMDb: Nejlepší volba pro rozsáhlé analýzy. Více než 26 milionů titulů, denní aktualizace, bez scrapování. Jen pro osobní/nekomerční použití.
• : Nejlepší volba pro lidi bez programování nebo pro každého, kdo chce data rychle bez údržby kódu. AI se přizpůsobí změnám rozvržení, zvládá stránkování a exportuje do Excelu/Sheets/Airtable/Notion.

Uložte si tenhle průvodce do záložek — aktualizuji ho, až se struktura IMDb příště změní. A pokud chcete přeskočit kód úplně, a podívejte se, jak rychle se z IMDb stránky dostanete k čisté tabulce. Pokud pracujete i s jinými weby, náš průvodce pokrývá širší workflow.

Časté dotazy

Je scrapování IMDb legální?

Podmínky použití IMDb zakazují scraping bez souhlasu, ale vymahatelnost ToS u veřejně dostupných dat je po nedávných rozhodnutích z roku 2024 právně sporná. Nejschůdnější a nejbezpečnější možnosti jsou oficiální (osobní/nekomerční použití) nebo API TMDb (zdarma klíč). Pokud scrapujete, respektujte robots.txt, používejte rozumné prodlevy mezi požadavky a vyhněte se blokovaným cestám. Pro komerční využití se poraďte s právníkem.

Proč můj scraper IMDb vrací prázdné výsledky?

Téměř vždy je příčinou zastaralý CSS selektor — názvy tříd jako td.titleColumn a td.ratingColumn od června 2023 neexistují. Řešením je přejít na extrakci JSON-LD (parsujte značku <script type="application/ld+json">) nebo aktualizovat selektory na aktuální třídy začínající ipc-. Také si ověřte, že posíláte správnou hlavičku User-Agent, protože její absence vyvolá chybu 403, která se může projevit jako prázdný výsledek.

Jak scrapovat více než 25 výsledků z IMDb?

Stránka Top 250 načítá všech 250 filmů v jedné odpovědi — stránkování není potřeba. U výsledků vyhledávání použijte URL parametr start= (zvyšovaný po 50), abyste procházeli výsledky stránku po stránce. Například: start=1, start=51, start=101. Mezi požadavky přidejte time.sleep(3), abyste se vyhnuli blokaci. Alternativně oficiální datasety IMDb na obsahují více než 26 milionů titulů a žádné stránkování nepotřebují.

Co je __NEXT_DATA__ a proč ho používat pro scraping IMDb?

__NEXT_DATA__ je JSON objekt vložený do značky <script id="__NEXT_DATA__"> na stránkách IMDb postavených na React/Next.js. Obsahuje kompletní strukturovaná data, která React používá k vykreslení stránky — názvy, hodnocení, obsazení, žánry, délku a další údaje. Protože odráží podkladový datový model, ne vizuální rozvržení, je vůči redesignům odolnější než CSS selektory. Pro nejrobustnější extrakci ho používejte spolu s JSON-LD.

Mohu scrapovat IMDb bez programování?

Ano. Dvě hlavní možnosti: (1) Stáhnout oficiální bulk datasety IMDb — 7 TSV souborů pokrývajících více než 26 milionů titulů, denně aktualizovaných, zdarma pro nekomerční použití. (2) Použít , který načte stránku IMDb, automaticky navrhne extrakční pole a exportuje do Excelu, Google Sheets nebo CSV na dvě kliknutí — bez kódu a bez nutnosti udržovat selektory.

Další informace