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 2,58 Milliarden monatlich aktiven Nutzern. Mit über 5,1 Milliarden gehosteten Videos und mehr als 500 Stunden hochgeladenem Content pro Minute 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:

Anwendungsfall	Wer braucht das?	Welche Daten?
Wettbewerbsanalyse	Marketing-Teams, Content-Strateg:innen	Aufrufzahlen, Upload-Frequenz, Engagement-Raten
Lead-Generierung	Vertrieb, B2B-Outreach	Kanal-Kontaktdaten, Geschäfts-E-Mails in Beschreibungen
Marktforschung	Produktmanager, Analyst:innen	Trendthemen, Stimmungsbilder aus Kommentaren
Content-Strategie	YouTuber, Agenturen	Erfolgreiche Formate, optimale Titel-/Tag-Muster
SEO / Keyword-Recherche	SEO-Spezialist:innen	Videotitel, Tags, Beschreibungen, Ranking-Signale
Brand Monitoring	PR-Teams, Brand Manager	Erwähnungen in Titeln, Kommentaren, Beschreibungen
Wissenschaftliche Forschung	Forschende, Data Scientists	Kommentardatensätze für Sentimentanalyse (eine Studie aus 2025 erreichte 93,1 % Genauigkeit, nachdem BERT auf 45.000 YouTube-Kommentaren feinjustiert wurde)

Eine Wettbewerbsanalyse zu DJI vs. GoPro vs. Insta360 zeigte zum Beispiel, dass DJIs YouTube-Reichweite mit 390 Millionen Views die der beiden Konkurrenten zusammen übertraf — 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:

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 — jedes Mal

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

Scrapflys YouTube-Analyse für 2026 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.

Kriterium	requests + BS4 (ytInitialData)	Selenium / Playwright	yt-dlp	YouTube Data API	No-Code (Thunderbit)
Einrichtungsaufwand	Gering	Mittel	Gering	Mittel (API-Key)	Keiner
JS-Rendering	Teilweise (JSON-Parsing)	Ja	Ja	N/A (strukturierte API)	Ja
Geschwindigkeit	Schnell	Langsam	Schnell	Schnell	Schnell (Cloud)
Anti-Bot-Risiko	Mittel	Hoch	Gering	Keines	Abgedeckt
Quota / Rate Limits	Keine (aber IP-Blocks)	Keine (aber Erkennung)	Keine	10.000 Einheiten/Tag	Credit-basiert
Kommentar-Extraktion	Schwer	Möglich, aber komplex	Integriert	Integriert	Abhängig von der Seite
Transkripte	Nein	Komplex	Ja	Nein	Nein
Am besten für	Schnelle Metadaten	Suchergebnisse, dynamische Seiten	Bulk-Metadaten + Kommentare	Strukturierte Daten in großem Umfang	Nicht-Programmierer, schnelle Exporte

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.

Datenfeld	BS4 (ytInitialData)	Selenium/Playwright	yt-dlp	YouTube API	Thunderbit
Videotitel	✅	✅	✅	✅	✅
Aufrufzahlen	✅	✅	✅	✅	✅
Like-Zahl	⚠️ Uneinheitlich	✅	✅	✅	✅
Kommentare (Text)	❌	⚠️ Komplex	✅	✅	⚠️
Transkript/Untertitel	❌	⚠️	✅	❌	❌
Tags	✅	✅	✅	✅	⚠️
Thumbnail-URLs	✅	✅	✅	✅	✅
Abonnentenzahl des Kanals	⚠️	✅	✅	✅	✅
Upload-Datum	✅	✅	✅	✅	✅
Videolänge	✅	✅	✅	✅	✅
Shorts-spezifische Daten	❌	⚠️	✅	⚠️	⚠️

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 — der Header-Guide von ScrapeOps bestätigt, dass das für Einsteiger die größte Stolperfalle ist.

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",  # umgeht die EU-Consent-Wall
}

url = "https://www.youtube.com/@mkbhd/videos"
response = requests.get(url, headers=HEADERS)
print(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:

import re
import json

# ytInitialData-JSON extrahieren
match = re.search(
    r"var ytInitialData\s*=\s*({.*?});</script>",
    response.text,
    re.DOTALL
)
if match:
    data = json.loads(match.group(1))
    print("ytInitialData erfolgreich extrahiert")
else:
    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 Scrapflys Scraper von 2026 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 Issue-Tracker von yt-dlp dokumentiert mehrere Formatänderungen seit 2023), solltest du lieber eine rekursive Schlüsselsuche verwenden:

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)

# Videoinfos von der Kanalseite extrahieren
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)} Videos gefunden")
for v in videos[:5]:
    print(f"  {v['title']} — {v['views']}")

Dieser rekursive Ansatz ist genau der, auf den scrapetube, 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

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("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. Benchmarks von TestDino aus 2026 zeigen Playwright mit rund 1,85× höherer Geschwindigkeit pro Aktion, etwa 2,1× geringerem Speicherbedarf und rund 4× mehr Parallelkapazität 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

pip install playwright
playwright install chromium

from playwright.sync_api import sync_playwright

pw = sync_playwright().start()
browser = pw.chromium.launch(headless=False)  # sichtbarer Modus vermeidet manche Erkennungen
context = browser.new_context()

# Consent-Cookie vorab setzen, um die EU-Wall zu umgehen
context.add_cookies([{
    "name": "SOCS",
    "value": "CAISNQgDEitib3FfaWRlbnRpdHlmcm9udGVuZHVpc2VydmVyXzIwMjMwODI5LjA3X3AxGgJlbiACGgYIgJnPpwY",
    "domain": ".youtube.com",
    "path": "/",
}])

page = context.new_page()

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

page.goto("https://www.youtube.com/@mkbhd/videos")
page.wait_for_selector("a#video-title-link", timeout=15000)
print("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 Scrapflys Scroll-Guide:

prev_height = -1
max_scrolls = 20  # begrenzen — ein Kanal mit 10.000 Videos würde sonst endlos scrollen
scroll_count = 0

while scroll_count < max_scrolls:
    page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
    page.wait_for_timeout(1500)  # auf neue Inhalte warten
    new_height = page.evaluate("document.body.scrollHeight")
    if new_height == prev_height:
        break  # keine neuen Inhalte geladen
    prev_height = new_height
    scroll_count += 1

print(f"{scroll_count} Mal gescrollt")

Schritt 4: Videodaten aus der gerenderten Seite extrahieren

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)} Videos extrahiert")

Für Aufrufzahlen und Upload-Daten musst du die benachbarten Elemente auslesen. Der Crawlee-Guide von 2025 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

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

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 jede clientseitige Erkennung sofort sieht. 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 über 157.000 GitHub-Stars, 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

pip install yt-dlp

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

Schritt 2: Videometadaten extrahieren, ohne das Video herunterzuladen

import yt_dlp

opts = {
    "quiet": True,
    "skip_download": True,      # keine Videodaten — nur Metadaten
    "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"Titel: {info['title']}")
print(f"Views: {info['view_count']:,}")
print(f"Likes: {info.get('like_count', 'N/A')}")
print(f"Dauer: {info['duration']}s")
print(f"Upload-Datum: {info['upload_date']}")
print(f"Kanal: {info['channel']} ({info.get('channel_follower_count', 'N/A')} Abos)")
print(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

opts = {
    "quiet": True,
    "skip_download": True,
    "getcomments": True,
    "extractor_args": {
        "youtube": {
            "max_comments": ["200", "50", "50", "10"],  # gesamt, Eltern, Antworten pro Kommentar, Antworten gesamt
            "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)} Kommentare abgerufen")
for c in comments[:3]:
    print(f"  [{c.get('like_count', 0)} Likes] {c['author']}: {c['text'][:80]}...")

Das Extrahieren von Kommentaren ist langsam. yt-dlp Issue #3532 berichtet von Kommentarabrufen mit nur etwa 30 KB/s — ein Video mit 100.000 Kommentaren kann Stunden dauern. Issue #11849 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.

opts = {
    "quiet": True,
    "skip_download": True,
    "writesubtitles": True,
    "writeautomaticsub": True,
    "subtitleslangs": ["en", "en-orig"],
    "subtitlesformat": "json3",   # maschinenlesbar: Start/Dauer in ms + Text
    "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
    )

# Untertiteldaten direkt aus dem info-Dict abrufen
auto_captions = info.get("automatic_captions", {})
manual_subs = info.get("subtitles", {})
print(f"Sprachen der Auto-Untertitel: {list(auto_captions.keys())[:10]}")
print(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

opts = {
    "quiet": True,
    "skip_download": True,
    "extract_flat": "in_playlist",  # schnell — nur Video-IDs und Titel
    "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)} Videos auf dem Kanal gefunden")
for e in entries[:5]:
    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 BotGuard-Attestation und PO-Tokens. Für den produktiven Einsatz installiere das Plugin bgutil-ytdlp-pot-provider 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 Google Cloud Console
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

from googleapiclient.discovery import build

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

# Details für ein bestimmtes Video abrufen
response = youtube.videos().list(
    part="snippet,statistics,contentDetails",
    id="dQw4w9WgXcQ"
).execute()

video = response["items"][0]
print(f"Titel: {video['snippet']['title']}")
print(f"Views: {video['statistics']['viewCount']}")
print(f"Likes: {video['statistics'].get('likeCount', 'hidden')}")
print(f"Kommentare: {video['statistics'].get('commentCount', 'disabled')}")
print(f"Dauer: {video['contentDetails']['duration']}")
print(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

# Videos suchen
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']}")

# Kommentare abrufen
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']} 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 10.000 Quota-Einheiten pro Tag, zurückgesetzt um Mitternacht Pacific Time. So viel kosten die einzelnen Aufrufe:

API-Endpunkt	Quota-Kosten pro Aufruf	Max. Ergebnisse pro Aufruf
search.list	100 Einheiten	50 Ergebnisse
videos.list	1 Einheit	50 Video-IDs (gebündelt)
channels.list	1 Einheit	50 Kanal-IDs
commentThreads.list	1 Einheit	100 Kommentare
captions.list	50 Einheiten	N/A

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 Prozess für eine Quota-Erhöhung 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.

Thunderbit 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 Thunderbit Chrome-Erweiterung 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.

Thunderbit für YouTube-Scraping testen

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 Subpage-Scraping 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 Thunderbit YouTube Channel Scraper Template und den Thunderbit-YouTube-Kanal 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 ScrapeOps mit 6/10 Schwierigkeit bewertet, 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 ScraperAPI-Guide von 2026 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 für YouTube-Scraping 2025–2026 praktisch tot.
• 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 playwright-stealth in Betracht; es wendet rund 17 Umgehungen an.

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

Für die API: Überwache den Quota-Verbrauch in der Google Cloud Console 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 Richter Chen entschied, dass Metas AGB nur Scraping im eingeloggten Zustand verbieten, nicht aber öffentliches Scraping ohne Login. Das Scrapen öffentlich zugänglicher Daten wurde nach diesem Urteil „deutlich weniger riskant“. Andererseits endete hiQ v. LinkedIn mit einem Urteil über 500.000 US-Dollar gegen hiQ wegen AGB-Verstößen, CFAA-Verstößen (Fake-Accounts) und „trespass to chattels“ — plus einer dauerhaften Unterlassungsverfügung.

YouTubes eigene Nutzungsbedingungen 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 DMCA-§1201-Klagen von Creators gegen KI-Unternehmen, 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 — 157K+ Stars nicht ohne Grund.
• Strukturierte, verlässliche Daten im mittleren Umfang nötig? → Methode 4 (YouTube Data API). Offiziell, sauber, aber auf 10.000 Einheiten/Tag begrenzt.
• Daten in 2 Minuten ohne Code? → Thunderbit. 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 Web-Scraping-Ansätze erkunden willst, findest du im Thunderbit-Blog viele weitere Anleitungen, von Python-Scraping-Tutorials bis hin zu Daten-Scraping nach Google Sheets.

Thunderbit für YouTube-Scraping testen Get Started Free

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 am 30. April 2025 geändert — 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 Plan gekoppelt ist.

Mehr erfahren

• How To Web Scrape With Python
• Playwright Vs Puppeteer
• Best Automated Web Scraping Tools
• Scrapy Python Tutorial
• Scrape Linkedin With Python