גרידת YouTube עם Python: 4 שיטות שבאמת עובדות

אם אי פעם ניסיתם requests.get("https://www.youtube.com/...") ואז לנתח את התוצאה עם BeautifulSoup כדי למצוא כותרות של סרטונים, אתם כבר מכירים את הפאנץ': קיבלתם קיר של תגי <div> ריקים ואפס נתונים שימושיים.

זו התסכול הנפוץ ביותר שאני רואה אצל מפתחים שמנסים לגרד את YouTube בפעם הראשונה. YouTube הוא יישום חד-דפי — כמעט הכול נטען בצד הלקוח באמצעות JavaScript. ה-HTML שסקריפט Python מקבל הוא רק מעטפת. כותרות הסרטונים, מספרי הצפיות והמטא־דאטה האמיתיים? הם קבורים בתוך בלוק JSON ענק בשם ytInitialData שמוזרק על ידי JS אחרי שהעמוד נטען.

לכן הקריאה התמימה לחלוטין ל-soup.find("div", class_="ytd-video-renderer") מחזירה None, כי האלמנט הזה פשוט לא קיים בתשובת ה-HTTP הגולמית. ברגע שהבנתי את זה, כל החידה התחברה — וארבע השיטות שלמטה הן תוצאה של הרבה בדיקות, שבירות, וקריאת יותר מדי בעיות ב-GitHub. אעבור איתכם על כל גישה, אראה בדיוק מתי להשתמש בכל אחת, ואוסיף בסוף קיצור דרך ללא קוד למי שרוצה רק את הנתונים בלי כל ההקמה של הפרויקט.

למה בכלל לגרד את YouTube עם Python?

YouTube הוא לא רק פלטפורמת וידאו — הוא גם מקור נתונים עצום עם 2.58 מיליארד משתמשים פעילים חודשיים. עם יותר מ-5.1 מיליארד סרטונים מאוחסנים ו-500+ שעות תוכן שמועלות בכל דקה, יש שם כמות אדירה של מידע גלוי לציבור שעסקים, חוקרים ויוצרים רוצים לנתח באופן תכנותי.

הבעיה היא שהאנליטיקס המובנה של YouTube מציג רק נתונים עבור הערוץ שלכם. אם אתם רוצים להבין את קצב ההעלאות של המתחרה, לעקוב אחר נושאים טרנדיים בנישה שלכם, או לנתח את תחושות הקהל מתוך תגובות לסרטונים של מישהו אחר, אתם צריכים לגרד את הנתונים.

אלו מקרי השימוש הנפוצים ביותר שראיתי בעולם האמיתי:

מקרה שימוש	מי צריך את זה	אילו נתונים
ניתוח מתחרים	צוותי שיווק, אסטרטגי תוכן	מספר צפיות, תדירות העלאה, שיעורי מעורבות
יצירת לידים	צוותי מכירות, פנייה ל-B2B	פרטי קשר של הערוץ, אימיילים עסקיים בתיאורים
מחקר שוק	מנהלי מוצר, אנליסטים	נושאים טרנדיים, תחושות קהל דרך תגובות
אסטרטגיית תוכן	יוטיוברים, סוכנויות	פורמטים מצליחים, דפוסי כותרות/תגיות מיטביים
SEO / מחקר מילות מפתח	מומחי SEO	כותרות סרטונים, תגיות, תיאורים, אותות דירוג
ניטור מותג	צוותי PR, מנהלי מותג	אזכורים בכותרות, תגובות ותיאורים של סרטונים
מחקר אקדמי	חוקרים, מדעני נתונים	מאגרי תגובות ל-ניתוח סנטימנט (מחקר מ-2025 הגיע לדיוק של 93.1% לאחר כוונון עדין של BERT על 45 אלף תגובות ביוטיוב)

למשל, ניתוח תחרותי בין DJI, GoPro ו-Insta360 מצא ש-הטווח של DJI ב-YouTube (390 מיליון צפיות) עקף את שני המתחרים יחד — סוג התובנה שפשוט אי אפשר לראות מתוך YouTube Studio.

למה requests + BeautifulSoup לבדן לא יגרדו את YouTube

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

הגישה ה"מתבקשת" נראית בערך כך:

import requests
from bs4 import BeautifulSoup

response = requests.get("https://www.youtube.com/@somechannel/videos")
soup = BeautifulSoup(response.text, "html.parser")
videos = soup.find_all("a", id="video-title-link")
print(len(videos))  # 0 — כל פעם מחדש

התוצאה היא תמיד אפס. כמו ש-מדריך הדיבוג של ScrapeOps אומר: "העמוד נטען דינמית, וזה לא נתמך על ידי ספריית requests." המדריך למתחילים של Teclado חד יותר: "בשימוש ב-requests וב-BeautifulSoup בלבד אי אפשר להריץ JavaScript."

הניתוח של Scrapfly ל-YouTube ב-2026 מסביר את המנגנון: YouTube בנוי כ-Single Page Application (SPA). כשמשתמשים בבקשות HTTP בסיסיות, מקבלים רק את מעטפת ה-HTML הראשונית — התוכן האמיתי עדיין לא רונדר. נתוני הסרטונים מוסתרים בתוך אובייקטי JavaScript שהדפדפן אמור להריץ ולהזריק ל-DOM.

החדשות הטובות: YouTube כן מטמיע את כל הנתונים שאתם צריכים בתוך ה-HTML הגולמי. הם פשוט לא נמצאים באלמנטים של ה-DOM — אלא בשני בלוקי JSON בתוך תגי <script>:

ytInitialData — מבנה העמוד, רשימות סרטונים, מדדי מעורבות, טוקנים להמשך תגובות
ytInitialPlayerResponse — מטא־דאטה ליבתית של הסרטון (כותרת, תיאור, משך, פורמטים, כתוביות)

את שניהם אפשר לשלוף עם requests.get() יחיד — בלי דפדפן — ברגע שמבינים איך לחלץ ולנתח אותם. זו שיטה 1 בהמשך.

4 דרכים לגרד את YouTube עם Python: השוואה זה לצד זה

לפני שנצלול לכל שיטה, הנה מטריצת ההחלטה. בדקתי את כל ארבע הגישות והשוויתי ביניהן לפי הקריטריונים שבאמת חשובים כשבוחרים כלי לפרויקט אמיתי.

קריטריון	requests + BS4 (ytInitialData)	Selenium / Playwright	yt-dlp	YouTube Data API	ללא קוד (Thunderbit)
מורכבות ההקמה	נמוכה	בינונית	נמוכה	בינונית (מפתח API)	אין
תמיכה ברינדור JS	חלקית (פענוח JSON)	כן	כן	לא רלוונטי (API מובנה)	כן
מהירות	מהירה	איטית	מהירה	מהירה	מהירה (ענן)
סיכון לאנטי-בוט	בינוני	גבוה	נמוך	אין	מטופל אוטומטית
מכסות / מגבלות קצב	אין	אין (אבל זיהוי)	אין	10,000 יחידות ביום	מבוסס קרדיטים
חילוץ תגובות	קשה	אפשרי אבל מורכב	מובנה	מובנה	תלוי בעמוד
תמלולים	לא	מורכב	כן	לא	לא
הכי מתאים ל	מטא־דאטה מהיר	תוצאות חיפוש, עמודים דינמיים	מטא־דאטה בכמויות + תגובות	נתונים מובנים בקנה מידה	לא-מתכנתים, ייצוא מהיר

סיכום קצר:

אילו נתונים באמת אפשר לחלץ מ-YouTube, ובאיזו שיטה?

זו טבלת הייחוס שהייתי רוצה שהייתה לי כשהתחלתי. אף שיטה אחת לא מכסה את כל השדות — וזו בדיוק הסיבה שהמאמר הזה עוסק בארבע.

שדה נתונים	BS4 (ytInitialData)	Selenium/Playwright	yt-dlp	YouTube API	Thunderbit
כותרת הסרטון	✅	✅	✅	✅	✅
מספר צפיות	✅	✅	✅	✅	✅
מספר לייקים	⚠️ לא עקבי	✅	✅	✅	✅
תגובות (טקסט)	❌	⚠️ מורכב	✅	✅	⚠️
תמלול/כתוביות	❌	⚠️	✅	❌	❌
תגיות	✅	✅	✅	✅	⚠️
כתובות URL של תמונות ממוזערות	✅	✅	✅	✅	✅
מספר מנויים של הערוץ	⚠️	✅	✅	✅	✅
תאריך העלאה	✅	✅	✅	✅	✅
משך הסרטון	✅	✅	✅	✅	✅
נתונים ייעודיים ל-Shorts	❌	⚠️	✅	⚠️	⚠️

בחרו את השיטה לפי השורות שהכי חשובות לפרויקט שלכם. אם אתם צריכים תגובות ותמלולים, yt-dlp הוא המנצח הברור. אם אתם צריכים נתונים מובנים בקנה מידה בינוני, ה-API הוא ההימור הטוב ביותר. ואם אתם צריכים נתונים תוך שתי דקות, המשיכו לקרוא על Thunderbit.

שיטה 1: גרידת YouTube עם Python באמצעות requests + BeautifulSoup (פענוח ytInitialData)

השיטה הזו מנצלת את העובדה ש-YouTube מטמיע את כל נתוני העמוד כ-JSON בתוך ה-HTML הגולמי. לא צריך דפדפן — רק לדעת איפה לחפש.

רמת קושי: מתחילים
זמן נדרש: כ-15 דקות
מה צריך: Python 3.10+, requests, beautifulsoup4

שלב 1: שליחת בקשת GET לעמוד YouTube

שלחו בקשה עם כותרת User-Agent אמיתית. הכותרת ברירת המחדל python-requests/2.x נחסמת מיד — מדריך הכותרות של ScrapeOps מאשר שזה מלכודת הקריסה הנפוצה ביותר למתחילים.

import requests

HEADERS = {
    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
                  "AppleWebKit/537.36 (KHTML, like Gecko) "
                  "Chrome/114.0.0.0 Safari/537.36",
    "Accept-Language": "en-US,en;q=0.9",
    "Cookie": "CONSENT=YES+cb",  # עוקף את מסך ההסכמה של האיחוד האירופי
}

url = "https://www.youtube.com/@mkbhd/videos"
response = requests.get(url, headers=HEADERS)
print(response.status_code)  # אמור להיות 200

הקוקי CONSENT הוא קריטי — בלעדיו, בקשות מאזור האיחוד האירופי יופנו ל-consent.youtube.com, שמחזיר HTML בלי ytInitialData בכלל.

שלב 2: ניתוח ה-HTML ואיתור הסקריפט של ytInitialData

השתמשו ב-BeautifulSoup או ב-regex כדי למצוא את תגית <script> שמכילה var ytInitialData =:

import re
import json

# חילוץ JSON של ytInitialData
match = re.search(
    r"var ytInitialData\s*=\s*({.*?});</script>",
    response.text,
    re.DOTALL
)
if match:
    data = json.loads(match.group(1))
    print("ytInitialData חולץ בהצלחה")
else:
    print("ytInitialData לא נמצא — בדקו כותרות/קוקיות")

טעות נפוצה: שימוש ב-.*? לא חמדני עם }; כסימן סוף בלבד. סיומי אובייקטים מקוננים מופיעים כל הזמן בתוך ה-JSON ויחתכו את הלכידה מוקדם מדי. השתמשו ב-};</script> כמו ש-Scrapfly ב-2026 עושה — זו ההשמה האחרונה בתוך בלוק הסקריפט שלה.

שלב 3: ניווט במבנה ה-JSON כדי לחלץ נתוני סרטונים

ה-JSON מקונן מאוד. במקום לקבע נתיבים שנשברים בכל פעם ש-YouTube משנה את המבנה (וזה קורה לא מעט — יומן הבעיות של yt-dlp מתעד כמה שינויי פורמט מאז 2023), עדיף להשתמש בחיפוש רקורסיבי לפי מפתח:

def search_dict(partial, search_key):
    stack = [partial]
    while stack:
        cur = stack.pop()
        if isinstance(cur, dict):
            for k, v in cur.items():
                if k == search_key:
                    yield v
                else:
                    stack.append(v)
        elif isinstance(cur, list):
            stack.extend(cur)

# חילוץ מידע על סרטונים מעמוד ערוץ
videos = []
for vr in search_dict(data, "videoRenderer"):
    videos.append({
        "video_id": vr.get("videoId"),
        "title": vr["title"]["runs"][0]["text"],
        "views": vr.get("viewCountText", {}).get("simpleText", "N/A"),
        "published": vr.get("publishedTimeText", {}).get("simpleText", "N/A"),
    })

print(f"נמצאו {len(videos)} סרטונים")
for v in videos[:5]:
    print(f"  {v['title']} — {v['views']}")

הגישה הרקורסיבית הזו היא מה ש-scrapetube, yt-dlp ו-Scrapfly התכנסו אליה — היא שורדת את השינויים התכופים במבנה ה-JSON של YouTube.

שלב 4: ייצוא הנתונים ל-CSV או Excel

import csv

with open("youtube_videos.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["video_id", "title", "views", "published"])
    writer.writeheader()
    writer.writerows(videos)

print("הנתונים ייוצאו ל-youtube_videos.csv")

מתי להשתמש בשיטה הזו ומתי לא

מתאים ל: משיכת מטא־דאטה מהירה מכמה עמודי ערוץ או סרטון. כלי SEO קלים. ניתוח חד-פעמי שבו צריך כותרת, צפיות ותאריך העלאה.

מגבלות: מבנה ה-JSON משתנה — תקלות מתועדות כוללות את ריפרוט הלייקים (2023: מ-toggleButtonRenderer ל-segmentedLikeDislikeButtonViewModel), ריפרוט התיאור (2023: מ-description.runs[] ל-attributedDescription.content), ועיצוב מחדש של לשונית הסרטונים בערוץ (2022–2023: מ-gridRenderer ל-richGridRenderer). כתובות IP של דאטה-סנטר נחסמות לרוב בעדינות אחרי 50–200 בקשות. אין תגובות, אין תמלולים.

שיטה 2: גרידת YouTube עם Python באמצעות Selenium או Playwright

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

רמת קושי: בינונית
זמן נדרש: כ-30 דקות
מה צריך: Python 3.10+, Playwright (pip install playwright && playwright install) או Selenium + ChromeDriver

אני ממליץ על Playwright על פני Selenium בפרויקטים חדשים. המדדים של TestDino ל-2026 מראים ש-Playwright מהיר בערך פי 1.85 לכל פעולה, צורך כ-2.1× פחות זיכרון, ומציע בערך פי 4 קיבולת מקבילית לעומת Selenium. Playwright משתמש ב-WebSocket קבוע דרך Chrome DevTools Protocol בעוד Selenium משתמש ב-WebDriver-over-HTTP, מה שמוסיף שכבת תרגום לכל פקודה.

שלב 1: הגדרת Playwright

pip install playwright
playwright install chromium

from playwright.sync_api import sync_playwright

pw = sync_playwright().start()
browser = pw.chromium.launch(headless=False)  # מצב גלוי מפחית חלק מהזיהוי
context = browser.new_context()

# הוספת קוקי הסכמה מראש כדי לעקוף את המחסום של האיחוד האירופי
context.add_cookies([{
    "name": "SOCS",
    "value": "CAISNQgDEitib3FfaWRlbnRpdHlmcm9udGVuZHVpc2VydmVyXzIwMjMwODI5LjA3X3AxGgJlbiACGgYIgJnPpwY",
    "domain": ".youtube.com",
    "path": "/",
}])

page = context.new_page()

שלב 2: ניווט לעמוד YouTube והמתנה לטעינת התוכן

page.goto("https://www.youtube.com/@mkbhd/videos")
page.wait_for_selector("a#video-title-link", timeout=15000)
print("העמוד נטען — אלמנטים של סרטונים נראים")

אם אתם מגרדים תוצאות חיפוש, נווטו במקום זאת ל-https://www.youtube.com/results?search_query=your+query.

שלב 3: טיפול ב-Infinite Scroll כדי לטעון עוד סרטונים

YouTube משתמש ב-Infinite Scroll בעמודי ערוץ ובתוצאות חיפוש. הנה לולאת scrollHeight הקלאסית, מותאמת ממדריך הגלילה של Scrapfly:

prev_height = -1
max_scrolls = 20  # כדאי להגביל — ערוץ עם 10K סרטונים ימשיך לגלול לנצח
scroll_count = 0

while scroll_count < max_scrolls:
    page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
    page.wait_for_timeout(1500)  # המתנה לטעינת תוכן חדש
    new_height = page.evaluate("document.body.scrollHeight")
    if new_height == prev_height:
        break  # לא נטען תוכן חדש
    prev_height = new_height
    scroll_count += 1

print(f"בוצעו {scroll_count} גלילות")

שלב 4: חילוץ נתוני הסרטונים מהעמוד המרונדר

video_elements = page.query_selector_all("a#video-title-link")
videos = []

for el in video_elements:
    title = el.inner_text()
    href = el.get_attribute("href")
    video_id = href.split("v=")[-1] if href else None
    videos.append({"title": title, "video_id": video_id, "url": f"https://www.youtube.com{href}"})

print(f"חולצו {len(videos)} סרטונים")

עבור מספר צפיות ותאריכי העלאה, צריך לאסוף אלמנטים סמוכים. המדריך של Crawlee מ-2025 מזהיר ש-id="video-title-link" לא אוניברסלי — ל-YouTube יש כמה וריאציות של עמודים. הפתרון העמיד הוא a[href*="watch"].

שלב 5: ייצוא ל-CSV או Google Sheets

import csv

with open("youtube_playwright.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["title", "video_id", "url"])
    writer.writeheader()
    writer.writerows(videos)

browser.close()
pw.stop()

מתי להשתמש בשיטה הזו ומתי לא

מתאים ל: גרידת תוצאות חיפוש, אינטראקציה עם רכיבי עמוד דינמיים (לחיצה על טאבים, פתיחת תיאורים), וכל דבר שדורש DOM מרונדר במלואו.

מגבלות: איטי (~1.5–3 שניות לכל סרטון בזרימת גלילה+חילוץ). סיכון גבוה לזיהוי אנטי-בוט — Selenium רגיל קובע navigator.webdriver === true, מה שכל זיהוי בצד JS קורא מיד כך. כבד במשאבים (כל מופע דפדפן משתמש ב-200–500 MB RAM). עבור 100 סרטונים, צפו ל-3–8 דקות במקום שניות עם yt-dlp.

שיטה 3: גרידת YouTube עם Python באמצעות yt-dlp

yt-dlp הוא אולר השוויצרי של גרידת YouTube. זהו fork קהילתי של youtube-dl עם מעל 157,000 כוכבים ב-GitHub, גרסאות nightly פעילות, ותמיכה מובנית במטא־דאטה, תגובות, תמלולים וגרידה אצווה — בלי צורך בדפדפן או במפתח API.

רמת קושי: מתחילים עד בינוני
זמן נדרש: כ-10 דקות
מה צריך: Python 3.10+, pip install yt-dlp

שלב 1: התקנת yt-dlp

pip install yt-dlp

בלי דרייברי דפדפן, בלי מפתחות API, בלי קבצי הגדרות.

שלב 2: חילוץ מטא־דאטה של סרטון בלי להוריד אותו

import yt_dlp

opts = {
    "quiet": True,
    "skip_download": True,      # בלי בייטים של הווידאו — רק מטא־דאטה
    "no_warnings": True,
}

with yt_dlp.YoutubeDL(opts) as ydl:
    info = ydl.extract_info(
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
        download=False
    )

print(f"כותרת: {info['title']}")
print(f"צפיות: {info['view_count']:,}")
print(f"לייקים: {info.get('like_count', 'N/A')}")
print(f"משך: {info['duration']} שניות")
print(f"תאריך העלאה: {info['upload_date']}")
print(f"ערוץ: {info['channel']} ({info.get('channel_follower_count', 'N/A')} מנויים)")
print(f"תגיות: {info.get('tags', [])[:5]}")

קריאה טיפוסית ל-extract_info מחזירה 80–120 שדות, בהתאם למצב הסרטון: id, title, channel, channel_id, channel_follower_count, view_count, like_count, comment_count, upload_date, duration, tags, categories, description, thumbnails, is_live, availability, automatic_captions, subtitles, chapters, heatmap, ועוד.

שלב 3: חילוץ תגובות מסרטון YouTube

opts = {
    "quiet": True,
    "skip_download": True,
    "getcomments": True,
    "extractor_args": {
        "youtube": {
            "max_comments": ["200", "50", "50", "10"],  # סה"כ, הורים, תשובות-לכל, תשובות-סה"כ
            "comment_sort": ["top"],
        }
    },
}

with yt_dlp.YoutubeDL(opts) as ydl:
    info = ydl.extract_info(
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
        download=False
    )

comments = info.get("comments", [])
print(f"נשלפו {len(comments)} תגובות")
for c in comments[:3]:
    print(f"  [{c.get('like_count', 0)} לייקים] {c['author']}: {c['text'][:80]}...")

חילוץ תגובות איטי. בעיה #3532 ב-yt-dlp מדווחת על קצב של כ-30 KB/s בעת שליפת תגובות — סרטון עם 100K תגובות יכול לקחת שעות. בעיה #11849 מתעדת סרטונים שבהם כתובות ה-URL של הפורמטים פגות תוקף (~6 שעות) לפני שסיום דפדוף התגובות מסתיים. הגדירו max_comments בצורה אגרסיבית עבור סרטונים גדולים.

שלב 4: חילוץ תמלולים וכתוביות

לא ה-YouTube Data API ולא ניתוח BS4 יכולים לתת לכם תמלול מלא. זה היתרון הייחודי של yt-dlp.

opts = {
    "quiet": True,
    "skip_download": True,
    "writesubtitles": True,
    "writeautomaticsub": True,
    "subtitleslangs": ["en", "en-orig"],
    "subtitlesformat": "json3",   # ניתן לפענוח מכונה: start/dur במילישניות + טקסט
    "outtmpl": "%(id)s.%(ext)s",
}

with yt_dlp.YoutubeDL(opts) as ydl:
    info = ydl.extract_info(
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
        download=False
    )

# גישה ישירה לנתוני הכתוביות מתוך מילון info
auto_captions = info.get("automatic_captions", {})
manual_subs = info.get("subtitles", {})
print(f"שפות כתוביות אוטומטיות: {list(auto_captions.keys())[:10]}")
print(f"שפות כתוביות ידניות: {list(manual_subs.keys())}")

הפורמט json3 מועדף לניתוח מכונה — לכל מקטע יש start/dur במילישניות יחד עם טקסט. קודי השפה הם BCP-47 (en, en-US, zh-Hans, ja, es).

שלב 5: גרידה אצוותית של כמה סרטונים או ערוץ שלם

opts = {
    "quiet": True,
    "skip_download": True,
    "extract_flat": "in_playlist",  # מהיר — רק מזהי סרטונים וכותרות
    "sleep_interval": 2,
    "max_sleep_interval": 6,
}

with yt_dlp.YoutubeDL(opts) as ydl:
    info = ydl.extract_info(
        "https://www.youtube.com/@mkbhd/videos",
        download=False
    )

entries = info.get("entries", [])
print(f"נמצאו {len(entries)} סרטונים בערוץ")
for e in entries[:5]:
    print(f"  {e.get('title', 'N/A')} — {e.get('id')}")

אפשר להעביר כתובת של ערוץ, פלייליסט, או אפילו שאילתת חיפוש (ytsearch10:python scraping) ו-yt-dlp מטפל בדפדוף פנימי.

מתי להשתמש בשיטה הזו ומתי לא

מתאים ל: חילוץ מטא־דאטה בכמויות, תגובות, תמלולים, הורדת סרטונים, או גרידות ברמת ערוץ שבו צריך את כל שדות הנתונים.

מגבלות: לא אידיאלי לגרידת עמודי תוצאות חיפוש (לזה Selenium/Playwright טובים יותר). מירוץ החימוש נגד אנטי-בוט בין 2024–2026 הפך את yt-dlp למורכב יותר להרצה בקנה מידה — YouTube אוכף עכשיו BotGuard attestation ו-PO Tokens על חלק מהקליינטים. לשימוש בייצור, התקינו את התוסף bgutil-ytdlp-pot-provider והשתמשו ב---cookies-from-browser chrome (עם חשבון חד-פעמי — צוות yt-dlp מזהיר שקוקיז מחשבון Google אמיתי עלולים להוביל לחסימת החשבון).

שיטה 4: גרידת YouTube עם Python באמצעות YouTube Data API

ה-YouTube Data API v3 הרשמי הוא הדרך הכי אמינה ומובנית לקבל נתוני YouTube. התשובות הן JSON נקי, השדות מתועדים, ואין משחקי חתול-עכבר של אנטי-בוט. אבל יש מלכוד שרוב המדריכים מדלגים עליו: מערכת המכסות.

רמת קושי: בינונית
זמן נדרש: כ-20 דקות (כולל הגדרת מפתח API)
מה צריך: Python 3.10+, פרויקט ב-Google Cloud, pip install google-api-python-client

שלב 1: קבלת מפתח ל-YouTube Data API

היכנסו ל-Google Cloud Console
צרו פרויקט חדש (או בחרו קיים)
עברו ל-APIs & Services → Library → חפשו "YouTube Data API v3" → Enable
עברו ל-APIs & Services → Credentials → Create Credentials → API Key
העתיקו את המפתח — תשתמשו בו בקוד שלמטה

שלב 2: קריאת API ראשונה

from googleapiclient.discovery import build

API_KEY = "YOUR_API_KEY_HERE"
youtube = build("youtube", "v3", developerKey=API_KEY)

# שליפת פרטים עבור סרטון ספציפי
response = youtube.videos().list(
    part="snippet,statistics,contentDetails",
    id="dQw4w9WgXcQ"
).execute()

video = response["items"][0]
print(f"כותרת: {video['snippet']['title']}")
print(f"צפיות: {video['statistics']['viewCount']}")
print(f"לייקים: {video['statistics'].get('likeCount', 'hidden')}")
print(f"תגובות: {video['statistics'].get('commentCount', 'disabled')}")
print(f"משך: {video['contentDetails']['duration']}")
print(f"תגיות: {video['snippet'].get('tags', [])[:5]}")

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

שלב 3: חילוץ פרטי סרטונים, מידע על ערוצים ותגובות

# חיפוש סרטונים
search_response = youtube.search().list(
    part="snippet",
    q="python web scraping tutorial",
    type="video",
    maxResults=10,
    order="viewCount"
).execute()

for item in search_response["items"]:
    print(f"  {item['snippet']['title']} — {item['id']['videoId']}")

# תגובות
comments_response = youtube.commentThreads().list(
    part="snippet",
    videoId="dQw4w9WgXcQ",
    maxResults=20,
    order="relevance"
).execute()

for item in comments_response["items"]:
    comment = item["snippet"]["topLevelComment"]["snippet"]
    print(f"  [{comment['likeCount']} לייקים] {comment['authorDisplayName']}: {comment['textDisplay'][:80]}")

מציאות המכסה של YouTube API (מה שאף אחד לא מספר לכם)

זה החלק שמפריד בין מדריך שימושי לבין מדריך להעתקה-הדבקה. ההקצאה ברירת המחדל היא 10,000 יחידות מכסה ביום, שמתאפסת בחצות לפי שעון פסיפיק. הנה כמה עולה כל קריאה:

נקודת קצה של ה-API	עלות מכסה לכל קריאה	מקסימום תוצאות לכל קריאה
`search.list`	100 יחידות	50 תוצאות
`videos.list`	1 יחידה	50 מזהי סרטון (באצווה)
`channels.list`	1 יחידה	50 מזהי ערוצים
`commentThreads.list`	1 יחידה	100 תגובות
`captions.list`	50 יחידות	לא רלוונטי

עכשיו החישוב. נניח שאתם רוצים לגרד 1,000 תוצאות חיפוש:

קריאות חיפוש: 1,000 תוצאות ÷ 50 לעמוד = 20 קריאות × 100 יחידות = 2,000 יחידות (20% מהתקציב היומי — נגמר)
פרטי סרטון עבור 1,000 הסרטונים האלה: 1,000 מזהים ÷ 50 לאצווה = 20 קריאות × 1 יחידה = 20 יחידות (זול — videos.list באצווה הוא החסד הגדול)
תגובות עבור 1,000 הסרטונים האלה (בהנחה שעמוד אחד לכל סרטון): 1,000 קריאות × 1 יחידה = 1,000 יחידות

סה"כ: כ-3,020 יחידות לגרידה צנועה. אבל אם לסרטונים האלה יש שרשראות תגובות עמוקות (50+ עמודים לכל סרטון), תשרפו במהירות את 7,000 היחידות שנותרו. סרטון עם 50,000 תגובות = בערך 500 עמודים = 500 יחידות. גרדו 20 סרטונים כאלה — והיום נגמר.

תהליך הגדלת המכסה דורש ביקורת ציות מלאה: כתובת מדיניות פרטיות, כתובת תנאי שימוש, סרטון הדגמה של האפליקציה, ונימוק מתמטי לצריכת המכסה. דיווחים מהקהילה מצביעים על תגובת Google טיפוסית בתוך 3–5 ימי עסקים, אישור מלא יכול לקחת שבועות עד חודשים, ורבות מהבקשות נדחות — במיוחד שימושים בסגנון "אני רוצה יותר נתונים לניתוח".

מתי להשתמש ב-API: בהיקף קטן עד בינוני, כשצריך נתונים מובנים ואמינים, כשתגובות וסטטיסטיקות ערוץ חשובות, וכשאפשר לחיות עם תקרת המכסה.

מתי גרידה עדיפה: פרויקטים בקנה מידה גדול (>10K סרטונים ביום), שדות שה-API לא חושף (תמלולים מלאים — captions.download דורש OAuth והרשאת בעל הסרטון), או כשצריך יותר מ-500 תוצאות חיפוש לשאילתה (מגבלה קשיחה של ה-API בלי קשר ל-totalResults).

קיצור הדרך ללא קוד: גרידת YouTube עם Thunderbit (בלי Python)

אם אתם צריכים Python כחלק מצינור נתונים, השתמשו בשיטות 1–4 למעלה. אבל אם אתם צריכים נתוני YouTube בתוך 2 דקות — אולי אתם משווקים שרוצים נתוני מתחרים, או מפתחים שרוצה שליפה מהירה בלי להקים סביבת פרויקט — יש מסלול מהיר יותר.

Thunderbit הוא תוסף Chrome לגרידת אתרים באמצעות AI, שנבנה במיוחד למקרים שבהם כתיבת קוד היא פשוט מוגזמת. הוא עובד ישירות על עמודי YouTube בדפדפן שלכם.

איך לגרד את YouTube עם Thunderbit ב-3 שלבים

שלב 1: התקינו את תוסף Thunderbit ל-Chrome ופתחו עמוד ערוץ YouTube, עמוד תוצאות חיפוש או עמוד סרטון.

שלב 2: לחצו על "AI Suggest Fields" בסרגל הצד של Thunderbit. ה-AI קורא את העמוד ומציע עמודות כמו כותרת הסרטון, צפיות, תאריך העלאה, משך, שם הערוץ ו-URL של התמונה הממוזערת. אפשר להוסיף, להסיר או לשנות שמות של עמודות לפי הצורך.

שלב 3: לחצו על "Scrape" וייצאו ל-Google Sheets, Excel, CSV, Airtable או Notion. הנתונים יגיעו כטבלה נקייה, מוכנה לעבודה.

נסו את Thunderbit לגרידת YouTube

למי זה מתאים

משווקים שצריכים נתוני ערוצי מתחרים אבל לא כותבים קוד
מפתחים שרוצים שליפה מהירה בלי להקים virtual environment ולהתקין תלויות
כל מי שנתקע מול חסימות אנטי-בוט — Thunderbit מגרד בתוך סשן הדפדפן המחובר של המשתמש, כך שהוא יורש את הקוקיז ואת ה-PO tokens שלכם. זה עוקף הרבה מהבעיות שמטרידות גרידות בצד השרת
Thunderbit יכול גם להשתמש ב-גרידת תתי-עמודים כדי לבקר בכל עמוד סרטון ולהעשיר את הטבלה בפרטים נוספים (לייקים, תיאור, תגיות)

להבנה עמוקה יותר של האופן שבו Thunderbit מטפל ב-YouTube ספציפית, עיינו ב-תבנית Thunderbit ל-YouTube Channel Scraper וב-ערוץ YouTube של Thunderbit.

טיפים לגרידת YouTube עם Python בלי להיחסם

הטיפים האלה רלוונטיים לכל ארבע השיטות ב-Python. מנגנוני האנטי-בוט של YouTube מדורגים 6/10 בקושי לפי ScrapeOps, עם שלושה אותות עיקריים: ניתוח התנהגות IP, דרישת הרצת JS, ומבנה HTML שמשתנה לעיתים קרובות.

לכל השיטות:

סובבו מחרוזות User-Agent וגם את כל סט הכותרות — Accept, Accept-Language, ו-Sec-CH-UA צריכים להתאים ל-UA המוצהר. המדריך של ScraperAPI ל-2026 כולל רשימה עדכנית.
הוסיפו השהיות אקראיות של 2–8 שניות בין בקשות. מרווחים קבועים הם אות זיהוי.
השתמשו בפרוקסי Residential לכל דבר מעבר לכמה עמודים. כתובות IP של דאטה-סנטר (AWS, GCP, Hetzner) כמעט מתות לגרידת YouTube ב-2025–2026.
סובבו session + IP יחד — YouTube קושר סשנים ל-IP, וקוקי של אותו סשן שמופיע בשתי כתובות IP הוא דגל אדום.

עבור requests + BS4: הגדירו את הקוקי CONSENT=YES+cb. בלעדיו, בקשות מהאיחוד האירופי יופנו לעמוד הסכמה בלי נתונים.

עבור Selenium/Playwright: הריצו במצב גלוי עם xvfb בשרתי Linux במקום --headless=new — Chrome ללא UI עדיין חושף מספיק טביעות אצבע לזיהוי מתקדם. שקלו את playwright-stealth, שמיישם כ-17 מנגנוני התחמקות.

עבור yt-dlp: השתמשו באפשרויות sleep_interval ו-max_sleep_interval. התקינו את התוסף bgutil-ytdlp-pot-provider ליצירת PO Token. השתמשו ב---cookies-from-browser chrome עם חשבון חד-פעמי.

עבור ה-API: עקבו אחרי צריכת המכסה דרך Google Cloud Console ובצעו בקשות באצווה ביעילות. קריאה אחת ל-videos.list עם 50 מזהים מופרדים בפסיקים עולה 1 יחידה — נצלו את זה.

עבור Thunderbit: מנגנוני האנטי-בוט מטופלים אוטומטית כי הגרידה מתבצעת בתוך סשן הדפדפן שלכם. בפועל, אתם פשוט מבצעים אוטומציה למה שהייתם עושים ידנית.

האם חוקי לגרד את YouTube עם Python?

זה תלוי מה מגרדים, איך מגרדים, ומה עושים עם הנתונים.

הנוף המשפטי השתנה ב-2024 עם Meta Platforms v. Bright Data (מחוז צפון קליפורניה, ינואר 2024), שבו השופט Chen קבע שתנאי השימוש של Meta אוסרים רק גרידה בזמן התחברות, ולא גרידה של נתונים ציבוריים ללא התחברות. גרידה של מידע נגיש לציבור הפכה ל"פחות מסוכנת משמעותית" אחרי הפסיקה הזו. מנגד, hiQ v. LinkedIn הסתיים ב-פסק דין של 500,000 דולר נגד hiQ בשל הפרת תנאי שימוש, הפרות CFAA (חשבונות מזויפים), ו-trespass to chattels — בנוסף לצו מניעה קבוע.

תנאי השימוש של YouTube עצמם ברורים: "אינכם מורשים לגשת לשירות באמצעים אוטומטיים כלשהם (כגון רובוטים, בוטנטים או סקרייפרים)" אלא אם יש אישור כתוב מראש או אם הדבר מותר לפי הדין החל. YouTube Data API הוא הדרך הרשמית והמאושרת לגשת לנתונים.

כמה כללי אצבע פרקטיים:

גרידה של נתונים גלויים לציבור לצורכי מחקר אישי או ניתוח לא-מסחרי היא בדרך כלל בסיכון נמוך יותר
ה-API הוא המסלול הבטוח ביותר — הוא מורשה במפורש
הימנעו מגרידת תוכן פרטי/מאחורי התחברות, מהורדת סרטונים מוגנים בזכויות יוצרים לצורכי הפצה מחדש, או מהפרת GDPR באמצעות נתונים אישיים מתגובות
תגובות ב-YouTube מכילות מידע אישי לפי GDPR Art. 4(1) — התייחסו למידע של נושאי מידע מהאיחוד האירופי בזהירות
התייעצו עם יועץ משפטי עבור פרויקטים מסחריים

כל זה אינו ייעוץ משפטי. הנוף משתנה במהירות — גל חדש של תביעות DMCA §1201 מיוצרים נגד חברות AI שגרדו YouTube לצורכי אימון משנה את המפה ב-2025–2026.

איזו שיטה כדאי לבחור לגרידת YouTube עם Python?

מדריך ההחלטה:

צריך מטא־דאטה מהיר מכמה עמודים? → שיטה 1 (requests + BS4). מהירה, קלה, בלי תלויות מעבר ל-requests ו-beautifulsoup4.
צריך לגרד תוצאות חיפוש או לעבוד עם עמודים דינמיים? → שיטה 2 (Selenium/Playwright). רינדור מלא של דפדפן, תמיכה בגלילה אינסופית, אבל איטי ונוטה לזיהוי.
צריך מטא־דאטה בכמות, תגובות או תמלולים? → שיטה 3 (yt-dlp). הכלי הבודד הכי חזק — 157K+ כוכבים לא במקרה.
צריך נתונים מובנים ואמינים בקנה מידה בינוני? → שיטה 4 (YouTube Data API). רשמי, נקי, אבל מוגבל ל-10,000 יחידות ביום.
צריך נתונים בתוך 2 דקות בלי לכתוב קוד? → Thunderbit. מבוסס דפדפן, מונע AI, מייצא ל-Google Sheets בכמה לחיצות.

אין שיטה אחת שמכסה כל מקרה שימוש. שמרו לכם את טבלת ההשוואה ואת טבלת שדות הנתונים למעלה — הן יחסכו לכם זמן בפרויקט הבא. ואם תרצו להעמיק בעוד גישות לגרידת אתרים, יש לנו הרבה מדריכים בבלוג של Thunderbit, מ-מדריכי Python לגרידה ועד גרידת נתונים ל-Google Sheets.

נסו את Thunderbit לגרידת YouTube Get Started Free

שאלות נפוצות

אפשר לגרד את YouTube בלי מפתח API?

כן. שיטות 1 (requests + BS4), 2 (Selenium/Playwright) ו-3 (yt-dlp) לא דורשות מפתח API. רק שיטה 4 (YouTube Data API) דורשת אחד. Thunderbit גם עובד בלי שום מפתח API — הוא מגרד ישירות בדפדפן שלכם.

מה הדרך המהירה ביותר לגרד את YouTube עם Python?

ב-Python, yt-dlp ו-requests + BS4 הם המהירים ביותר — שניהם עוקפים את העלות של הדפדפן ויכולים למשוך מטא־דאטה בתוך שניות לכל סרטון. yt-dlp מהיר במיוחד בעבודת אצווה כי הוא מטפל בדפדוף פנימי. למי שלא עובד עם Python, Thunderbit הוא המהיר ביותר בסך הכול כי אין זמן הקמה.

איך מגרדים תגובות מ-YouTube עם Python?

yt-dlp כולל חילוץ תגובות מובנה דרך האפשרות getcomments — זו הדרך הפשוטה ביותר. גם YouTube Data API תומך בתגובות דרך commentThreads.list (יחידת מכסה אחת לכל קריאה, עד 100 תגובות לעמוד). Selenium/Playwright יכולים טכנית לעשות זאת באמצעות גלילה וחילוץ אלמנטים מרונדרים של תגובות, אבל זה איטי ושביר.

אפשר לגרד YouTube Shorts עם Python?

כן. yt-dlp מתמודד היטב עם מטא־דאטה של Shorts — הוא מתייחס אליהם כסרטונים רגילים עם שדות ייעודיים נוספים ל-Shorts. ל-YouTube Data API יש תמיכה חלקית (ספירת הצפיות ב-Shorts שונתה ב-30 באפריל 2025 — כעת כל התחלת נגינה/הפעלה חוזרת נספרת). ל-BS4 ול-Selenium/Playwright יש תמיכה מוגבלת ב-Shorts כי מדפי ה-Shorts משתמשים במבני DOM שונים.

כמה סרטוני YouTube אפשר לגרד ביום?

עם YouTube Data API אתם מוגבלים לכ-10,000 יחידות מכסה ביום. באמצעות קריאות videos.list באצווה (50 מזהים לקריאה ב-1 יחידה), זה יכול להגיע עד 500,000 בדיקות סטטוס של סרטונים ביום — אבל search.list שעולה 100 יחידות לקריאה שורף את התקציב מהר. בשיטות גרידה (BS4, Selenium, yt-dlp), המגבלה היא מעשית ולא קשיחה: חסימות IP בדרך כלל נכנסות לפעולה אחרי כמה מאות עד כמה אלפי בקשות לכל IP ביום, תלוי בהגדרת הפרוקסי ובדפוסי הבקשות. Thunderbit משתמש במערכת קרדיטים שקשורה ל-תוכנית שלכם.

למידע נוסף

מדף אינטרנט לגיליון נתונים

תארו מה אתם צריכים — סוכן ה-AI של Thunderbit מחלץ את זה ומייצא ל-Excel, Google Sheets, Airtable או Notion. חינמי להתחלה.

Chrome Store Rating

PRODUCT HUNT#1 Product of the Week

גרידת YouTube עם Python: 4 שיטות שבאמת עובדות

למה בכלל לגרד את YouTube עם Python?

למה requests + BeautifulSoup לבדן לא יגרדו את YouTube

4 דרכים לגרד את YouTube עם Python: השוואה זה לצד זה

אילו נתונים באמת אפשר לחלץ מ-YouTube, ובאיזו שיטה?

שיטה 1: גרידת YouTube עם Python באמצעות requests + BeautifulSoup (פענוח ytInitialData)

שלב 1: שליחת בקשת GET לעמוד YouTube

שלב 2: ניתוח ה-HTML ואיתור הסקריפט של ytInitialData

שלב 3: ניווט במבנה ה-JSON כדי לחלץ נתוני סרטונים

שלב 4: ייצוא הנתונים ל-CSV או Excel

מתי להשתמש בשיטה הזו ומתי לא

שיטה 2: גרידת YouTube עם Python באמצעות Selenium או Playwright

שלב 1: הגדרת Playwright

שלב 2: ניווט לעמוד YouTube והמתנה לטעינת התוכן

שלב 3: טיפול ב-Infinite Scroll כדי לטעון עוד סרטונים

שלב 4: חילוץ נתוני הסרטונים מהעמוד המרונדר

שלב 5: ייצוא ל-CSV או Google Sheets

מתי להשתמש בשיטה הזו ומתי לא

שיטה 3: גרידת YouTube עם Python באמצעות yt-dlp

שלב 1: התקנת yt-dlp

שלב 2: חילוץ מטא־דאטה של סרטון בלי להוריד אותו

שלב 3: חילוץ תגובות מסרטון YouTube

שלב 4: חילוץ תמלולים וכתוביות

שלב 5: גרידה אצוותית של כמה סרטונים או ערוץ שלם

מתי להשתמש בשיטה הזו ומתי לא

שיטה 4: גרידת YouTube עם Python באמצעות YouTube Data API

שלב 1: קבלת מפתח ל-YouTube Data API

שלב 2: קריאת API ראשונה

שלב 3: חילוץ פרטי סרטונים, מידע על ערוצים ותגובות

מציאות המכסה של YouTube API (מה שאף אחד לא מספר לכם)

קיצור הדרך ללא קוד: גרידת YouTube עם Thunderbit (בלי Python)

איך לגרד את YouTube עם Thunderbit ב-3 שלבים

למי זה מתאים

טיפים לגרידת YouTube עם Python בלי להיחסם

האם חוקי לגרד את YouTube עם Python?

איזו שיטה כדאי לבחור לגרידת YouTube עם Python?

שאלות נפוצות

אפשר לגרד את YouTube בלי מפתח API?

מה הדרך המהירה ביותר לגרד את YouTube עם Python?

איך מגרדים תגובות מ-YouTube עם Python?

אפשר לגרד YouTube Shorts עם Python?

כמה סרטוני YouTube אפשר לגרד ביום?

איסוף נתונים אוטומטי

חלץ נתונים מכל דף בתוך קליק אחד