YouTube scrapen met Python: 4 methoden die echt werken

Als je ooit requests.get("https://www.youtube.com/...") hebt geprobeerd en daarna met BeautifulSoup de boel hebt geparsed op zoek naar videotitels, dan ken je de grap al: je kreeg een bak lege <div>-tags terug en precies nul bruikbare data.

Dat is precies de frustratie die ik ontwikkelaars het vaakst zie voelen wanneer ze voor het eerst YouTube proberen te scrapen. YouTube is een single-page application: bijna alles wordt aan de clientkant gerenderd met JavaScript. De HTML die je Python-script terugkrijgt, is dus vooral een hulsschaal. De echte videotitels, weergaven en metadata? Die zitten verstopt in een groot JSON-blok met de naam ytInitialData, dat pas door JS wordt toegevoegd nadat de pagina geladen is.

Dus die ogenschijnlijk logische soup.find("div", class_="ytd-video-renderer") geeft None terug, omdat dat element in de ruwe HTTP-response letterlijk niet bestaat. Toen ik dat eenmaal doorhad, vielen alle puzzelstukjes op hun plek — en de vier methoden hieronder zijn het resultaat van flink wat testen, dingen kapot maken en veel te veel GitHub-issues doorspitten. Ik neem je mee door elke aanpak, laat precies zien wanneer je welke gebruikt, en sluit af met een no-code shortcut voor iedereen die gewoon de data wil zonder eerst een project op te tuigen.

Waarom zou je YouTube überhaupt scrapen met Python?

YouTube is niet alleen een videoplatform — het is ook een . Met en , zit er een enorme berg publiek zichtbare informatie waar bedrijven, onderzoekers en makers programmatically mee aan de slag willen.

Het addertje onder het gras: de ingebouwde analytics van YouTube tonen alleen data van je eigen kanaal. Wil je snappen hoe vaak een concurrent uploadt, trending onderwerpen binnen jouw niche volgen, of reacties op andermans video's analyseren, dan moet je scrapen.

Dit zijn de meest voorkomende praktijkcases die ik zie:

Een concurrentieanalyse van DJI vs. GoPro vs. Insta360 liet bijvoorbeeld zien dat — precies het soort inzicht dat je in YouTube Studio nooit ziet.

Waarom requests + BeautifulSoup alleen YouTube niet scrapen

Voordat we naar de werkende methoden gaan, moet je snappen waarom de voor de hand liggende aanpak faalt. Dat is niet alleen theorie — het scheelt je uren debuggen.

De “logische” aanpak ziet er conceptueel ongeveer zo uit:

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 — elke keer weer

Het resultaat is altijd nul. Zoals zegt: “The page was loaded dynamically, which is not supported by the requests lib.” is nog directer: “Using requests and BeautifulSoup alone you cannot execute JavaScript.”

legt het mechanisme uit: YouTube is gebouwd als een Single Page Application (SPA). Als je simpele HTTP-requests gebruikt, krijg je alleen de eerste HTML-shell terug — de echte content is dan nog niet gerenderd. De videodata zit verstopt in JavaScript-objecten die een browser normaal gesproken uitvoert en in de DOM injecteert.

Het goede nieuws: YouTube stopt wél alle data die je nodig hebt in de ruwe HTML. Alleen niet in DOM-elementen, maar in twee JSON-blokken in <script>-tags:

• ytInitialData — paginastructuur, videolijsten, engagementmetrics, continuation tokens voor reacties
• ytInitialPlayerResponse — kernmetadata van de video (titel, beschrijving, duur, formaten, ondertiteling)

Beide zijn met één requests.get() op te halen — zonder browser — zodra je weet hoe je ze moet uitlezen en parsen. Dat is hieronder Methode 1.

4 manieren om YouTube te scrapen met Python: een vergelijking naast elkaar

Voordat we in elke methode duiken, eerst de beslismatrix. Ik heb alle vier de aanpakken getest en vergeleken op de criteria die echt tellen als je een tool kiest voor een concreet project.

Korte samenvatting:

Welke YouTube-data kun je eigenlijk extraheren — en met welke methode?

Dit is de referentietabel die ik graag had gehad toen ik begon. Geen enkele methode dekt alle velden af — en precies daarom behandelt dit artikel er vier.

Kies je methode op basis van welke rijen voor jouw project het belangrijkst zijn. Heb je reacties en transcripties nodig, dan is yt-dlp duidelijk de winnaar. Heb je gestructureerde statistieken op middelgrote schaal nodig, dan is de API je beste optie. Wil je binnen twee minuten data, lees dan vooral verder naar het Thunderbit-gedeelte.

Methode 1: YouTube scrapen met Python via requests + BeautifulSoup (ytInitialData-parsing)

Deze methode maakt gebruik van het feit dat YouTube alle paginadata als JSON in de ruwe HTML stopt. Je hebt geen browser nodig — je moet alleen weten waar je moet kijken.

• Moeilijkheidsgraad: Beginner
• Benodigde tijd: ~15 minuten
• Wat je nodig hebt: Python 3.10+, requests, beautifulsoup4

Stap 1: Stuur een GET-request naar de YouTube-pagina

Stuur een request met een realistische User-Agent-header. De standaard python-requests/2.x-header wordt direct geblokkeerd — bevestigt dat dit de klassieke valkuil is voor beginners.

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",  # omzeilt de EU-consentlaag
8}
9url = "https://www.youtube.com/@mkbhd/videos"
10response = requests.get(url, headers=HEADERS)
11print(response.status_code)  # zou 200 moeten zijn

De CONSENT-cookie is cruciaal — zonder die cookie worden requests uit de EU-regio doorgestuurd naar consent.youtube.com, waar HTML wordt teruggegeven zonder ytInitialData.

Stap 2: Parse de HTML en vind het ytInitialData-script

Gebruik BeautifulSoup of een regex om de <script>-tag te vinden met var ytInitialData =:

1import re
2import json
3# Extraheer ytInitialData JSON
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 succesvol geëxtraheerd")
12else:
13    print("ytInitialData niet gevonden — controleer je headers/cookies")

Een veelgemaakte fout: een niet-gulzige .*? gebruiken met alleen }; als eindmarkering. Geneste objectafsluitingen komen constant voor in de JSON en zorgen ervoor dat je capture te vroeg stopt. Gebruik };</script> zoals doet — dat is de laatste toewijzing in het scriptblok zelf.

Stap 3: Navigeer door de JSON-structuur om videodata te extraheren

De JSON is diep genest. In plaats van vaste paden hard te coderen die stukgaan zodra YouTube de structuur herschikt (wat regelmatig gebeurt — documenteert meerdere formatwijzigingen sinds 2023), gebruik je beter een recursieve sleutelzoeker:

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# Extraheer video-info van kanaalpagina
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)} video's gevonden")
23for v in videos[:5]:
24    print(f"  {v['title']} — {v['views']}")

Deze recursieve aanpak is waar , yt-dlp en Scrapfly uiteindelijk allemaal op uitkwamen — het overleeft de frequente JSON-herschikkingen van YouTube.

Stap 4: Exporteer de gescrapete data naar CSV of Excel

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("Data geëxporteerd naar youtube_videos.csv")

Wanneer je deze methode wel en niet moet gebruiken

Beste voor: Snel metadata ophalen van een handvol kanaal- of videopagina’s. Lichtgewicht SEO-tools. Eenmalige analyses waarbij je titel, weergaven en uploaddatum nodig hebt.

Beperkingen: De JSON-structuur verandert regelmatig — bekende breuken zijn onder meer de herbouw van de like-knop (2023: toggleButtonRenderer → segmentedLikeDislikeButtonViewModel), de herbouw van de beschrijving (2023: description.runs[] → attributedDescription.content) en het redesign van het Videos-tabblad van kanalen (2022–2023: gridRenderer → richGridRenderer). Datacenter-IP’s worden meestal zacht geblokkeerd na 50–200 requests. Geen reacties, geen transcripties.

Methode 2: YouTube scrapen met Python via Selenium of Playwright

Wanneer je met de pagina moet interacteren — door zoekresultaten scrollen, tabs aanklikken, beschrijvingen uitklappen — dan is browserautomatisering de juiste route.

• Moeilijkheidsgraad: Gemiddeld
• Benodigde tijd: ~30 minuten
• Wat je nodig hebt: Python 3.10+, Playwright (pip install playwright && playwright install) of Selenium + ChromeDriver

Ik raad Playwright aan boven Selenium voor nieuwe projecten. laten zien dat Playwright ongeveer dan Selenium. Playwright gebruikt een persistente WebSocket via Chrome DevTools Protocol, terwijl Selenium via WebDriver over HTTP werkt, wat per opdracht een extra vertaallaag toevoegt.

Stap 1: Playwright instellen

1pip install playwright
2playwright install chromium

1from playwright.sync_api import sync_playwright
2pw = sync_playwright().start()
3browser = pw.chromium.launch(headless=False)  # zichtbaar draaien helpt detectie deels vermijden
4context = browser.new_context()
5# Vooraf ingestelde consent-cookie om de EU-melding te omzeilen
6context.add_cookies([{
7    "name": "SOCS",
8    "value": "CAISNQgDEitib3FfaWRlbnRpdHlmcm9udGVuZHVpc2VydmVyXzIwMjMwODI5LjA3X3AxGgJlbiACGgYIgJnPpwY",
9    "domain": ".youtube.com",
10    "path": "/",
11}])
12page = context.new_page()

Stap 2: Navigeer naar een YouTube-pagina en wacht tot de content laadt

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

Als je zoekresultaten wilt scrapen, gebruik dan in plaats daarvan https://www.youtube.com/results?search_query=je+zoekterm.

Stap 3: Handel infinite scroll af om meer video's te laden

YouTube gebruikt infinite scroll op kanaalpagina’s en zoekresultaten. Hier is de klassieke scrollHeight-lus, aangepast van :

1prev_height = -1
2max_scrolls = 20  # begrens dit — een kanaal met 10K video's blijft anders eindeloos scrollen
3scroll_count = 0
4while scroll_count < max_scrolls:
5    page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
6    page.wait_for_timeout(1500)  # wacht tot nieuwe content geladen is
7    new_height = page.evaluate("document.body.scrollHeight")
8    if new_height == prev_height:
9        break  # geen nieuwe content geladen
10    prev_height = new_height
11    scroll_count += 1
12print(f"{scroll_count} keer gescrolld")

Stap 4: Haal videodata uit de gerenderde pagina

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)} video's geëxtraheerd")

Voor weergaven en uploaddata moet je de naastliggende elementen ophalen. waarschuwt dat id="video-title-link" niet universeel is — YouTube gebruikt meerdere paginavarianten. De robuuste fallback is a[href*="watch"].

Stap 5: Exporteer naar CSV of 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()

Wanneer je deze methode wel en niet moet gebruiken

Beste voor: Zoekresultaten scrapen, interacteren met dynamische pagina-elementen (tabs aanklikken, beschrijvingen uitklappen), alles wat een volledig gerenderde DOM vereist.

Beperkingen: Traag (~1,5–3 seconden per video in een scroll-en-extract flow). Hoog risico op anti-botdetectie — standaard Selenium zet navigator.webdriver === true, wat . Zwaar qua resources (elke browserinstantie gebruikt 200–500 MB RAM). Voor 100 video's ben je al snel 3–8 minuten kwijt in plaats van seconden met yt-dlp.

Methode 3: YouTube scrapen met Python via yt-dlp

yt-dlp is de Zwitserse zakmes-oplossing voor YouTube scraping. Het is een community-fork van youtube-dl met , actieve nightly releases en ingebouwde ondersteuning voor metadata, reacties, transcripties en batch scraping — allemaal zonder browser of API-key.

• Moeilijkheidsgraad: Beginner tot gemiddeld
• Benodigde tijd: ~10 minuten
• Wat je nodig hebt: Python 3.10+, pip install yt-dlp

Stap 1: Installeer yt-dlp

1pip install yt-dlp

Geen browserdrivers, geen API-keys, geen configuratiebestanden.

Stap 2: Extraheer videometadata zonder te downloaden

1import yt_dlp
2opts = {
3    "quiet": True,
4    "skip_download": True,      # geen videobestanden — alleen metadata
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"Weergaven: {info['view_count']:,}")
14print(f"Likes: {info.get('like_count', 'N/A')}")
15print(f"Duur: {info['duration']}s")
16print(f"Uploaddatum: {info['upload_date']}")
17print(f"Kanaal: {info['channel']} ({info.get('channel_follower_count', 'N/A')} abonnees)")
18print(f"Tags: {info.get('tags', [])[:5]}")

Een typische extract_info-call levert 80–120 velden op, afhankelijk van de videostatus: 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 en meer.

Stap 3: Extraheer reacties van een YouTube-video

1opts = {
2    "quiet": True,
3    "skip_download": True,
4    "getcomments": True,
5    "extractor_args": {
6        "youtube": {
7            "max_comments": ["200", "50", "50", "10"],  # totaal, hoofdreacties, replies-per, replies-totaal
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)} reacties opgehaald")
19for c in comments[:3]:
20    print(f"  [{c.get('like_count', 0)} likes] {c['author']}: {c['text'][:80]}...")

Reacties extraheren is traag. meldt comment-ophaling met ongeveer 30 KB/s — een video met 100K reacties kan uren duren. documenteert video's waarbij formaat-URL’s verlopen (~6 uur) voordat de comment-paginatie klaar is. Stel max_comments agressief in voor grote video's.

Stap 4: Transcripties en ondertiteling extraheren

Noch de YouTube Data API, noch BS4-parsing kan je volledige transcripties geven. Dit is het unieke voordeel van yt-dlp.

1opts = {
2    "quiet": True,
3    "skip_download": True,
4    "writesubtitles": True,
5    "writeautomaticsub": True,
6    "subtitleslangs": ["en", "en-orig"],
7    "subtitlesformat": "json3",   # machineleesbaar: start/dur in ms + tekst
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# Subtitle-data direct uit de info-dict ophalen
16auto_captions = info.get("automatic_captions", {})
17manual_subs = info.get("subtitles", {})
18print(f"Talen voor automatische ondertiteling: {list(auto_captions.keys())[:10]}")
19print(f"Talen voor handmatige ondertiteling: {list(manual_subs.keys())}")

Het json3-formaat is het beste voor machine parsing — elk segment heeft start/dur in milliseconden plus tekstfragmenten. Taalcodes zijn BCP-47 (en, en-US, zh-Hans, ja, es).

Stap 5: Scrape meerdere video's of een volledig kanaal in batch

1opts = {
2    "quiet": True,
3    "skip_download": True,
4    "extract_flat": "in_playlist",  # snel — alleen video-ID’s en titels
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)} video's gevonden op het kanaal")
15for e in entries[:5]:
16    print(f"  {e.get('title', 'N/A')} — {e.get('id')}")

Geef een kanaal-URL, playlist-URL of zelfs een zoekopdracht (ytsearch10:python scraping) mee, en yt-dlp regelt de paginatie intern.

Wanneer je deze methode wel en niet moet gebruiken

Beste voor: Bulk-extractie van metadata, reacties, transcripties, video’s downloaden, kanaalbrede scrapes waarbij je het volledige veldenset nodig hebt.

Beperkingen: Niet ideaal voor zoekresultaatpagina’s scrapen (daar is Selenium/Playwright beter voor). De anti-bot-wapenwedloop van 2024–2026 heeft yt-dlp complexer gemaakt om op schaal te draaien — YouTube handhaaft nu op sommige clients . Voor productiegebruik kun je de plugin installeren en --cookies-from-browser chrome gebruiken (met een wegwerpaccount — het yt-dlp-team waarschuwt dat cookies van een echt Google-account dat account kunnen laten bannen).

Methode 4: YouTube scrapen met Python via de YouTube Data API

De officiële YouTube Data API v3 is de meest betrouwbare en gestructureerde manier om YouTube-data op te halen. De responses zijn nette JSON, de velden zijn gedocumenteerd en er is geen anti-bot kat-en-muisspel. Maar er is een addertje onder het gras dat de meeste tutorials overslaan: het quota-systeem.

• Moeilijkheidsgraad: Gemiddeld
• Benodigde tijd: ~20 minuten (inclusief API-key setup)
• Wat je nodig hebt: Python 3.10+, een Google Cloud-project, pip install google-api-python-client

Stap 1: Haal een YouTube Data API-key op

1. Ga naar de
2. Maak een nieuw project aan (of selecteer een bestaand project)
3. Ga naar APIs & Services → Library → zoek naar "YouTube Data API v3" → Enable
4. Ga naar APIs & Services → Credentials → Create Credentials → API Key
5. Kopieer de sleutel — je gebruikt die in de code hieronder

Stap 2: Doe je eerste API-call

1from googleapiclient.discovery import build
2API_KEY = "YOUR_API_KEY_HERE"
3youtube = build("youtube", "v3", developerKey=API_KEY)
4# Haal details op voor een specifieke video
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"Weergaven: {video['statistics']['viewCount']}")
12print(f"Likes: {video['statistics'].get('likeCount', 'verborgen')}")
13print(f"Reacties: {video['statistics'].get('commentCount', 'uitgeschakeld')}")
14print(f"Duur: {video['contentDetails']['duration']}")
15print(f"Tags: {video['snippet'].get('tags', [])[:5]}")

De response is schoon, getypeerd en gedocumenteerd. Geen JSON-archeologie nodig.

Stap 3: Extraheer videodetails, kanaalinformatie en reacties

1# Zoek naar video's
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# Haal reacties op
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]}")

De quota-realiteit van de YouTube API (wat niemand je vertelt)

Dit is het stuk dat een bruikbare gids onderscheidt van een copy-paste tutorial. De standaardtoewijzing is , gereset om middernacht Pacific Time. Dit kost elke call:

Dan de rekensom. Stel dat je 1.000 zoekresultaten wilt scrapen:

• Zoekcalls: 1.000 resultaten ÷ 50 per pagina = 20 calls × 100 units = 2.000 units (20% van je dagbudget — weg)
• Videodetails voor die 1.000 video's: 1.000 ID’s ÷ 50 per batch = 20 calls × 1 unit = 20 units (goedkoop — gebatchte videos.list redt je)
• Reacties voor die 1.000 video's (uitgaand van 1 pagina per video): 1.000 calls × 1 unit = 1.000 units

Totaal: ongeveer 3.020 units voor een bescheiden scrape. Maar als die video's diepe reactiethreads hebben (50+ pagina’s per video), tik je de resterende 7.000 units snel aan. Een video met 50.000 reacties = ongeveer 500 pagina’s = 500 units. Scrape je 20 van zulke video's, dan ben je voor die dag klaar.

Het vereist een volledige compliance-audit: URL van je privacybeleid, URL van je voorwaarden, videorondleiding van de app, onderbouwing van de quota-berekening. Volgens community-ervaring duurt een Google-reactie meestal 3–5 werkdagen, kan volledige goedkeuring weken tot maanden duren, en worden veel aanvragen afgewezen — vooral bij use cases als “ik wil meer data voor analyse”.

Wanneer de API gebruiken: Kleine tot middelgrote schaal, wanneer je gestructureerde/betrouwbare data nodig hebt, wanneer reacties en kanaalstatistieken belangrijk zijn, en wanneer je het quotaplafond kunt accepteren.

Wanneer scrapen logischer is: Grote projecten (>10K video's per dag), velden die de API niet blootlegt (volledige transcripties — captions.download vereist OAuth + toestemming van de video-eigenaar), of wanneer je meer dan 500 zoekresultaten per query nodig hebt (harde API-limiet, ongeacht de totalResults-claim).

De no-code shortcut: YouTube scrapen met Thunderbit (geen Python nodig)

Als je Python nodig hebt voor een datapijplijn, gebruik dan Methode 1–4 hierboven. Maar als je YouTube-data binnen 2 minuten nodig hebt — misschien ben je marketeer en trek je concurrentiestatistieken, of een ontwikkelaar die gewoon snel data wil zonder eerst een projectomgeving op te zetten — dan is er een snellere route.

is een AI-webscraper Chrome-extensie die we speciaal hebben gebouwd voor situaties waarin code schrijven gewoon te veel gedoe is. Het werkt direct op YouTube-pagina’s in je browser.

Zo scrape je YouTube met Thunderbit in 3 stappen

Stap 1: Installeer de en open een YouTube-kanaalpagina, zoekresultatenpagina of videopagina.

Stap 2: Klik op "AI Suggest Fields" in de Thunderbit-zijbalk. De AI leest de pagina en stelt kolommen voor zoals videotitel, weergaven, uploaddatum, duur, kanaalnaam en thumbnail-URL. Je kunt kolommen toevoegen, verwijderen of hernoemen zoals je wilt.

Stap 3: Klik op "Scrape" en exporteer naar Google Sheets, Excel, CSV, Airtable of Notion. De data komt netjes in een tabel, klaar voor gebruik.

Voor wie is dit bedoeld?

• Marketeers die concurrentiekanaaldata nodig hebben maar niet coderen
• Ontwikkelaars die snel data willen ophalen zonder virtual environment op te zetten en dependencies te installeren
• Iedereen die tegen anti-botblokkades aanloopt — Thunderbit scrapt in je eigen ingelogde browsersessie, waardoor je cookies en PO-tokens worden meegenomen. Daarmee omzeil je veel van de blokkades waar server-side scrapers last van hebben
• Thunderbit kan ook gebruiken om elke videopagina te bezoeken en de tabel te verrijken met extra details (zoals aantal likes, beschrijving, tags)

Voor een dieper kijkje in hoe Thunderbit specifiek met YouTube omgaat, bekijk de en het .

Tips om YouTube met Python te scrapen zonder geblokkeerd te worden

Deze tips gelden voor alle vier de Python-methoden. De anti-botmaatregelen van YouTube krijgen van ScrapeOps een , met drie hoofd-signalen: IP-gedragsanalyse, vereisten rond JS-uitvoering en de vaak veranderende HTML-structuur.

Voor alle methoden:

• Roteer User-Agent-strings én de volledige header-set — Accept, Accept-Language, Sec-CH-UA-client hints moeten allemaal overeenkomen met de opgegeven UA. heeft een actuele lijst.
• Voeg willekeurige vertragingen van 2–8 seconden toe tussen requests. Vaste intervallen zijn een detectiesignaal.
• Gebruik residential proxies voor alles wat verder gaat dan een handvol pagina’s. Datacenter-IP’s (AWS, GCP, Hetzner) zijn .
• Roteer sessie en IP samen — YouTube koppelt sessies aan IP, en dezelfde sessiecookie op twee IP’s is een rood vlaggetje.

Voor requests + BS4: Zet de CONSENT=YES+cb-cookie. Zonder die cookie worden EU-requests doorgestuurd naar een consent-pagina zonder data.

Voor Selenium/Playwright: Draai zichtbaar met xvfb op Linux-servers in plaats van --headless=new — headless Chrome lekt nog steeds genoeg fingerprint-signalen voor geavanceerde detectors. Overweeg , dat ongeveer 17 ontwijkingen toepast.

Voor yt-dlp: Gebruik de opties sleep_interval en max_sleep_interval. Installeer de -plugin voor PO-token-generatie. Gebruik --cookies-from-browser chrome met een wegwerpaccount.

Voor de API: Monitor quota-gebruik via de en batch requests efficiënt. Eén videos.list-call met 50 komma-gescheiden ID’s kost 1 unit — gebruik dat.

Voor Thunderbit: Anti-botmaatregelen worden automatisch afgehandeld omdat het scrapen in je browsersessie gebeurt. Je automatiseert in feite gewoon wat je handmatig ook zou doen.

Is het legaal om YouTube te scrapen met Python?

Dat hangt af van wat je scrapt, hoe je het scrapt en wat je met de data doet.

Het juridische landschap veranderde in 2024 met Meta Platforms v. Bright Data (N.D. Cal., januari 2024), waar . Scrapen van publiek toegankelijke data werd daardoor “aanzienlijk minder risicovol”. Aan de andere kant eindigde hiQ v. LinkedIn met een wegens schending van ToS, CFAA-schendingen (valse accounts) en trespass to chattels — plus een permanent verbod.

YouTube’s eigen zijn duidelijk: “You are not allowed to access the Service using any automated means (such as robots, botnets or scrapers)” behalve met voorafgaande schriftelijke toestemming of zoals toegestaan door toepasselijk recht. De YouTube Data API is de officieel goedgekeurde manier om data te gebruiken.

Enkele praktische vuistregels:

• Publiek zichtbare data scrapen voor eigen onderzoek of niet-commerciële analyse is doorgaans lager risico
• De API is de veiligste route — expliciet toegestaan
• Vermijd het scrapen van privé-/login-afgeschermde content, het downloaden van auteursrechtelijk beschermde video's voor herdistributie, of het schenden van de AVG met persoonsgegevens uit reacties
• YouTube-reacties bevatten persoonsgegevens onder AVG art. 4(1) — ga zorgvuldig om met informatie van EU-betrokkenen
• Raadpleeg juridisch advies bij commerciële scrapingprojecten

Dit is geen juridisch advies. Het landschap verandert snel — een nieuwe golf van die YouTube voor trainingsdata scrapen, herschrijft in 2025–2026 opnieuw de spelregels.

Welke methode moet je gebruiken om YouTube met Python te scrapen?

De keuzegids:

• Snel metadata nodig van een paar pagina’s? → Methode 1 (requests + BS4). Snel, lichtgewicht, geen afhankelijkheden behalve requests en beautifulsoup4.
• Zoekresultaten scrapen of dynamische pagina’s bedienen? → Methode 2 (Selenium/Playwright). Volledige browser-rendering, infinite-scroll ondersteuning, maar traag en gevoelig voor detectie.
• Bulk metadata, reacties of transcripties nodig? → Methode 3 (yt-dlp). De meest capabele all-in-one tool — en zijn niet voor niets.
• Gestructureerde, betrouwbare data op middelgrote schaal nodig? → Methode 4 (YouTube Data API). Officieel, netjes, maar beperkt tot .
• Binnen 2 minuten data nodig zonder code te schrijven? → . Browsergebaseerd, AI-gedreven, exporteert met een paar klikken naar Google Sheets.

Geen enkele methode dekt alle use cases. Sla de vergelijkingstabel en de tabel met extraheerbare velden hierboven op — die besparen je tijd bij je volgende project. En als je meer wilt ontdekken, hebben we op de Thunderbit-blog genoeg gidsen, van tot .

Veelgestelde vragen

Kan ik YouTube scrapen zonder API-key?

Ja. Methode 1 (requests + BS4), 2 (Selenium/Playwright) en 3 (yt-dlp) hebben geen API-key nodig. Alleen Methode 4 (YouTube Data API) vereist er een. Thunderbit werkt ook zonder API-key — het scrapt direct in je browser.

Wat is de snelste manier om YouTube met Python te scrapen?

Voor Python zijn yt-dlp en requests + BS4 het snelst — beide vermijden browser-overhead en kunnen metadata in enkele seconden per video ophalen. yt-dlp is vooral snel voor batchtaken omdat het paginatie intern afhandelt. Voor niet-Python-gebruikers is Thunderbit overall het snelst, omdat er geen setup-tijd is.

Hoe scrape ik YouTube-reacties met Python?

yt-dlp heeft ingebouwde comment-extractie via de getcomments-optie — dat is de simpelste route. De YouTube Data API ondersteunt reacties ook via commentThreads.list (1 quota-unit per call, tot 100 reacties per pagina). Selenium/Playwright kan het technisch ook door te scrollen en gerenderde reactie-elementen uit te lezen, maar dat is traag en kwetsbaar.

Kan ik YouTube Shorts scrapen met Python?

Ja. yt-dlp verwerkt Shorts-metadata goed — het behandelt ze als gewone video's met extra Shorts-specifieke velden. De YouTube Data API heeft gedeeltelijke ondersteuning (de manier waarop Shorts-views worden geteld is — views tellen nu elke playback-start/herhaling mee). BS4 en Selenium/Playwright hebben beperkte Shorts-ondersteuning, omdat de Shorts-shelf andere DOM-structuren gebruikt.

Hoeveel YouTube-video’s kan ik per dag scrapen?

Met de YouTube Data API zit je rond de limiet van ~10.000 quota-units per dag. Met gebatchte videos.list-calls (50 ID’s per call voor 1 unit) kun je tot 500.000 videostatistieken per dag opvragen — maar search.list kost 100 units per call en vreet je budget snel op. Bij scraping-methoden (BS4, Selenium, yt-dlp) is de limiet praktisch in plaats van hard gecodeerd: IP-blokkades treden meestal op na een paar honderd tot een paar duizend requests per IP per dag, afhankelijk van je proxy-opzet en requestpatronen. Thunderbit gebruikt een credit-systeem gekoppeld aan je .

Meer lezen