Python से IMDb स्क्रैप करें: ऐसा कोड जो सच में काम करे

अगर आपने हाल ही में "Python से IMDb स्क्रैप करें" खोजा है, तो आपने शायद एक बात नोटिस की होगी: ज़्यादातर ट्यूटोरियल अब काम नहीं करते। "थोड़े पुराने" नहीं — बल्कि ऐसे टूटे हुए कि NoneType एरर की लंबी दीवार खड़ी कर दें और एक भी नतीजा न दें।

पिछले कुछ हफ्तों में मैंने IMDb स्क्रैपिंग के लगभग हर बड़े ट्यूटोरियल को टेस्ट किया — GeeksforGeeks, Medium, freeCodeCamp, Kaggle notebooks, जो भी नाम लें। IMDb स्क्रैपिंग के लिए टैग किए गए में से बहुत बड़ी संख्या अब भी उन CSS selectors (td.titleColumn, td.ratingColumn) का इस्तेमाल करती है जो जून 2023 से मौजूद ही नहीं हैं, जब IMDb ने अपना Top 250 पेज नया डिज़ाइन किया था। नतीजा? फ़ोरमों में डेवलपर्स पूछ रहे हैं, "मेरा कोड खाली क्यों लौटाता है?" और जैसी लोकप्रिय लाइब्रेरी के मेंटेनर भी मान रहे हैं, "इसे ठीक करने के अलावा हम ज्यादा कुछ नहीं कर सकते, बस हर parser को सुधारना होगा।" यह गाइड उन दो Python तरीकों को कवर करती है जो अभी सच में काम करते हैं, pagination और आम errors को कैसे संभालें, कब Python सही टूल नहीं है, और अपने scraper को future-proof कैसे बनाएं ताकि वह भी कब्रिस्तान में न चला जाए।

Python से IMDb स्क्रैप करने का मतलब क्या है?

वेब स्क्रैपिंग का मतलब है वेब पेजों से डेटा को प्रोग्राम के जरिए निकालना — यानी हाथ से कॉपी-पेस्ट करने के बजाय आप एक script लिखते हैं जो यह काम आपके लिए करती है। जब हम "IMDb स्क्रैप करना" कहते हैं, तो उसका मतलब होता है Python का इस्तेमाल करके IMDb के web pages से structured movie data (titles, ratings, genres, cast, runtime, vote counts) निकालना।

इसके लिए आम Python stack में तीन libraries होती हैं: requests (web page लाने के लिए), BeautifulSoup (HTML parse करने और डेटा ढूँढने के लिए), और pandas (results को व्यवस्थित करने और export करने के लिए)। कुछ tutorials JavaScript rendering वाली pages के लिए Selenium या Playwright भी इस्तेमाल करते हैं, लेकिन जैसा आप आगे देखेंगे, इससे तेज़ तरीके भी मौजूद हैं।

एक महत्वपूर्ण सावधानी: इस गाइड की हर बात mid-2025 तक IMDb की current page structure के अनुसार सत्यापित है। IMDb लगभग हर 6–12 महीने में बदलाव करता है, इसलिए अगर आप इसे 2027 में पढ़ रहे हैं, तो कुछ selectors बदल चुके हो सकते हैं। (मैं यह भी बताऊँगा कि उसे कैसे संभालना है।)

Python से IMDb क्यों स्क्रैप करें? असली उपयोग के उदाहरण

कोड की एक भी line लिखने से पहले, आप IMDb data का करेंगे क्या? इसका जवाब इस बात पर निर्भर करता है कि आप कौन हैं।

IMDb review dataset दुनिया के सबसे व्यापक रूप से इस्तेमाल होने वाले NLP benchmarks में से एक है — Maas et al. (2011) के foundational paper को मिल चुके हैं, और यह dataset TensorFlow, Keras, और PyTorch में built-in है। Hugging Face पर stanfordnlp/imdb dataset हर महीने 213,321 downloads पाता है और 1,500 से ज्यादा models को train करने में इस्तेमाल हो चुका है। यानी अगर आप machine learning में हैं, तो आप शायद IMDb data से पहले से ही परिचित होंगे।

लेकिन इसके उपयोग अकादमिक दुनिया से कहीं आगे जाते हैं:

केवल film tourism market ही 2025 में लगभग का अनुमानित मूल्य रखता है। Netflix ने 2024 में content पर 17 अरब डॉलर से ज्यादा खर्च किए, और personalized recommendations से संचालित थी। मतलब साफ है: IMDb data अलग-अलग industries में असली फैसलों को प्रभावित करता है।

कोड लिखने से पहले IMDb data पाने के आपके विकल्प

यह वह हिस्सा है जिसे ज़्यादातर tutorials पूरी तरह छोड़ देते हैं। वे यह पूछे बिना कि आपकी स्थिति में Python scraping सही है भी या नहीं, सीधे pip install beautifulsoup4 पर कूद जाते हैं।

पूरा landscape यह है:

इन विकल्पों पर कुछ नोट्स। Cinemagoer की PyPI release May 2023 के बाद से नहीं आई है और IMDb के June 2025 redesign के बाद इसके ज्यादातर parsers टूट गए — अभी production use के लिए मैं इसे recommend नहीं करूँगा। TMDb बेहतरीन है, लेकिन वह अपना rating system इस्तेमाल करता है, IMDb का नहीं। और IMDb का official enterprise API AWS Data Exchange के जरिए सालाना का पड़ता है, इसलिए यह हम में से ज़्यादातर लोगों के लिए विकल्प नहीं है।

जो readers बिल्कुल code नहीं लिखना चाहते, उनके लिए IMDb page पढ़ता है, extraction fields अपने-आप सुझाता है (title, rating, year, genre), और दो clicks में Excel, Google Sheets, Airtable, या Notion में export कर देता है। IMDb का layout बदलने पर भी AI adapt कर जाता है, इसलिए selectors maintain करने की ज़रूरत नहीं पड़ती। आगे इस पर और बात करेंगे।

अब, जो लोग Python लिखना चाहते हैं — उनके लिए यहां दो तरीके हैं जो काम करते हैं।

तरीका 1: BeautifulSoup से Python में IMDb स्क्रैप करना (पारंपरिक तरीका)

यह वही classic approach है जो आपको अधिकतर tutorials में मिलेगी। यह काम करती है, लेकिन मैं साफ़-साफ़ कहना चाहता हूँ: जिन तरीकों को मैं यहां कवर करूँगा, उनमें यह सबसे नाज़ुक है। IMDb के CSS class names auto-generated होते हैं और redesign के साथ बदल जाते हैं। फिर भी web scraping की बुनियादी बातें सीखने के लिए यह सबसे अच्छा तरीका है।

चरण 1: अपनी Python libraries इंस्टॉल और import करें

आपको चार packages चाहिए:

1pip install requests beautifulsoup4 pandas lxml

हर package क्या करता है:

• requests — web page लाने के लिए HTTP requests भेजता है
• beautifulsoup4 — HTML parse करता है ताकि आप specific elements खोज सकें
• pandas — extracted data को tables में व्यवस्थित करता है और CSV/Excel में export करता है
• lxml — तेज़ HTML parser (BeautifulSoup इसे backend की तरह इस्तेमाल कर सकता है)

आपका import block:

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

चरण 2: IMDb को HTTP request भेजें

यहीं ज़्यादातर beginners पहली दीवार से टकराते हैं। IMDb उन requests को block कर देता है जिनमें proper User-Agent header नहीं होता — आपको 403 Forbidden error मिलेगा। Python Requests की default user-agent string (python-requests/2.31.0) तुरंत flag हो जाती है।

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"पेज लाने में असफल: {response.status_code}")
9else:
10    print("पेज सफलतापूर्वक लोड हो गया")

Accept-Language header भी महत्वपूर्ण है — इसके बिना IMDb आपके IP की geolocation के आधार पर किसी और भाषा में content लौटा सकता है।

चरण 3: BeautifulSoup से HTML parse करें

HTML मिल जाने के बाद, एक BeautifulSoup object बनाइए और सही elements ढूँढना शुरू कीजिए। Chrome में IMDb Top 250 page खोलें, किसी movie title पर right-click करें, और underlying HTML structure देखने के लिए "Inspect" पर क्लिक करें।

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

Mid-2025 तक, Top 250 page इन selectors का उपयोग करता है:

• Movie container: li.ipc-metadata-list-summary-item
• Title: h3.ipc-title__text
• Year: span.cli-title-metadata-item (पहला span)
• Rating: span.ipc-rating-star--rating

ध्यान रहे: ये ipc- prefixed class names IMDb की component system द्वारा generate होते हैं। June 2023 redesign के बाद से ये stable रहे हैं, लेकिन इस बात की कोई गारंटी नहीं है कि ये फिर नहीं बदलेंगे।

चरण 4: movie data निकालें (Title, Year, Rating)

यहाँ मैं ज़्यादातर tutorials से अलग काम करता हूँ: मैं try/except error handling शामिल करता हूँ। जिन competitor guides को मैंने देखा, उनमें यह नहीं था, और इसी वजह से selector बदलते ही उनका code silently टूट जाता है।

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"Movie parse करने में त्रुटि: {e}")
18        continue
19print(f"{len(movies)} movies निकाली गईं")

चरण 5: Pandas से CSV या Excel में सेव करें

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

Sample 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

यह काम करता है। लेकिन यह CSS selectors के सहारे टिका है, जो किसी भी दिन टूट सकते हैं — और यहीं से हम उस approach पर आते हैं जिसकी मैं सच में सिफारिश करता हूँ।

तरीका 2: JSON-LD ट्रिक — HTML parsing को पूरी तरह छोड़ दें

यह वही तकनीक है जिसका उल्लेख कोई competitor article नहीं करता, और मैं किसी serious project के लिए इसी का उपयोग करूँगा। IMDb हर page पर <script type="application/ld+json"> tags में structured data के रूप में (JavaScript Object Notation for Linked Data) embed करता है। यह data Schema.org standard का पालन करता है, Google इसे rich search results के लिए इस्तेमाल करता है, और CSS class names की तुलना में बहुत कम बदलता है।

Production-grade tool Apify IMDb Scraper extraction priority order के रूप में यह इस्तेमाल करता है: "JSON-LD > NEXT_DATA > DOM." मैं भी यही hierarchy recommend करूँगा।

CSS selectors की तुलना में JSON-LD अधिक भरोसेमंद क्यों है

ipc-metadata-list-summary-item जैसे CSS class names IMDb के React component system द्वारा auto-generated होते हैं और हर redesign के साथ बदल जाते हैं। JSON-LD schema वास्तविक data model को दर्शाता है, presentation layer को नहीं। यह किताब की table of contents पढ़ने और chapters को उनके font size से पहचानने की कोशिश करने के फर्क जैसा है।

चरण-दर-चरण: JSON-LD से IMDb data निकालें

चरण 1: पेज लाएँ

पहले की तरह — proper User-Agent header के साथ requests इस्तेमाल करें।

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

चरण 2: JSON-LD script tag ढूँढें

1script_tag = soup.find("script", {"type": "application/ld+json"})
2if not script_tag:
3    print("इस पेज पर JSON-LD नहीं मिला")
4else:
5    data = json.loads(script_tag.string)
6    print(f"JSON-LD मिला, type: {data.get('@type', 'unknown')}")

चरण 3: structured data parse करें

Top 250 page पर JSON-LD में एक itemListElement array होता है जिसमें सभी 250 movies शामिल होते हैं। हर entry में position, name, URL, aggregateRating, datePublished, genre, description, director, और 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    })

चरण 4: CSV में export करें

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

Sample 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

सभी 250 movies। साफ़, structured, और CSS selector gymnastics से मुक्त। और क्योंकि यह data Schema.org standard का पालन करता है (जिस पर Google search results के लिए निर्भर करता है), इसके visual layout की तुलना में बदलने की संभावना बहुत कम है।

बोनस: individual movie pages के लिए __NEXT_DATA__

Individual title pages (runtime, full cast, plot summary, poster images) से richer data पाने के लिए IMDb एक __NEXT_DATA__ JSON object भी embed करता है। यह वही data है जिसका उपयोग React page को hydrate करने के लिए करता है — इसे हटाने से site टूट जाएगी।

1# /title/tt0111161/ जैसी individual movie page पर
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"]

Chart/list pages के लिए JSON-LD, और individual title pages के लिए __NEXT_DATA__ का उपयोग करें। यही production-grade approach है।

आपका IMDb scraper बार-बार क्यों टूटता है (और उसे कैसे ठीक करें)

IMDb scraping forums में यह सबसे ज़्यादा रिपोर्ट किया गया दर्द बिंदु है। यूज़र लिखते हैं: "कुछ code UI changes की वजह से टूट गया" और "2024 में काम नहीं कर रहा!" — और जवाब अक्सर या तो खामोशी होता है या "Selenium try करो।"

मूल कारण है IMDb का React/Next.js frontend की ओर लगातार migration। बड़े breaking changes की timeline यह रही है:

यानी लगभग हर 6–12 महीने में एक major breaking change। अगर आपका scraper CSS class names पर निर्भर है, तो आप एक treadmill पर दौड़ रहे हैं।

आम errors और उन्हें कैसे ठीक करें

Empty results / NoneType errors

सबसे आम error। आपको AttributeError: 'NoneType' object has no attribute 'text' दिखाई देगा। इसका मतलब है कि BeautifulSoup को वह element नहीं मिला जिसे आप ढूँढ रहे थे — आमतौर पर इसलिए कि CSS class name बदल गया या content JavaScript से render हो रहा है।

समाधान: JSON-LD extraction पर स्विच करें (ऊपर Method 2)। डेटा initial HTML response में ही होता है, JavaScript की ज़रूरत नहीं।

403 Forbidden

IMDb bots का पता लगाने और उन्हें block करने के लिए इस्तेमाल करता है। सबसे बड़ा कारण होता है missing या साफ़ तौर पर fake User-Agent header। यह open-source projects और में दर्ज है, जहाँ IMDb के एक employee ने भी इस समस्या को स्वीकार किया था।

समाधान: हमेशा realistic browser User-Agent string और Accept-Language: en-US header शामिल करें। Connection pooling के लिए requests.Session() इस्तेमाल करें।

सिर्फ 25 results लौटे

IMDb search pages और "Most Popular" lists lazy loading इस्तेमाल करते हैं — वे शुरू में लगभग 25 results ही render करते हैं और जैसे-जैसे आप scroll करते हैं, AJAX से और लोड करते हैं।

समाधान: URL parameter pagination (अगले section में कवर किया गया है) का उपयोग करें, या Top 250 page पर जाएँ, जो सभी 250 movies को एक ही response में लोड करता है।

Selectors अचानक काम करना बंद कर दें

पुराने selectors जो अब काम नहीं करते: td.titleColumn, td.ratingColumn, .lister-item-header, .inline-block.ratings-imdb-rating. अगर आपका code इनमें से किसी का उपयोग करता है, तो वह टूट चुका है।

समाधान: auto-generated class names की बजाय data-testid attributes (जैसे h1[data-testid="hero-title-block__title"]) को प्राथमिकता दें। उससे भी बेहतर: JSON-LD का उपयोग करें।

निर्णय लेने की रूपरेखा: short-term बनाम long-term fixes

• Quick fix: हर selector के आसपास try/except blocks जोड़ें, HTTP status codes validate करें, crashes के बजाय errors log करें
• Medium-term fix: CSS selectors से JSON-LD extraction पर स्विच करें (Method 2)
• Long-term fix: बड़े पैमाने के analysis के लिए का उपयोग करें, या जैसे टूल का उपयोग करें जो हर बार page structure को fresh तरीके से AI से पढ़ता है — selectors maintain करने की ज़रूरत नहीं, AI layout changes के साथ अपने-आप adapt कर जाता है

25-Result Wall से आगे: IMDb pagination और बड़े datasets को स्क्रैप करना

जितने competitor tutorials मैंने देखे, उनमें हर एक सिर्फ एक page scrape करता है। कोई भी pagination को कवर नहीं करता। लेकिन अगर आपको एक ही list से ज्यादा चाहिए, तो आप जल्दी ही दीवार से टकराएँगे।

वे pages जिन्हें pagination की ज़रूरत नहीं

अच्छी खबर: Top 250 page सभी 250 movies को single server-rendered response में लोड करता है। JSON-LD और __NEXT_DATA__ दोनों में पूरा dataset मौजूद होता है। Pagination की आवश्यकता नहीं।

IMDb search pagination कैसे काम करती है

IMDb search pages start= URL parameter इस्तेमाल करती हैं, जो 50 के increments में बढ़ता है:

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

यहाँ एक Python loop है जो results को page by page निकालता है:

1import time
2all_movies = []
3for start in range(1, 1001, 50):  # top 1000 पर pages के लिए
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"start={start} पर विफल: {response.status_code}")
8        break
9    soup = BeautifulSoup(response.text, "lxml")
10    # अपनी पसंदीदा method से movies निकालें
11    # ...
12    print(f"{start} से शुरू होने वाला page scrape कर लिया गया")
13    time.sleep(3)  # संयम रखें — IMDb लगभग 50 तेज़ requests के बाद block कर देता है

वह time.sleep(3) महत्वपूर्ण है। Community reports के अनुसार IMDb लगभग 50 तेज़ requests के बाद IPs को block करना शुरू कर देता है। 2–5 सेकंड के बीच random delay एक अच्छी practice है।

Scraping पूरी तरह कब छोड़ दें: IMDb के official bulk datasets

वाकई बड़े पैमाने की ज़रूरतों के लिए, IMDb पर 7 free TSV files प्रदान करता है, जो रोज़ाना refresh होती हैं:

इन्हें 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# tconst (IMDb title ID) पर merge करें
4merged = basics.merge(ratings, on="tconst")
5top_movies = merged[merged["titleType"] == "movie"].nlargest(250, "averageRating")

ये datasets 26+ million titles को cover करते हैं। कोई pagination नहीं, कोई selectors नहीं, कोई 403 errors नहीं। लाइसेंस केवल personal और non-commercial use के लिए है — आप इस data को दोबारा publish या resell नहीं कर सकते।

No-code shortcut: Thunderbit pagination आपके लिए संभालता है

जिन readers को paginated IMDb data चाहिए लेकिन pagination logic लिखना नहीं चाहते, उनके लिए click-based pagination और infinite scroll — दोनों को native रूप से support करता है। आप बस scrape करने को कहते हैं, बाकी काम वह कर देता है — lazy-loaded content को scroll करना भी शामिल है।

Python से IMDb स्क्रैप करें: पूरा working code (सीधे copy-paste करने लायक)

यहाँ दो self-contained scripts हैं जिन्हें आप अभी चला सकते हैं।

Script A: BeautifulSoup method (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"त्रुटि: {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"त्रुटि के कारण movie छोड़ दी गई: {e}")
28df = pd.DataFrame(movies)
29df.to_csv("imdb_top250_bs4.csv", index=False)
30print(f"{len(df)} movies सेव की गईं")
31print(df.head())

Script B: JSON-LD method (सिफारिश की जाती है)

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"त्रुटि: {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("कोई 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"{len(df)} movies सेव की गईं")
42print(df.head())

दोनों scripts में error handling शामिल है और ये साफ़ CSV output देती हैं। Script B आपको richer data देती है — director, description, URL — और layout changes के प्रति अधिक resilient है।

बिना code लिखे IMDb कैसे scrape करें (Thunderbit का उपयोग करके)

हर किसी को Python लिखने की ज़रूरत या इच्छा नहीं होती। शायद आप एक operations analyst हैं और बस इस हफ़्ते की top-rated movies spreadsheet में चाहिए। शायद आप एक content strategist हैं और अलग-अलग सालों के genre trends compare करना चाहते हैं। ऐसे मामलों में scraper लिखना overkill है।

Thunderbit का उपयोग करके वही data पाने का तरीका यह है:

शुरू करने से पहले:

• कठिनाई: शुरुआती
• समय: ~2 मिनट
• ज़रूरी चीज़ें: Chrome browser, (free tier काम करता है)

चरण 1: IMDb page पर जाएँ जिसे आप scrape करना चाहते हैं। Chrome में IMDb Top 250 (या कोई भी दूसरी IMDb list/search page) खोलें।

चरण 2: Thunderbit sidebar में "AI Suggest Fields" पर क्लिक करें। AI page को scan करता है और columns सुझाता है — आमतौर पर Title, Year, Rating, Genre, और page के अनुसार कुछ और। आपको सुझाए गए fields के साथ एक preview table दिखेगा।

चरण 3: ज़रूरत हो तो fields adjust करें। जो columns नहीं चाहिए उन्हें हटाएँ, या "+ Add Column" पर क्लिक करके plain English में बताकर custom columns जोड़ें (जैसे "Director name" या "Number of votes").

चरण 4: "Scrape" पर क्लिक करें। Thunderbit data निकालता है। infinite scroll या pagination वाले pages पर यह scrolling अपने-आप संभाल लेता है।

चरण 5: Export करें। export button पर क्लिक करके format चुनें — Excel, Google Sheets, CSV, Airtable, या Notion। कुछ ही सेकंड में data आपकी destination में पहुँच जाता है।

यहाँ असली फ़ायदा सिर्फ convenience नहीं है — बल्कि यह है कि Thunderbit का AI हर बार page structure को fresh तरीके से पढ़ता है। जब IMDb layout बदलता है (और बदलेगा), AI adapt हो जाता है। selectors update करने की ज़रूरत नहीं, code ठीक करने की ज़रूरत नहीं। जिसने कभी किसी deadline से पहले रात 2 बजे टूटे scraper से धोखा खाया हो, उसके लिए यह काफ़ी मूल्यवान है।

Thunderbit subpage scraping भी support करता है — आप हर movie की detail page में जाकर अपनी table को cast, director, runtime, और दूसरे ऐसे fields से समृद्ध कर सकते हैं जो list page पर नहीं दिखते। इसे action में देखना हो तो देखें।

क्या IMDb स्क्रैप करना कानूनी है? आपको क्या जानना चाहिए

फ़ोरमों में यूज़र सीधे पूछते हैं: "क्या ऐसा करना legal है?… IMDb नहीं चाहता कि लोग उनकी website scrape करें।" यह एक उचित सवाल है, और कोई competitor article इसे ठीक से address नहीं करता।

IMDb का robots.txt: Top 250 chart (/chart/top/), individual title pages (/title/ttXXXXXXX/), और name pages (/name/nmXXXXXXX/) robots.txt द्वारा blocked नहीं हैं। Blocked paths में /find, /_json/*, /search/name-text, /user/ur*/ratings, और कई AJAX endpoints शामिल हैं। कोई Crawl-delay directive निर्दिष्ट नहीं है।

IMDb की Conditions of Use: संबंधित clause कहता है: "आप इस साइट पर data mining, robots, screen scraping, या इसी तरह के data gathering और extraction tools का उपयोग नहीं कर सकते, सिवाय हमारी स्पष्ट लिखित अनुमति के." एक अतिरिक्त clause scraped data के resale या commercial use पर रोक लगाता है।

व्यवहार में इसका मतलब: हाल के 2024 court rulings (Meta v. Bright Data, X Corp v. Bright Data) ने पाया कि Terms of Service उन users पर बाध्यकारी नहीं भी हो सकतीं जिन्होंने उन्हें कभी स्वीकार ही नहीं किया — अगर आप login किए बिना publicly available data scrape कर रहे हैं, तो ToS enforceability बहस का विषय है। लेकिन यह कानून का विकसित होता हुआ क्षेत्र है।

सुरक्षित विकल्प: IMDb के व्यक्तिगत और non-commercial use के लिए स्पष्ट रूप से अनुमोदित हैं। TMDb API free API key के साथ permissive है। अगर आप पूरी तरह सुरक्षित रहना चाहते हैं, तो दोनों अच्छे विकल्प हैं।

व्यावहारिक सलाह: अगर आप scrape करते हैं, तो respectful crawl rate रखें (time.sleep(3) requests के बीच), proper headers सेट करें, और robots.txt से blocked paths पर न जाएँ। commercial projects के लिए, कानूनी पेशेवर से सलाह लें या official datasets/API का उपयोग करें।

हमने Thunderbit blog पर को विस्तार से कवर किया है।

निष्कर्ष: Python से IMDb स्क्रैप करने का सही तरीका चुनें

संक्षेप में:

• BeautifulSoup + CSS selectors: fundamentals सीखने के लिए अच्छा। उम्मीद रखें कि यह हर 6–12 महीने में टूटेगा। हमेशा error handling शामिल करें।
• JSON-LD extraction: किसी भी ongoing Python project के लिए मैं यही recommend करूँगा। यह Schema.org standard का पालन करता है, CSS classes की तुलना में बहुत कम बदलता है, और JavaScript rendering के बिना साफ़ structured data देता है।
• __NEXT_DATA__ JSON: individual title pages पर richer data (runtime, full cast, plot, poster images) के लिए इसे supplement की तरह इस्तेमाल करें।
• IMDb Official Datasets: बड़े पैमाने के analysis के लिए सबसे अच्छा विकल्प। 26M+ titles, daily updates, scraping की ज़रूरत नहीं। केवल personal/non-commercial use।
• : non-coders या जल्दी data चाहने वालों के लिए सबसे अच्छा विकल्प, बिना code maintain किए। AI layout changes के साथ adapt करता है, pagination संभालता है, Excel/Sheets/Airtable/Notion में export करता है।

इस गाइड को bookmark कर लें — IMDb की structure अगली बार बदलेगी तो मैं इसे अपडेट करूँगा। और अगर आप पूरा code छोड़ना चाहते हैं, तो और देखें कि IMDb page से clean spreadsheet तक कितनी जल्दी पहुँचा जा सकता है। अगर आप दूसरी sites पर भी काम कर रहे हैं, तो वाली हमारी गाइड broader workflow को कवर करती है।

FAQs

क्या IMDb को scrape करना legal है?

IMDb की Terms of Service consent के बिना scraping को prohibit करती हैं, लेकिन हाल के 2024 court rulings के बाद publicly accessible data पर ToS की enforceability कानूनी रूप से बहस का विषय है। सबसे सुरक्षित विकल्प IMDb के (personal/non-commercial use) या TMDb API (free key) हैं। अगर आप scrape करते हैं, तो robots.txt का सम्मान करें, requests के बीच reasonable delays रखें, और blocked paths से बचें। commercial use के लिए कानूनी पेशेवर से सलाह लें।

मेरा IMDb scraper खाली results क्यों लौटाता है?

लगभग हमेशा कारण पुराने CSS selectors होते हैं — td.titleColumn और td.ratingColumn जैसे class names जून 2023 से मौजूद नहीं हैं। समाधान है JSON-LD extraction पर स्विच करना (<script type="application/ld+json"> tag parse करें) या अपने selectors को मौजूदा ipc- prefixed classes के अनुसार अपडेट करें। यह भी verify करें कि proper User-Agent header शामिल है, क्योंकि missing header 403 error पैदा कर सकता है जो खाली results जैसा दिखता है।

IMDb से 25 से ज्यादा results कैसे scrape करें?

Top 250 page सभी 250 movies को एक ही response में लोड करता है — pagination की ज़रूरत नहीं। Search results के लिए, start= URL parameter का उपयोग करें (50-50 के increments में) ताकि results को page by page निकाला जा सके। उदाहरण: start=1, start=51, start=101। blocked होने से बचने के लिए requests के बीच time.sleep(3) जोड़ें। वैकल्पिक रूप से, पर IMDb के official datasets में 26M+ titles होते हैं और pagination की आवश्यकता नहीं होती।

__NEXT_DATA__ क्या है और IMDb scrape करने के लिए इसका उपयोग क्यों करना चाहिए?

__NEXT_DATA__ एक JSON object है जो IMDb के React/Next.js pages पर <script id="__NEXT_DATA__"> tag में embedded होता है। इसमें वह पूरा structured data होता है जिसका उपयोग React page render करने के लिए करता है — titles, ratings, cast, genres, runtime, और बहुत कुछ। क्योंकि यह visual layout के बजाय underlying data model को दर्शाता है, इसलिए यह CSS selectors की तुलना में UI redesigns के प्रति अधिक resilient है। सबसे मजबूत extraction approach के लिए इसे JSON-LD के साथ इस्तेमाल करें।

क्या मैं बिना coding के IMDb scrape कर सकता हूँ?

हाँ। दो मुख्य विकल्प हैं: (1) IMDb के डाउनलोड करें — 26M+ titles कवर करने वाली 7 TSV files, daily updates, non-commercial use के लिए मुफ्त। (2) इस्तेमाल करें, जो IMDb page को पढ़ता है, extraction fields अपने-आप सुझाता है, और दो clicks में Excel, Google Sheets, या CSV में export कर देता है — न code, न selectors maintain करने की जरूरत।

और जानें