YouTube mit Python scrapen: 4 Methoden, die wirklich funktionieren

Wenn du schon einmal requests.get("https://www.youtube.com/...") ausprobiert und das Ergebnis mit BeautifulSoup nach Videotiteln durchsucht hast, kennst du den Dreh wahrscheinlich schon: Statt brauchbarer Daten bekommst du eine Wand aus leeren <div>-Tags und genau null verwertbare Informationen.

Das ist das Problem, das ich bei Entwickler:innen am häufigsten sehe, wenn sie zum ersten Mal versuchen, YouTube zu scrapen. YouTube ist eine Single-Page-App — fast alles wird clientseitig per JavaScript gerendert. Das HTML, das dein Python-Skript zurückbekommt, ist nur eine Hülle. Die echten Videotitel, Aufrufzahlen und Metadaten? Die stecken in einem riesigen JSON-Block namens ytInitialData, der erst nach dem Laden der Seite per JavaScript eingebunden wird.

Deshalb liefert dein eigentlich völlig vernünftiges soup.find("div", class_="ytd-video-renderer") None zurück — dieses Element existiert im rohen HTTP-Response schlicht nicht. Sobald ich das verstanden hatte, ergab das ganze Puzzle endlich Sinn — und die vier Methoden unten sind das Ergebnis von viel Testen, Kaputtmachen und viel zu vielen GitHub-Issues. Ich zeige dir jede Herangehensweise, erkläre dir genau, wann du welche einsetzen solltest, und hänge am Ende noch einen No-Code-Shortcut für alle an, die einfach nur Daten wollen, ohne erst ein Projekt aufzusetzen.

Warum YouTube überhaupt mit Python scrapen?

YouTube ist nicht nur eine Videoplattform — es ist eine Datenquelle mit . Mit und gibt es dort eine riesige Menge öffentlich sichtbarer Informationen, die Unternehmen, Forschende und Creator programmatisch auswerten wollen.

Der Haken: Die integrierten YouTube-Analytics zeigen nur Daten für den eigenen Kanal. Wenn du die Upload-Frequenz eines Konkurrenten verstehen, Trendthemen in deiner Nische verfolgen oder die Stimmung in Kommentaren zu fremden Videos analysieren willst, musst du scrapen.

Hier sind die häufigsten Praxisfälle, die ich gesehen habe:

Eine Wettbewerbsanalyse zu DJI vs. GoPro vs. Insta360 zeigte zum Beispiel, dass — genau die Art von Erkenntnis, die in YouTube Studio nicht sichtbar wird.

Warum requests + BeautifulSoup allein YouTube nicht scrapen kann

Bevor wir zu den Methoden kommen, die funktionieren, musst du verstehen, warum der naheliegende Ansatz scheitert. Das ist nicht bloß Theorie — es spart dir Stunden an Debugging.

Der offensichtliche Ansatz sieht konzeptionell ungefähr so aus:

1import requests
2from bs4 import BeautifulSoup
3response = requests.get("https://www.youtube.com/@somechannel/videos")
4soup = BeautifulSoup(response.text, "html.parser")
5videos = soup.find_all("a", id="video-title-link")
6print(len(videos))  # 0 — jedes Mal

Das Ergebnis ist immer null. Wie das sagt: „The page was loaded dynamically, which is not supported by the requests lib.“ Der formuliert es noch direkter: „Using requests and BeautifulSoup alone you cannot execute JavaScript."

erklärt den Mechanismus: YouTube ist als Single Page Application (SPA) gebaut. Bei einfachen HTTP-Requests bekommst du nur die anfängliche HTML-Hülle — der eigentliche Inhalt ist da noch gar nicht gerendert. Die Videodaten stecken in JavaScript-Objekten, die ein Browser normalerweise ausführt und anschließend ins DOM schreibt.

Die gute Nachricht: YouTube bettet alle benötigten Daten tatsächlich in das rohe HTML ein. Sie stehen nur nicht in DOM-Elementen — sondern in zwei JSON-Blobs innerhalb von <script>-Tags:

• ytInitialData — Seitenstruktur, Videolisten, Engagement-Metriken, Kommentar-Fortsetzungstokens
• ytInitialPlayerResponse — zentrale Videometadaten (Titel, Beschreibung, Dauer, Formate, Untertitel)

Beide kannst du mit einem einzigen requests.get() auslesen — ganz ohne Browser, wenn du weißt, wie du sie extrahierst und parst. Das ist unten Methode 1.

4 Wege, YouTube mit Python zu scrapen: Vergleich auf einen Blick

Bevor wir in die Details gehen, hier die Entscheidungsmatrix. Ich habe alle vier Ansätze getestet und nach den Kriterien verglichen, die bei einem echten Projekt wirklich zählen.

Kurz zusammengefasst:

Welche YouTube-Daten kannst du überhaupt extrahieren — und womit?

Das ist die Referenztabelle, die ich mir am Anfang gewünscht hätte. Keine einzelne Methode deckt jedes Feld ab — genau deshalb behandelt dieser Artikel vier Ansätze.

Wähle deine Methode danach aus, welche Zeilen für dein Projekt am wichtigsten sind. Wenn du Kommentare und Transkripte brauchst, ist yt-dlp klar vorne. Wenn du strukturierte Statistiken in mittlerem Umfang benötigst, ist die API die beste Wahl. Wenn du die Daten in zwei Minuten brauchst, lies direkt weiter zum Thunderbit-Abschnitt.

Methode 1: YouTube mit Python scrapen mit requests + BeautifulSoup (ytInitialData-Parsen)

Diese Methode nutzt aus, dass YouTube alle Seitendaten als JSON direkt im Roh-HTML einbettet. Du brauchst keinen Browser — du musst nur wissen, wo du suchen musst.

• Schwierigkeit: Anfänger
• Zeitaufwand: ca. 15 Minuten
• Was du brauchst: Python 3.10+, requests, beautifulsoup4

Schritt 1: Eine GET-Anfrage an die YouTube-Seite senden

Sende eine Anfrage mit einem realistischen User-Agent-Header. Der Standard-Header python-requests/2.x wird sofort geblockt — bestätigt, dass das für Einsteiger die größte Stolperfalle ist.

1import requests
2HEADERS = {
3    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
4                  "AppleWebKit/537.36 (KHTML, like Gecko) "
5                  "Chrome/114.0.0.0 Safari/537.36",
6    "Accept-Language": "en-US,en;q=0.9",
7    "Cookie": "CONSENT=YES+cb",  # umgeht die EU-Consent-Wall
8}
9url = "https://www.youtube.com/@mkbhd/videos"
10response = requests.get(url, headers=HEADERS)
11print(response.status_code)  # sollte 200 sein

Der CONSENT-Cookie ist entscheidend — ohne ihn werden Requests aus der EU zu consent.youtube.com umgeleitet, und diese Seite enthält überhaupt kein ytInitialData.

Schritt 2: HTML parsen und das ytInitialData-Skript finden

Nutze BeautifulSoup oder einen Regex, um das <script>-Tag mit var ytInitialData = zu finden:

1import re
2import json
3# ytInitialData-JSON extrahieren
4match = re.search(
5    r"var ytInitialData\s*=\s*({.*?});</script>",
6    response.text,
7    re.DOTALL
8)
9if match:
10    data = json.loads(match.group(1))
11    print("ytInitialData erfolgreich extrahiert")
12else:
13    print("ytInitialData nicht gefunden — prüfe deine Header/Cookies")

Ein häufiger Fehler: ein nicht-gieriges .*? mit nur }; als Endmarke zu verwenden. Geschachtelte Objektenden kommen im JSON ständig vor und schneiden die Extraktion zu früh ab. Nutze stattdessen };</script>, wie es auch macht — das ist die letzte Zuweisung in diesem Script-Block.

Schritt 3: Die JSON-Struktur durchlaufen und Videodaten extrahieren

Das JSON ist stark verschachtelt. Statt harte Pfade fest zu verdrahten, die bei jeder YouTube-Umstrukturierung brechen (was regelmäßig passiert — der dokumentiert mehrere Formatänderungen seit 2023), solltest du lieber eine rekursive Schlüsselsuche verwenden:

1def search_dict(partial, search_key):
2    stack = [partial]
3    while stack:
4        cur = stack.pop()
5        if isinstance(cur, dict):
6            for k, v in cur.items():
7                if k == search_key:
8                    yield v
9                else:
10                    stack.append(v)
11        elif isinstance(cur, list):
12            stack.extend(cur)
13# Videoinfos von der Kanalseite extrahieren
14videos = []
15for vr in search_dict(data, "videoRenderer"):
16    videos.append({
17        "video_id": vr.get("videoId"),
18        "title": vr["title"]["runs"][0]["text"],
19        "views": vr.get("viewCountText", {}).get("simpleText", "N/A"),
20        "published": vr.get("publishedTimeText", {}).get("simpleText", "N/A"),
21    })
22print(f"{len(videos)} Videos gefunden")
23for v in videos[:5]:
24    print(f"  {v['title']} — {v['views']}")

Dieser rekursive Ansatz ist genau der, auf den , yt-dlp und Scrapfly am Ende alle gekommen sind — er hält YouTubes häufigen JSON-Umstrukturierungen stand.

Schritt 4: Extrahierte Daten als CSV oder Excel exportieren

1import csv
2with open("youtube_videos.csv", "w", newline="", encoding="utf-8") as f:
3    writer = csv.DictWriter(f, fieldnames=["video_id", "title", "views", "published"])
4    writer.writeheader()
5    writer.writerows(videos)
6print("Daten wurden nach youtube_videos.csv exportiert")

Wann du diese Methode nutzen solltest — und wann nicht

Am besten für: Schnelle Metadaten-Extraktion von wenigen Kanal- oder Videoseiten. Leichte SEO-Tools. Einmalige Analysen, bei denen du Titel, Views und Upload-Datum brauchst.

Einschränkungen: Die JSON-Struktur ändert sich — dokumentierte Brüche umfassen den Like-Button-Refactor (2023: toggleButtonRenderer → segmentedLikeDislikeButtonViewModel), den Beschreibung-Refactor (2023: description.runs[] → attributedDescription.content) und das Redesign des Kanal-Tabs „Videos“ (2022–2023: gridRenderer → richGridRenderer). Datacenter-IPs werden typischerweise nach 50–200 Requests soft-geblockt. Keine Kommentare, keine Transkripte.

Methode 2: YouTube mit Python scrapen mit Selenium oder Playwright

Wenn du mit der Seite interagieren musst — etwa durch Suchergebnisse scrollen, Tabs anklicken oder Beschreibungen ausklappen — ist Browser-Automatisierung der richtige Weg.

• Schwierigkeit: Fortgeschritten
• Zeitaufwand: ca. 30 Minuten
• Was du brauchst: Python 3.10+, Playwright (pip install playwright && playwright install) oder Selenium + ChromeDriver

Ich würde für neue Projekte Playwright statt Selenium empfehlen. zeigen Playwright mit rund im Vergleich zu Selenium. Playwright nutzt einen persistenten WebSocket über das Chrome DevTools Protocol, während Selenium WebDriver über HTTP verwendet und pro Befehl eine Übersetzungsschicht einführt.

Schritt 1: Playwright einrichten

1pip install playwright
2playwright install chromium

1from playwright.sync_api import sync_playwright
2pw = sync_playwright().start()
3browser = pw.chromium.launch(headless=False)  # sichtbarer Modus vermeidet manche Erkennungen
4context = browser.new_context()
5# Consent-Cookie vorab setzen, um die EU-Wall zu umgehen
6context.add_cookies([{
7    "name": "SOCS",
8    "value": "CAISNQgDEitib3FfaWRlbnRpdHlmcm9udGVuZHVpc2VydmVyXzIwMjMwODI5LjA3X3AxGgJlbiACGgYIgJnPpwY",
9    "domain": ".youtube.com",
10    "path": "/",
11}])
12page = context.new_page()

Schritt 2: Zu einer YouTube-Seite navigieren und auf das Laden warten

1page.goto("https://www.youtube.com/@mkbhd/videos")
2page.wait_for_selector("a#video-title-link", timeout=15000)
3print("Seite geladen — Video-Elemente sichtbar")

Wenn du Suchergebnisse scrapen willst, verwende stattdessen https://www.youtube.com/results?search_query=deine+suche.

Schritt 3: Infinite Scroll behandeln, um mehr Videos zu laden

YouTube verwendet auf Kanalseiten und Suchergebnissen Infinite Scroll. Hier ist die klassische scrollHeight-Schleife, angepasst aus :

1prev_height = -1
2max_scrolls = 20  # begrenzen — ein Kanal mit 10.000 Videos würde sonst endlos scrollen
3scroll_count = 0
4while scroll_count < max_scrolls:
5    page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
6    page.wait_for_timeout(1500)  # auf neue Inhalte warten
7    new_height = page.evaluate("document.body.scrollHeight")
8    if new_height == prev_height:
9        break  # keine neuen Inhalte geladen
10    prev_height = new_height
11    scroll_count += 1
12print(f"{scroll_count} Mal gescrollt")

Schritt 4: Videodaten aus der gerenderten Seite extrahieren

1video_elements = page.query_selector_all("a#video-title-link")
2videos = []
3for el in video_elements:
4    title = el.inner_text()
5    href = el.get_attribute("href")
6    video_id = href.split("v=")[-1] if href else None
7    videos.append({"title": title, "video_id": video_id, "url": f"https://www.youtube.com{href}"})
8print(f"{len(videos)} Videos extrahiert")

Für Aufrufzahlen und Upload-Daten musst du die benachbarten Elemente auslesen. Der weist darauf hin, dass id="video-title-link" nicht universell ist — YouTube liefert mehrere Seitenvarianten aus. Die robustere Fallback-Option ist a[href*="watch"].

Schritt 5: Export nach CSV oder Google Sheets

1import csv
2with open("youtube_playwright.csv", "w", newline="", encoding="utf-8") as f:
3    writer = csv.DictWriter(f, fieldnames=["title", "video_id", "url"])
4    writer.writeheader()
5    writer.writerows(videos)
6browser.close()
7pw.stop()

Wann du diese Methode nutzen solltest — und wann nicht

Am besten für: Suchergebnisse scrapen, mit dynamischen Seitenelementen interagieren (Tabs klicken, Beschreibungen aufklappen), alles, was ein vollständig gerendertes DOM braucht.

Einschränkungen: Langsam (~1,5–3 Sekunden pro Video in einem Scroll-Extract-Flow). Hohes Anti-Bot-Erkennungsrisiko — normales Selenium setzt navigator.webdriver === true, was . Hoher Ressourcenverbrauch (jede Browser-Instanz braucht 200–500 MB RAM). Für 100 Videos solltest du mit 3–8 Minuten rechnen statt mit Sekunden wie bei yt-dlp.

Methode 3: YouTube mit Python scrapen mit yt-dlp

yt-dlp ist das Schweizer Taschenmesser unter den YouTube-Scraping-Tools. Es ist ein Community-Fork von youtube-dl mit , aktiven Nightly-Releases und integrierter Unterstützung für Metadaten, Kommentare, Transkripte und Batch-Scraping — ganz ohne Browser oder API-Key.

• Schwierigkeit: Anfänger bis Fortgeschritten
• Zeitaufwand: ca. 10 Minuten
• Was du brauchst: Python 3.10+, pip install yt-dlp

Schritt 1: yt-dlp installieren

1pip install yt-dlp

Keine Browser-Driver, keine API-Keys, keine Config-Dateien.

Schritt 2: Videometadaten extrahieren, ohne das Video herunterzuladen

1import yt_dlp
2opts = {
3    "quiet": True,
4    "skip_download": True,      # keine Videodaten — nur Metadaten
5    "no_warnings": True,
6}
7with yt_dlp.YoutubeDL(opts) as ydl:
8    info = ydl.extract_info(
9        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
10        download=False
11    )
12print(f"Titel: {info['title']}")
13print(f"Views: {info['view_count']:,}")
14print(f"Likes: {info.get('like_count', 'N/A')}")
15print(f"Dauer: {info['duration']}s")
16print(f"Upload-Datum: {info['upload_date']}")
17print(f"Kanal: {info['channel']} ({info.get('channel_follower_count', 'N/A')} Abos)")
18print(f"Tags: {info.get('tags', [])[:5]}")

Ein typischer extract_info-Aufruf liefert je nach Videostatus 80–120 Felder zurück: 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 und mehr.

Schritt 3: Kommentare aus einem YouTube-Video extrahieren

1opts = {
2    "quiet": True,
3    "skip_download": True,
4    "getcomments": True,
5    "extractor_args": {
6        "youtube": {
7            "max_comments": ["200", "50", "50", "10"],  # gesamt, Eltern, Antworten pro Kommentar, Antworten gesamt
8            "comment_sort": ["top"],
9        }
10    },
11}
12with yt_dlp.YoutubeDL(opts) as ydl:
13    info = ydl.extract_info(
14        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
15        download=False
16    )
17comments = info.get("comments", [])
18print(f"{len(comments)} Kommentare abgerufen")
19for c in comments[:3]:
20    print(f"  [{c.get('like_count', 0)} Likes] {c['author']}: {c['text'][:80]}...")

Das Extrahieren von Kommentaren ist langsam. berichtet von Kommentarabrufen mit nur etwa 30 KB/s — ein Video mit 100.000 Kommentaren kann Stunden dauern. dokumentiert Videos, bei denen Format-URLs ablaufen (~6 Stunden), bevor das Paginieren der Kommentare abgeschlossen ist. Setze max_comments bei großen Videos aggressiv nach unten.

Schritt 4: Transkripte und Untertitel extrahieren

Weder die YouTube Data API noch BS4-Parsing liefern dir vollständige Transkripte. Genau hier liegt der besondere Vorteil von yt-dlp.

1opts = {
2    "quiet": True,
3    "skip_download": True,
4    "writesubtitles": True,
5    "writeautomaticsub": True,
6    "subtitleslangs": ["en", "en-orig"],
7    "subtitlesformat": "json3",   # maschinenlesbar: Start/Dauer in ms + Text
8    "outtmpl": "%(id)s.%(ext)s",
9}
10with yt_dlp.YoutubeDL(opts) as ydl:
11    info = ydl.extract_info(
12        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
13        download=False
14    )
15# Untertiteldaten direkt aus dem info-Dict abrufen
16auto_captions = info.get("automatic_captions", {})
17manual_subs = info.get("subtitles", {})
18print(f"Sprachen der Auto-Untertitel: {list(auto_captions.keys())[:10]}")
19print(f"Sprachen manueller Untertitel: {list(manual_subs.keys())}")

Das json3-Format ist für maschinelles Parsen ideal — jedes Segment enthält start/dur in Millisekunden plus Text-Runs. Sprachcodes sind BCP-47 (en, en-US, zh-Hans, ja, es).

Schritt 5: Mehrere Videos oder einen ganzen Kanal im Batch scrapen

1opts = {
2    "quiet": True,
3    "skip_download": True,
4    "extract_flat": "in_playlist",  # schnell — nur Video-IDs und Titel
5    "sleep_interval": 2,
6    "max_sleep_interval": 6,
7}
8with yt_dlp.YoutubeDL(opts) as ydl:
9    info = ydl.extract_info(
10        "https://www.youtube.com/@mkbhd/videos",
11        download=False
12    )
13entries = info.get("entries", [])
14print(f"{len(entries)} Videos auf dem Kanal gefunden")
15for e in entries[:5]:
16    print(f"  {e.get('title', 'N/A')} — {e.get('id')}")

Gib eine Kanal-URL, eine Playlist-URL oder sogar eine Suchanfrage (ytsearch10:python scraping) an, und yt-dlp übernimmt die Paginierung intern.

Wann du diese Methode nutzen solltest — und wann nicht

Am besten für: Massenhafte Metadaten-Extraktion, Kommentare, Transkripte, Video-Downloads, kanalweite Scrapes, bei denen du das volle Felderset brauchst.

Einschränkungen: Nicht ideal für Suchergebnisseiten (dafür sind Selenium/Playwright besser). Der Anti-Bot-Wettrüsten-Zyklus von 2024 bis 2026 hat yt-dlp im großen Maßstab komplexer gemacht — YouTube erzwingt inzwischen bei manchen Clients . Für den produktiven Einsatz installiere das Plugin und nutze --cookies-from-browser chrome (am besten mit einem Wegwerf-Account — das yt-dlp-Team warnt, dass Cookies aus einem echten Google-Account zu einer Sperre dieses Kontos führen können).

Methode 4: YouTube mit Python scrapen mit der YouTube Data API

Die offizielle YouTube Data API v3 ist der zuverlässigste und am stärksten strukturierte Weg, YouTube-Daten zu erhalten. Die Antworten sind sauberes JSON, die Felder sind dokumentiert, und das ganze Anti-Bot-Katz-und-Maus-Spiel fällt weg. Aber es gibt einen Haken, den viele Tutorials gern unter den Tisch fallen lassen: das Quota-System.

• Schwierigkeit: Fortgeschritten
• Zeitaufwand: ca. 20 Minuten (inklusive API-Key-Setup)
• Was du brauchst: Python 3.10+, ein Google-Cloud-Projekt, pip install google-api-python-client

Schritt 1: Einen YouTube Data API Key holen

1. Gehe zur
2. Erstelle ein neues Projekt (oder wähle ein bestehendes)
3. Öffne APIs & Services → Library → suche nach „YouTube Data API v3“ → Enable
4. Gehe zu APIs & Services → Credentials → Create Credentials → API Key
5. Kopiere den Schlüssel — du brauchst ihn im Code unten

Schritt 2: Deinen ersten API-Aufruf machen

1from googleapiclient.discovery import build
2API_KEY = "YOUR_API_KEY_HERE"
3youtube = build("youtube", "v3", developerKey=API_KEY)
4# Details für ein bestimmtes Video abrufen
5response = youtube.videos().list(
6    part="snippet,statistics,contentDetails",
7    id="dQw4w9WgXcQ"
8).execute()
9video = response["items"][0]
10print(f"Titel: {video['snippet']['title']}")
11print(f"Views: {video['statistics']['viewCount']}")
12print(f"Likes: {video['statistics'].get('likeCount', 'hidden')}")
13print(f"Kommentare: {video['statistics'].get('commentCount', 'disabled')}")
14print(f"Dauer: {video['contentDetails']['duration']}")
15print(f"Tags: {video['snippet'].get('tags', [])[:5]}")

Die Antwort ist sauber, typisiert und dokumentiert. Keine JSON-Archäologie nötig.

Schritt 3: Videodetails, Kanalinfos und Kommentare extrahieren

1# Videos suchen
2search_response = youtube.search().list(
3    part="snippet",
4    q="python web scraping tutorial",
5    type="video",
6    maxResults=10,
7    order="viewCount"
8).execute()
9for item in search_response["items"]:
10    print(f"  {item['snippet']['title']} — {item['id']['videoId']}")
11# Kommentare abrufen
12comments_response = youtube.commentThreads().list(
13    part="snippet",
14    videoId="dQw4w9WgXcQ",
15    maxResults=20,
16    order="relevance"
17).execute()
18for item in comments_response["items"]:
19    comment = item["snippet"]["topLevelComment"]["snippet"]
20    print(f"  [{comment['likeCount']} Likes] {comment['authorDisplayName']}: {comment['textDisplay'][:80]}")

Die harte Realität der YouTube-API-Quota (was dir niemand erzählt)

Das ist der Teil, der einen brauchbaren Leitfaden von einem Copy-Paste-Tutorial unterscheidet. Das Standardkontingent beträgt , zurückgesetzt um Mitternacht Pacific Time. So viel kosten die einzelnen Aufrufe:

Jetzt die Rechnung. Angenommen, du möchtest 1.000 Suchergebnisse scrapen:

• Suchaufrufe: 1.000 Ergebnisse ÷ 50 pro Seite = 20 Aufrufe × 100 Einheiten = 2.000 Einheiten (20 % deines Tagesbudgets — weg)
• Videodetails für diese 1.000 Videos: 1.000 IDs ÷ 50 pro Batch = 20 Aufrufe × 1 Einheit = 20 Einheiten (günstig — gebündeltes videos.list rettet die Situation)
• Kommentare für diese 1.000 Videos (angenommen 1 Seite pro Video): 1.000 Aufrufe × 1 Einheit = 1.000 Einheiten

In Summe also rund 3.020 Einheiten für einen eher kleinen Scrape. Wenn diese Videos aber tiefe Kommentar-Threads haben (50+ Seiten pro Video), ist dein Restbudget von 7.000 Einheiten schnell verbraucht. Ein Video mit 50.000 Kommentaren = ungefähr 500 Seiten = 500 Einheiten. Wenn du 20 solcher Videos scrapen willst, ist dein Tag vorbei.

Der verlangt eine vollständige Compliance-Prüfung: URL zur Datenschutzerklärung, URL zu den AGB, ein Video-Walkthrough der App, eine nachvollziehbare Quota-Begründung. Aus der Community hört man meist von einer Google-Antwort in 3–5 Werktagen, eine vollständige Freigabe kann aber Wochen bis Monate dauern, und viele Anträge werden abgelehnt — vor allem bei „Ich will mehr Daten für Analysen“-Use-Cases.

Wann du die API nutzen solltest: Für kleine bis mittlere Datenmengen, wenn du strukturierte und verlässliche Daten brauchst, wenn Kommentare und Kanalstatistiken wichtig sind und wenn du das Quota-Limit akzeptieren kannst.

Wann Scraping sinnvoller ist: Bei großen Projekten (>10.000 Videos/Tag), bei Feldern, die die API nicht anbietet (vollständige Transkripte — captions.download benötigt OAuth plus Berechtigung des Video-Eigentümers), oder wenn du mehr als 500 Suchergebnisse pro Query brauchst (hartes API-Limit, unabhängig von der totalResults-Angabe).

Der No-Code-Shortcut: YouTube mit Thunderbit scrapen (kein Python nötig)

Wenn du Python für eine Datenpipeline brauchst, nutze die Methoden 1–4 oben. Wenn du YouTube-Daten aber in 2 Minuten brauchst — vielleicht als Marketer für Konkurrenzanalysen oder als Entwickler für einen schnellen Datenexport ohne Projekt-Setup — gibt es einen schnelleren Weg.

ist eine AI-Web-Scraper-Chrome-Erweiterung, die wir genau für Fälle gebaut haben, in denen Code Overkill wäre. Sie funktioniert direkt auf YouTube-Seiten in deinem Browser.

YouTube mit Thunderbit in 3 Schritten scrapen

Schritt 1: Installiere die und öffne eine YouTube-Kanalseite, eine Suchergebnisseite oder eine Videoseite.

Schritt 2: Klicke in der Thunderbit-Seitenleiste auf „AI Suggest Fields“. Die KI liest die Seite aus und schlägt Spalten vor wie Videotitel, Views, Upload-Datum, Dauer, Kanalname und Thumbnail-URL. Du kannst Spalten nach Bedarf hinzufügen, entfernen oder umbenennen.

Schritt 3: Klicke auf „Scrape“ und exportiere die Daten nach Google Sheets, Excel, CSV, Airtable oder Notion. Die Daten landen in einer sauberen Tabelle und sind sofort einsatzbereit.

Für wen das gedacht ist

• Marketer, die Konkurrenzdaten von Kanälen brauchen, aber nicht programmieren
• Entwickler, die schnell Daten ziehen wollen, ohne virtuelle Umgebungen und Abhängigkeiten einzurichten
• Alle, die an Anti-Bot-Wände stoßen — Thunderbit scrapt in deiner eigenen eingeloggten Browser-Session und übernimmt damit Cookies und PO-Tokens. So umgehst du viele der Blockaden, die serverseitige Scraper ausbremsen
• Thunderbit kann außerdem nutzen, um jede Videoseite zu besuchen und die Tabelle mit zusätzlichen Details anzureichern (Like-Zahl, Beschreibung, Tags)

Für einen tieferen Einblick, wie Thunderbit speziell mit YouTube umgeht, schau dir das und den an.

Tipps, um YouTube mit Python zu scrapen, ohne geblockt zu werden

Diese Tipps gelten für alle vier Python-Methoden. YouTubes Anti-Bot-Maßnahmen werden von , mit drei Hauptsignalen: IP-Verhaltensanalyse, JS-Ausführungsanforderungen und häufig wechselnde HTML-Strukturen.

Für alle Methoden:

• Wechsle User-Agent-Strings und den gesamten Header-Satz — Accept, Accept-Language und Sec-CH-UA-Client-Hints müssen zum angegebenen UA passen. Der enthält eine aktuelle Liste.
• Baue zufällige Pausen von 2–8 Sekunden zwischen Requests ein. Feste Intervalle sind ein Erkennungssignal.
• Nutze Residential Proxies für alles, was über ein paar Seiten hinausgeht. Datacenter-IPs (AWS, GCP, Hetzner) sind .
• Rotiere Session und IP gemeinsam — YouTube verknüpft Sessions mit IPs, und derselbe Session-Cookie auf zwei IPs ist ein Warnsignal.

Für requests + BS4: Setze den Cookie CONSENT=YES+cb. Ohne ihn werden EU-Requests auf eine Consent-Seite umgeleitet, auf der keine Daten stehen.

Für Selenium/Playwright: Nutze auf Linux-Servern lieber einen sichtbaren Browser mit xvfb statt --headless=new — Headless Chrome verrät immer noch genug Fingerprint-Signale für ausgefeilte Detektoren. Ziehe in Betracht; es wendet rund 17 Umgehungen an.

Für yt-dlp: Nutze die Optionen sleep_interval und max_sleep_interval. Installiere das -Plugin zur PO-Token-Erzeugung. Verwende --cookies-from-browser chrome mit einem Wegwerf-Account.

Für die API: Überwache den Quota-Verbrauch in der und bündele Anfragen effizient. Ein einzelner videos.list-Aufruf mit 50 kommaseparierten IDs kostet 1 Einheit — nutze das aus.

Für Thunderbit: Anti-Bot-Maßnahmen werden automatisch abgefangen, weil das Scraping in deiner eigenen Browser-Session läuft. Du automatisierst im Grunde das, was du sonst manuell tun würdest.

Ist es legal, YouTube mit Python zu scrapen?

Das hängt davon ab, was du scrapest, wie du es scrapest und was du mit den Daten machst.

Die rechtliche Lage hat sich 2024 mit Meta Platforms v. Bright Data (N.D. Cal., Januar 2024) verändert, als . Das Scrapen öffentlich zugänglicher Daten wurde nach diesem Urteil „deutlich weniger riskant“. Andererseits endete hiQ v. LinkedIn mit einem wegen AGB-Verstößen, CFAA-Verstößen (Fake-Accounts) und „trespass to chattels“ — plus einer dauerhaften Unterlassungsverfügung.

YouTubes eigene sind eindeutig: „You are not allowed to access the Service using any automated means (such as robots, botnets or scrapers)" — außer mit vorheriger schriftlicher Genehmigung oder soweit das anwendbare Recht es erlaubt. Die YouTube Data API ist der offiziell vorgesehene Weg, auf Daten zuzugreifen.

Ein paar praktische Grundregeln:

• Das Scrapen öffentlich sichtbarer Daten für persönliche Forschung oder nicht-kommerzielle Analysen ist in der Regel mit geringerem Risiko verbunden
• Die API ist der sicherste Weg — sie ist ausdrücklich autorisiert
• Vermeide das Scrapen privater oder nur nach Login zugänglicher Inhalte, das Herunterladen urheberrechtlich geschützter Videos zur Weiterverbreitung oder Verstöße gegen die DSGVO durch personenbezogene Daten aus Kommentaren
• YouTube-Kommentare enthalten personenbezogene Daten im Sinne von DSGVO Art. 4 Abs. 1 — mit Daten von EU-Betroffenen solltest du sorgfältig umgehen
• Ziehe für kommerzielle Scraping-Projekte juristischen Rat hinzu

Das ist keine Rechtsberatung. Die Lage verändert sich schnell — eine neue Welle von , die YouTube für Trainingsdaten gescrapt haben, verändert die Landschaft 2025–2026 bereits deutlich.

Welche Methode solltest du zum Scrapen von YouTube mit Python verwenden?

Die Entscheidungshilfe:

• Schnelle Metadaten von wenigen Seiten nötig? → Methode 1 (requests + BS4). Schnell, leichtgewichtig, keine Abhängigkeiten außer requests und beautifulsoup4.
• Suchergebnisse scrapen oder dynamische Seiten bedienen? → Methode 2 (Selenium/Playwright). Vollständiges Browser-Rendering, Infinite-Scroll-Support, aber langsam und anfällig für Erkennung.
• Massenhaft Metadaten, Kommentare oder Transkripte nötig? → Methode 3 (yt-dlp). Das leistungsstärkste Einzeltool — nicht ohne Grund.
• Strukturierte, verlässliche Daten im mittleren Umfang nötig? → Methode 4 (YouTube Data API). Offiziell, sauber, aber auf begrenzt.
• Daten in 2 Minuten ohne Code? → . Browserbasiert, KI-gestützt, Export nach Google Sheets mit wenigen Klicks.

Keine einzelne Methode deckt jeden Anwendungsfall ab. Setz dir am besten die Vergleichstabelle und die Referenz zu den extrahierbaren Feldern oben als Lesezeichen — sie sparen dir beim nächsten Projekt Zeit. Und wenn du mehr erkunden willst, findest du im Thunderbit-Blog viele weitere Anleitungen, von bis hin zu .

FAQs

Kann ich YouTube ohne API-Key scrapen?

Ja. Die Methoden 1 (requests + BS4), 2 (Selenium/Playwright) und 3 (yt-dlp) brauchen keinen API-Key. Nur Methode 4 (YouTube Data API) benötigt einen. Thunderbit funktioniert ebenfalls ohne API-Key — es scrapt direkt in deinem Browser.

Was ist der schnellste Weg, YouTube mit Python zu scrapen?

Für Python sind yt-dlp und requests + BS4 am schnellsten — beide umgehen den Browser-Overhead und können Metadaten in wenigen Sekunden pro Video ziehen. yt-dlp ist besonders schnell bei Batch-Operationen, weil es die Paginierung intern übernimmt. Für Nicht-Python-Nutzer ist Thunderbit insgesamt am schnellsten, weil es keine Einrichtungszeit gibt.

Wie scrape ich YouTube-Kommentare mit Python?

yt-dlp hat eine integrierte Kommentar-Extraktion über die Option getcomments — das ist der einfachste Weg. Die YouTube Data API unterstützt Kommentare ebenfalls über commentThreads.list (1 Quota-Einheit pro Aufruf, bis zu 100 Kommentare pro Seite). Selenium/Playwright kann das technisch auch, indem man scrollt und gerenderte Kommentar-Elemente ausliest, aber das ist langsam und fragil.

Kann ich YouTube Shorts mit Python scrapen?

Ja. yt-dlp kommt mit Shorts-Metadaten gut zurecht — es behandelt sie wie normale Videos mit zusätzlichen Shorts-spezifischen Feldern. Die YouTube Data API unterstützt Shorts nur teilweise (die Zählung der Shorts-Views wurde — Views zählen nun jeden Wiedergabestart bzw. jede Wiederholung). BS4 und Selenium/Playwright haben bei Shorts nur eingeschränkte Unterstützung, da die Shorts-Bereiche andere DOM-Strukturen verwenden.

Wie viele YouTube-Videos kann ich pro Tag scrapen?

Mit der YouTube Data API bist du auf etwa 10.000 Quota-Einheiten pro Tag begrenzt. Mit gebündelten videos.list-Aufrufen (50 IDs pro Call für 1 Einheit) sind theoretisch bis zu 500.000 Video-Metadaten-Abfragen pro Tag möglich — aber search.list mit 100 Einheiten pro Call verbraucht das Budget sehr schnell. Bei Scraping-Methoden (BS4, Selenium, yt-dlp) ist die Grenze eher praktisch als fest vorgegeben: IP-Blocks treten je nach Proxy-Setup und Request-Muster meist nach einigen hundert bis einigen tausend Requests pro IP und Tag auf. Thunderbit verwendet ein credit-basiertes System, das an deinen gekoppelt ist.

Mehr erfahren