גריפת IMDb עם Python: קוד שבאמת עובד

אם חיפשתם לאחרונה "לגרוף את IMDb עם Python", כנראה שמתם לב למשהו: רוב המדריכים שתמצאו שבורים. לא שבורים במובן של "קצת מיושנים" — אלא שבורים במובן של "מחזירים אפס תוצאות וקיר של שגיאות NoneType".

במהלך השבועות האחרונים בדקתי כל מדריך מרכזי לגריפת IMDb שהצלחתי למצוא — GeeksforGeeks, Medium, freeCodeCamp, מחברות Kaggle, כל מה שתרצו. מתוך המתויגים לגריפת IMDb, הרוב המוחלט מסתמך על בוררי CSS (td.titleColumn, td.ratingColumn) שכבר לא קיימים מאז יוני 2023, כשהאתר של IMDb עוצב מחדש בעמוד Top 250. התוצאה? פורומים מלאים במפתחים ששואלים "למה הקוד שלי מחזיר ריק?" ותחזוקנים של ספריות פופולריות כמו ש"אין הרבה מה לעשות חוץ מלתקן כל פרסר." המדריך הזה מציג שתי שיטות ב‑Python שבאמת עובדות כרגע, איך להתמודד עם עימוד ושגיאות נפוצות, מתי Python בכלל לא הכלי הנכון, ואיך להכין את הגריפר שלכם לעתיד כך שלא יצטרף לבית הקברות.

מה זה אומר לגרוף את IMDb עם Python?

גריפת אתרים היא תהליך של חילוץ נתונים מדפי אינטרנט באופן תכנותי — במקום להעתיק ולהדביק ידנית, כותבים סקריפט שעושה זאת בשבילכם. כשאנחנו מדברים על "גריפת IMDb", הכוונה היא לשליפת נתוני סרטים מובנים (כותרות, דירוגים, ז׳אנרים, שחקנים, משך, מספרי הצבעות) מדפי IMDb בעזרת Python.

הסטאק הטיפוסי ב‑Python למשימה הזו כולל שלוש ספריות: requests (כדי להביא את דף האינטרנט), BeautifulSoup (כדי לנתח את ה‑HTML ולמצוא את הנתונים), ו‑pandas (כדי לארגן ולייצא את התוצאות). חלק מהמדריכים משתמשים גם ב‑Selenium או ב‑Playwright עבור דפים שדורשים רינדור JavaScript, אבל כפי שתראו, יש גישות מהירות יותר.

הסתייגות חשובה אחת: כל מה שבמדריך הזה אומת מול מבנה הדפים הנוכחי של IMDb נכון לאמצע 2025. IMDb משנה דברים בערך כל 6–12 חודשים, כך שאם אתם קוראים את זה ב‑2027, ייתכן שחלק מהבוררים השתנו. (אסביר גם איך להתמודד עם זה.)

למה לגרוף את IMDb עם Python? שימושים אמיתיים

לפני שאתם כותבים אפילו שורת קוד אחת, מה בכלל תעשו עם נתוני IMDb? התשובה תלויה במי אתם.

מאגר הביקורות של IMDb הוא אחד ממדדי ה‑NLP הנפוצים ביותר בעולם — המאמר הבסיסי של Maas ואחרים (2011) צבר , והמאגר מובנה ב‑TensorFlow, ב‑Keras וב‑PyTorch. ב‑Hugging Face, המאגר stanfordnlp/imdb מקבל 213,321 הורדות בחודש ושימש לאימון יותר מ‑1,500 מודלים. אז אם אתם בתחום למידת המכונה, סביר להניח שכבר אתם מכירים את נתוני IMDb.

אבל השימושים חורגים הרבה מעבר לאקדמיה:

שוק תיירות הקולנוע לבדו מוערך בכ‑. נטפליקס הוציאה יותר מ‑17 מיליארד דולר על תוכן ב‑2024, כאשר הונעו על ידי המלצות מותאמות אישית. הנקודה היא: נתוני IMDb מזינים החלטות אמיתיות בתעשיות שונות.

האפשרויות שלכם להשגת נתוני IMDb (לפני כתיבת שורת קוד)

זהו החלק שרוב המדריכים מדלגים עליו לחלוטין. הם קופצים ישר ל‑pip install beautifulsoup4 בלי לשאול אם גריפת Python בכלל היא הגישה הנכונה למקרה שלכם.

הנה כל המפה:

כמה הערות על האפשרויות האלה. ל‑Cinemagoer לא הייתה גרסת PyPI מאז מאי 2023, ורוב הפרסרים שלו נשברו אחרי העיצוב מחדש של IMDb ביוני 2025 — כרגע לא הייתי ממליץ עליו לשימוש בייצור. TMDb מצוין, אבל משתמש במערכת דירוג משלו, לא בדירוג של IMDb. ו‑API הארגוני הרשמי של IMDb עולה דרך AWS Data Exchange, כך שלרובנו זו לא אופציה.

למי שלא רוצה לכתוב קוד בכלל, קורא את דף IMDb, מציע שדות חילוץ אוטומטית (כותרת, דירוג, שנה, ז׳אנר), ומייצא ל‑Excel, ל‑Google Sheets, ל‑Airtable או ל‑Notion בשני קליקים. ה‑AI מסתגל כש‑IMDb משנה את הפריסה שלו, כך שאין בוררים שצריך לתחזק. עוד על זה בהמשך.

ועכשיו, למי שכן רוצים לכתוב Python — הנה שתי שיטות שעובדות.

שיטה 1: גריפת IMDb עם Python באמצעות BeautifulSoup (הגישה המסורתית)

זוהי הגישה הקלאסית שתמצאו ברוב המדריכים. היא עובדת, אבל חשוב לי להיות כן: זו השיטה השברירית ביותר מבין אלה שאציג. שמות מחלקות ה‑CSS של IMDb נוצרים אוטומטית ומשתנים עם עיצובים מחדש. עם זאת, זו הדרך הטובה ביותר ללמוד את יסודות גריפת האתרים.

שלב 1: התקינו וייבאו את ספריות ה‑Python שלכם

אתם צריכים ארבע חבילות:

1pip install requests beautifulsoup4 pandas lxml

כך כל אחת מהן פועלת:

• requests — שולחת בקשות HTTP כדי להביא את דף האינטרנט
• beautifulsoup4 — מנתחת את ה‑HTML כך שאפשר לחפש אלמנטים מסוימים
• pandas — מארגנת את הנתונים שחולצו לטבלאות ומייצאת ל‑CSV/Excel
• lxml — מנתח HTML מהיר (BeautifulSoup יכול להשתמש בו כ־backend)

בלוק הייבוא שלכם:

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

שלב 2: שלחו בקשת HTTP ל‑IMDb

כאן רוב המתחילים נתקלים בקיר הראשון. IMDb חוסם בקשות שלא כוללות כותרת User-Agent תקינה — תקבלו שגיאת 403 Forbidden. מחרוזת ה‑user-agent ברירת המחדל של Python Requests (python-requests/2.31.0) מזוהה מיד.

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

גם לכותרת Accept-Language יש חשיבות — בלעדיה, IMDb עשוי להחזיר תוכן בשפה אחרת לפי המיקום הגיאוגרפי של ה‑IP שלכם.

שלב 3: נתחו את ה‑HTML עם BeautifulSoup

אחרי שיש לכם HTML, צרו אובייקט BeautifulSoup והתחילו לחפש את האלמנטים הנכונים. פתחו את עמוד Top 250 של IMDb ב‑Chrome, לחצו לחיצה ימנית על שם של סרט, ולחצו "Inspect" כדי לראות את מבנה ה‑HTML הבסיסי.

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

נכון לאמצע 2025, עמוד Top 250 משתמש בבוררים האלה:

• מכולת הסרט: li.ipc-metadata-list-summary-item
• כותרת: h3.ipc-title__text
• שנה: span.cli-title-metadata-item (ה־span הראשון)
• דירוג: span.ipc-rating-star--rating

אזהרה: שמות המחלקות עם הקידומת ipc- נוצרים על ידי מערכת הרכיבים של IMDb. הם היו יציבים מאז העיצוב מחדש של יוני 2023, אבל אין ערובה שלא ישתנו שוב.

שלב 4: חילוץ נתוני הסרטים (כותרת, שנה, דירוג)

כאן אני שונה מרוב המדריכים: אני כולל טיפול בשגיאות עם try/except. אף אחד מהמדריכים המתחרים שבדקתי לא עושה את זה, וזו בדיוק הסיבה שהקוד שלהם נשבר בשקט כשהבורר משתנה.

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

שלב 5: שמירה ל‑CSV או ל‑Excel עם 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())

פלט לדוגמה:

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 שעלולים להישבר בכל יום — וזה מוביל אותנו לגישה שאני באמת ממליץ עליה.

שיטה 2: טריק ה‑JSON-LD — לדלג לגמרי על ניתוח HTML

זוהי הטכניקה שאף מאמר מתחרה לא מכסה, וזו השיטה שהייתי משתמש בה לכל פרויקט רציני. IMDb מטמיע נתונים מובנים כ‑ (JavaScript Object Notation for Linked Data) בתוך תגיות <script type="application/ld+json"> בכל דף. הנתונים האלה פועלים לפי תקן Schema.org, משמשים את Google לתוצאות חיפוש עשירות, ומשתנים הרבה פחות משמות מחלקות CSS.

Apify IMDb Scraper, כלי ברמת ייצור, משתמש בסדר עדיפויות חילוץ: "JSON-LD > NEXT_DATA > DOM." זה גם ההיררכיה שהייתי ממליץ עליה.

למה JSON-LD אמין יותר מבוררי CSS

שמות מחלקות כמו ipc-metadata-list-summary-item נוצרים אוטומטית על ידי מערכת הרכיבים React של IMDb ומשתנים עם כל עיצוב מחדש. סכמת JSON-LD מייצגת את מודל הנתונים האמיתי, לא את שכבת ההצגה. זה כמו ההבדל בין לקרוא את תוכן העניינים של ספר לבין לנסות לזהות פרקים לפי גודל הגופן שלהם.

שלב אחר שלב: חילוץ נתוני IMDb מ‑JSON-LD

שלב 1: הביאו את הדף

כמו קודם — השתמשו ב‑requests עם כותרת 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")

שלב 2: מצאו את תגית הסקריפט של JSON-LD

1script_tag = soup.find("script", {"type": "application/ld+json"})
2if not script_tag:
3    print("No JSON-LD found on this page")
4else:
5    data = json.loads(script_tag.string)
6    print(f"Found JSON-LD with type: {data.get('@type', 'unknown')}")

שלב 3: נתחו את הנתונים המובנים

בעמוד Top 250, ה‑JSON-LD מכיל מערך itemListElement עם כל 250 הסרטים. כל רשומה כוללת position, name, URL, aggregateRating, datePublished, genre, description, director, ומערכי 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    })

שלב 4: ייצוא ל‑CSV

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

פלט לדוגמה:

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 הסרטים. נקי, מובנה, בלי לוליינות של בוררי CSS. ומכיוון שהנתונים האלה פועלים לפי תקן Schema.org (ש‑Google נשען עליו לתוצאות חיפוש), סביר הרבה פחות שהם ישתנו מאשר הפריסה הוויזואלית.

בונוס: __NEXT_DATA__ עבור דפי סרט בודדים

כדי לקבל נתונים עשירים יותר מדפי כותרת בודדים (משך, כל הקאסט, תקציר העלילה, תמונות פוסטר), IMDb מטמיע גם אובייקט JSON בשם __NEXT_DATA__. אלה הנתונים ש‑React משתמש בהם כדי לאתחל את הדף — אי אפשר להסיר אותם בלי לשבור את האתר.

1# בדף סרט בודד כמו /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"]

השתמשו ב‑JSON-LD עבור עמודי רשימות/טבלאות, וב‑__NEXT_DATA__ עבור דפי כותרת בודדים. זו הגישה ברמת ייצור.

למה הגריפר שלכם ב‑IMDb נשבר כל הזמן (ואיך לתקן זאת)

זוהי נקודת הכאב המדווחת ביותר כמעט בכל פורום גריפת IMDb שבדקתי. משתמשים כותבים: "חלק מהקוד נשבר בגלל שינויי UI" ו‑"לא עובד ב‑2024!" — ובדרך כלל התגובה היא שתיקה או "תנסו Selenium."

שורש הבעיה הוא המעבר המתמשך של IMDb ל‑frontend מבוסס React/Next.js. הנה ציר הזמן של השינויים הגדולים ששברו הכול:

זה בערך שינוי שובר גדול אחד כל 6–12 חודשים. אם הגריפר שלכם נשען על שמות מחלקות CSS, אתם רצים על הליכון.

שגיאות נפוצות ואיך לתקן אותן

תוצאות ריקות / שגיאות NoneType

זו השגיאה הנפוצה ביותר. תראו AttributeError: 'NoneType' object has no attribute 'text'. זה אומר ש‑BeautifulSoup לא מצא את האלמנט שחיפשתם — בדרך כלל כי שם מחלקת ה‑CSS השתנה או שהתוֹכֶן נרנדר על ידי JavaScript.

תיקון: עברו לחילוץ JSON-LD (שיטה 2 למעלה). הנתונים נמצאים בתגובה הראשונית של ה‑HTML, בלי צורך ב‑JavaScript.

403 Forbidden

IMDb משתמשת ב‑ כדי לזהות ולחסום בוטים. הגורם מספר 1 הוא כותרת User-Agent חסרה או מזויפת באופן ברור. זה מתועד בכמה וב שבהם עובד IMDb הודה בבעיה.

תיקון: תמיד כללו מחרוזת User-Agent ריאליסטית של דפדפן וכותרת Accept-Language: en-US. השתמשו ב‑requests.Session() לצורך pooling של חיבורים.

רק 25 תוצאות מוחזרות

דפי החיפוש ורשימות "Most Popular" של IMDb משתמשים בטעינה מדורגת — בהתחלה נרנדרים רק כ‑25 תוצאות, והשאר נטענות דרך AJAX בזמן הגלילה.

תיקון: השתמשו בעימוד באמצעות פרמטר URL (מוסבר בסעיף הבא) או עברו לעמוד Top 250, שמטען את כל 250 הסרטים בתגובה אחת.

בוררים מפסיקים לעבוד פתאום

בוררים ישנים שכבר לא עובדים: td.titleColumn, td.ratingColumn, .lister-item-header, .inline-block.ratings-imdb-rating. אם הקוד שלכם משתמש באחד מהם, הוא שבור.

תיקון: העדיפו מאפייני data-testid (כמו h1[data-testid="hero-title-block__title"]) על פני שמות מחלקה שנוצרים אוטומטית. אפילו טוב יותר — השתמשו ב‑JSON-LD.

מסגרת החלטה: תיקונים לטווח קצר מול ארוך

• תיקון מהיר: הוסיפו בלוקי try/except סביב כל בורר, בדקו קודי סטטוס HTTP, תעדו שגיאות במקום לקרוס
• תיקון לטווח בינוני: עברו מבוררי CSS לחילוץ JSON-LD (שיטה 2)
• תיקון לטווח ארוך: השתמשו ב לניתוח בקנה מידה גדול, או בכלי כמו שמשתמש ב‑AI כדי לקרוא מחדש את מבנה הדף בכל פעם — בלי בוררים לתחזק, כשה‑AI מסתגל לשינויים בפריסה אוטומטית

מעבר למחסום של 25 תוצאות: גריפת עימוד ומאגרי נתונים גדולים ב‑IMDb

כל מדריך מתחרה שבדקתי גורף בדיוק דף אחד. אף אחד לא מכסה עימוד. אבל אם אתם צריכים יותר מרשימה אחת, תיתקעו במהירות.

דפים שלא צריכים עימוד

חדשות טובות: עמוד Top 250 טוען את כל 250 הסרטים בתגובה אחת שמרונדרת בצד השרת. גם JSON-LD וגם __NEXT_DATA__ מכילים את כל מאגר הנתונים. אין צורך בעימוד.

איך עובד עימוד החיפוש של IMDb

דפי החיפוש של IMDb משתמשים בפרמטר URL של start=, בקפיצות של 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

הנה לולאת Python שעוברת על התוצאות:

1import time
2all_movies = []
3for start in range(1, 1001, 50):  # עוברים על 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    # חלצו סרטים בשיטה המועדפת עליכם
11    # ...
12    print(f"Scraped page starting at {start}")
13    time.sleep(3)  # היו מנומסים — IMDb חוסמת אחרי ~50 בקשות מהירות

ה‑time.sleep(3) הזה חשוב. דיווחים מהקהילה מציעים ש‑IMDb מתחילה לחסום IP‑ים אחרי בערך 50 בקשות מהירות. השהיה אקראית של 2–5 שניות היא פרקטיקה טובה.

מתי לדלג על גריפה לגמרי: מאגרי הנתונים הרשמיים של IMDb

לצרכים גדולים באמת, IMDb מספקת 7 קובצי TSV חינמיים ב‑, המתעדכנים מדי יום:

טעינה שלהם ל‑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)
4merged = basics.merge(ratings, on="tconst")
5top_movies = merged[merged["titleType"] == "movie"].nlargest(250, "averageRating")

המאגר הזה מכסה יותר מ‑26 מיליון כותרים. בלי עימוד, בלי בוררים, בלי שגיאות 403. הרישיון הוא לשימוש אישי ולא מסחרי בלבד — אסור לכם לפרסם מחדש או למכור את הנתונים.

קיצור הדרך ללא קוד: Thunderbit מטפל בעימוד בשבילכם

למי שצריך נתוני IMDb עם עימוד אבל לא רוצה לכתוב לוגיקת עימוד, תומך באופן טבעי גם בעימוד מבוסס קליקים וגם בגלילה אינסופית. אתם אומרים לו לגרוף, והוא מטפל בשאר — כולל גלילה בתוכן שנטען עצלנית.

לגרוף את IMDb עם Python: הקוד המלא שעובד (מוכן להעתקה)

הנה שני סקריפטים עצמאיים שאפשר להריץ עכשיו.

סקריפט א': שיטת BeautifulSoup (בוררי 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"Error: {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"Skipping movie due to error: {e}")
28df = pd.DataFrame(movies)
29df.to_csv("imdb_top250_bs4.csv", index=False)
30print(f"Saved {len(df)} movies")
31print(df.head())

סקריפט ב': שיטת JSON-LD (מומלץ)

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"Error: {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("No JSON-LD data found")
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"Saved {len(df)} movies")
42print(df.head())

שני הסקריפטים כוללים טיפול בשגיאות ומייצרים פלט CSV נקי. סקריפט ב' נותן לכם נתונים עשירים יותר — במאי, תיאור, URL — והוא עמיד יותר לשינויי פריסה.

איך לגרוף את IMDb בלי לכתוב קוד בכלל (עם Thunderbit)

לא כולם צריכים או רוצים לכתוב Python. אולי אתם אנליסטים תפעוליים שפשוט צריכים את הסרטים המדורגים ביותר של השבוע בגיליון. אולי אתם אסטרטגי תוכן שרוצים להשוות מגמות ז׳אנר לאורך שנים. במקרים כאלה, כתיבת גריפר היא יותר מדי.

כך מקבלים את אותם נתונים בעזרת :

לפני שמתחילים:

• רמת קושי: מתחילים
• זמן נדרש: ~2 דקות
• מה צריך: דפדפן Chrome, (הגרסה החינמית עובדת)

שלב 1: עברו לדף IMDb שאתם רוצים לגרוף. פתחו ב‑Chrome את Top 250 של IMDb (או כל דף רשימה/חיפוש אחר של IMDb).

שלב 2: לחצו על "AI Suggest Fields" בסרגל הצד של Thunderbit. ה‑AI סורק את הדף וממליץ על עמודות — בדרך כלל Title, Year, Rating, Genre ועוד כמה, תלוי בדף. תראו טבלת תצוגה מקדימה עם השדות המוצעים.

שלב 3: התאימו את השדות אם צריך. הסירו עמודות שאינכם צריכים, או הוסיפו עמודות מותאמות אישית על ידי לחיצה על "+ Add Column" ותיאור מה אתם רוצים באנגלית פשוטה (למשל "Director name" או "Number of votes").

שלב 4: לחצו על "Scrape." Thunderbit מחלץ את הנתונים. בדפים עם גלילה אינסופית או עימוד, הוא מטפל בגלילה אוטומטית.

שלב 5: ייצוא. לחצו על כפתור הייצוא ובחרו את הפורמט — Excel, Google Sheets, CSV, Airtable או Notion. הנתונים נוחתים ביעד תוך שניות.

היתרון המרכזי כאן הוא לא רק נוחות — אלא ש‑AI של Thunderbit קורא את מבנה הדף מחדש בכל פעם. כש‑IMDb משנה את הפריסה שלו (והיא תשתנה), ה‑AI מסתגל. אין בוררים לעדכן, אין קוד לתקן. לכל מי שנכווה מגריפר שבור ב‑2 בלילה לפני דדליין, זה שווה הרבה.

Thunderbit תומך גם בגריפת תתי־דפים — אפשר להיכנס לדף הפרטים של כל סרט ולהעשיר את הטבלה עם קאסט, במאי, משך ושדות נוספים שלא נראים בדף הרשימה. אם תרצו לראות את זה בפעולה, בדקו את .

האם זה חוקי לגרוף את IMDb? מה שחשוב לדעת

משתמשים שואלים זאת במפורש בפורומים: "האם משהו כזה חוקי?… IMDb לא רוצה שאנשים יגרפו את האתר שלהם." זו שאלה הוגנת, ואף מאמר מתחרה לא מתייחס אליה.

robots.txt של IMDb: תרשים Top 250 (/chart/top/), דפי כותרת בודדים (/title/ttXXXXXXX/), ודפי Name (/name/nmXXXXXXX/) אינם חסומים ב‑robots.txt. נתיבים חסומים כוללים /find, /_json/*, /search/name-text, /user/ur*/ratings, ומספר נקודות קצה של AJAX. אין הוראת Crawl-delay מוגדרת.

תנאי השימוש של IMDb: הסעיף הרלוונטי קובע: "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." סעיף נוסף אוסר מכירה חוזרת או שימוש מסחרי בנתונים שנגרפו.

מה זה אומר בפועל: פסיקות משפטיות עדכניות מ‑2024 (Meta v. Bright Data, X Corp v. Bright Data) קבעו שתנאי שימוש אולי אינם מחייבים משתמשים שמעולם לא הסכימו להם — אם אתם גורפים נתונים הזמינים לציבור בלי להתחבר, האכיפות של ה‑ToS שנויה במחלוקת. אבל זהו תחום משפטי שמתפתח.

חלופות בטוחות: ה‑ מאושרים במפורש לשימוש אישי ולא מסחרי. ה‑API של TMDb גמיש עם מפתח API חינמי. שתיהן אפשרויות טובות אם אתם רוצים להישאר בצד הבטוח בבירור.

הנחיה מעשית: אם אתם כן גורפים, השתמשו בקצב סריקה מכבד (time.sleep(3) בין בקשות), הגדירו כותרות מתאימות, ואל תגעו בנתיבים החסומים ב‑robots.txt. לפרויקטים מסחריים, התייעצו עם איש מקצוע משפטי או השתמשו במאגרי הנתונים/‏API הרשמיים.

כיסינו בהרחבה את בבלוג של Thunderbit.

מסקנה: בחרו את הדרך הנכונה לגרוף את IMDb עם Python

הגרסה הקצרה:

• BeautifulSoup + בוררי CSS: טובים ללימוד היסודות. צפו לשבירה כל 6–12 חודשים. תמיד הוסיפו טיפול בשגיאות.
• חילוץ JSON-LD: הגישה שהייתי ממליץ עליה לכל פרויקט Python מתמשך. פועלת לפי תקן Schema.org, משתנה הרבה פחות ממחלקות CSS, ונותנת לכם נתונים מובנים ונקיים בלי רינדור JavaScript.
• JSON של __NEXT_DATA__: השתמשו בזה כהשלמה לנתונים עשירים יותר בדפי כותרת בודדים (משך, כל הקאסט, עלילה, תמונות פוסטר).
• IMDb Official Datasets: הבחירה הטובה ביותר לניתוח בקנה מידה גדול. 26M+ כותרים, מתעדכן מדי יום, בלי צורך בגריפה. לשימוש אישי/לא מסחרי בלבד.
• : הבחירה הטובה ביותר למי שלא כותב קוד או למי שרוצה נתונים מהר בלי לתחזק קוד. ה‑AI מסתגל לשינויים בפריסה, מטפל בעימוד, ומייצא ל‑Excel/Sheets/Airtable/Notion.

שמרו את המדריך הזה במועדפים — אעדכן אותו כשהמבנה של IMDb ישתנה שוב. ואם אתם רוצים לדלג על הקוד לגמרי, וראו כמה מהר אפשר לעבור מדף IMDb לגיליון נקי. אם אתם עובדים גם עם אתרים אחרים, המדריך שלנו על מכסה את התהליך הרחב יותר.

שאלות נפוצות

האם זה חוקי לגרוף את IMDb?

תנאי השימוש של IMDb אוסרים גריפה בלי הסכמה, אבל האכיפות של תנאי שימוש על נתונים הזמינים לציבור מוטלת בספק משפטי לאחר פסיקות עדכניות מ‑2024. האפשרויות הבטוחות ביותר הן (לשימוש אישי/לא מסחרי) או ה‑API של TMDb (מפתח חינמי). אם אתם כן גורפים, כבדו את robots.txt, השתמשו בהשהיות סבירות בין בקשות, והימנעו מנתיבים חסומים. לשימוש מסחרי, התייעצו עם עורך דין.

למה הגריפר שלי ל‑IMDb מחזיר תוצאות ריקות?

כמעט תמיד הסיבה היא בוררי CSS מיושנים — שמות מחלקות כמו td.titleColumn ו‑td.ratingColumn לא קיימים מאז יוני 2023. התיקון הוא לעבור לחילוץ JSON-LD (לנתח את תגית <script type="application/ld+json">) או לעדכן את הבוררים למחלקות הנוכחיות עם הקידומת ipc-. בדקו גם שאתם כוללים כותרת User-Agent תקינה, כי כותרת חסרה גורמת לשגיאת 403 שיכולה להיראות כמו תוצאות ריקות.

איך לגרוף יותר מ‑25 תוצאות מ‑IMDb?

עמוד Top 250 טוען את כל 250 הסרטים בתגובה אחת — אין צורך בעימוד. עבור תוצאות חיפוש, השתמשו בפרמטר ה‑URL start= (בקפיצות של 50) כדי לעבור בין התוצאות. לדוגמה: start=1, start=51, start=101. הוסיפו time.sleep(3) בין בקשות כדי להימנע מחסימה. לחלופין, מאגרי הנתונים הרשמיים של IMDb ב‑ כוללים יותר מ‑26 מיליון כותרים בלי צורך בעימוד.

מה זה __NEXT_DATA__ ולמה כדאי להשתמש בו לגריפת IMDb?

__NEXT_DATA__ הוא אובייקט JSON שמוטמע בתגית <script id="__NEXT_DATA__"> בדפי React/Next.js של IMDb. הוא מכיל את כל הנתונים המובנים ש‑React משתמשת בהם כדי לרנדר את הדף — כותרות, דירוגים, קאסט, ז׳אנרים, משך ועוד. מכיוון שהוא מייצג את מודל הנתונים הבסיסי ולא את הפריסה הוויזואלית, הוא עמיד יותר לעיצובי ממשק מחדש מאשר בוררי CSS. השתמשו בו יחד עם JSON-LD כדי לקבל את שיטת החילוץ החזקה ביותר.

אפשר לגרוף את IMDb בלי קוד?

כן. שתי אפשרויות עיקריות: (1) להוריד את — 7 קובצי TSV שמכסים יותר מ‑26 מיליון כותרים, מתעדכנים מדי יום, וחינמיים לשימוש לא מסחרי. (2) להשתמש ב, שקורא את דף IMDb, מציע שדות חילוץ אוטומטית, ומייצא ל‑Excel, ל‑Google Sheets או ל‑CSV בשני קליקים — בלי קוד, בלי בוררים לתחזק.

למידע נוסף