Skrap YouTube med Python: 4 metoder som faktisk fungerer

Hvis du noen gang har prøvd requests.get("https://www.youtube.com/...") og deretter analysert resultatet med BeautifulSoup på jakt etter videotitler, kjenner du sannsynligvis allerede utfallet: du får en vegg av tomme <div>-tagger og nøyaktig null nyttige data.

Det er den vanligste frustrasjonen jeg ser blant utviklere som prøver å skrape YouTube for første gang. YouTube er en single-page application — nesten alt rendres på klientsiden via JavaScript. HTML-en Python-scriptet ditt får tilbake er bare et skall. De faktiske videotitlene, visningstallene og metadataene? De ligger gjemt i en massiv JSON-blokk kalt ytInitialData, som injiseres av JS etter at siden er lastet.

Så når den helt rimelige soup.find("div", class_="ytd-video-renderer") returnerer None, er det fordi elementet bokstavelig talt ikke finnes i den rå HTTP-responsen. Da jeg først skjønte dette, falt hele puslespillet på plass — og metodene nedenfor er resultatet av mye testing, mange feil og altfor mange GitHub-issues. Jeg går gjennom hver tilnærming, viser nøyaktig når du bør bruke hvilken, og legger til et no-code-alternativ til slutt for deg som bare vil ha dataene uten oppsettet.

Hvorfor skrape YouTube med Python i utgangspunktet?

YouTube er ikke bare en videoplattform — det er en datakilde med 2,58 milliarder månedlige aktive brukere. Med over 5,1 milliarder videoer og 500+ timer med innhold lastet opp hvert minutt, finnes det enorme mengder offentlig synlig informasjon som bedrifter, forskere og skapere ønsker å analysere programmatisk.

Haken er at YouTubes innebygde analyse bare viser data for din egen kanal. Hvis du vil forstå hvor ofte en konkurrent publiserer, følge trendtemaer i din nisje eller analysere publikumsreaksjoner i kommentarer på andres videoer, må du skrape data.

Her er de vanligste reelle bruksområdene jeg har sett:

Bruksområde	Hvem trenger det	Data som inngår
Konkurrentanalyse	Markedsføringsteam, innholdsstrateger	Visningstall, publiseringsfrekvens, engasjementsrate
Leadgenerering	Salgsteam, B2B outreach	Kanal-kontaktinfo, e-postadresser i beskrivelser
Markedsresearch	Produktledere, analytikere	Trendtemaer, publikumsstemning via kommentarer
Innholdsstrategi	YouTubere, byråer	Formater med høy ytelse, optimale tittel-/tag-mønstre
SEO / søkeordanalyse	SEO-spesialister	Videotitler, tags, beskrivelser, rangeringssignaler
Brandovervåking	PR-team, brand managers	Omtaler i videotitler, kommentarer, beskrivelser
Akademisk forskning	Forskere, data scientists	Kommentardatasett for sentimentanalyse (en studie fra 2025 oppnådde 93,1 % nøyaktighet ved å finjustere BERT på 45 000 YouTube-kommentarer)

En konkurranseanalyse av DJI vs. GoPro vs. Insta360 viste for eksempel at DJIs rekkevidde på YouTube (390 millioner visninger) overgikk begge konkurrentene til sammen — innsikt du aldri ser direkte i YouTube Studio.

Hvorfor requests + BeautifulSoup alene ikke vil skrape YouTube

Før vi går til metodene som faktisk fungerer, må du forstå hvorfor den opplagte tilnærmingen feiler. Dette er ikke akademisk flisespikkeri — det sparer deg for timer med feilsøking.

Den «åpenbare» løsningen ser omtrent slik ut i praksis:

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 — hver gang

Resultatet er alltid null. Som ScrapeOps sin feilsøkingsguide sier: «Siden ble lastet dynamisk, noe requests-biblioteket ikke støtter.» Teclados nybegynnerguide sier det enda tydeligere: «Ved å bruke requests og BeautifulSoup alene kan du ikke kjøre JavaScript.»

Scrapflys YouTube-gjennomgang fra 2026 forklarer mekanismen: YouTube er bygget som en Single Page Application (SPA). Når du bruker vanlige HTTP-forespørsler, får du bare det første HTML-skallet tilbake — det faktiske innholdet er ikke rendret ennå. Videodataene er skjult i JavaScript-objekter som en nettleser normalt ville kjørt og injisert i DOM-en.

Den gode nyheten: YouTube legger faktisk inn alle dataene du trenger i rå HTML. De ligger bare ikke i DOM-elementer — de finnes i to JSON-blokker inne i <script>-tagger:

• ytInitialData — sidens struktur, videolister, engasjementsmålinger, continuation tokens for kommentarer
• ytInitialPlayerResponse — sentrale videometadata (tittel, beskrivelse, varighet, formater, undertekster)

Begge kan hentes med én enkelt requests.get() — ingen nettleser nødvendig — når du vet hvordan du skal trekke dem ut og tolke dem. Det er metode 1 nedenfor.

4 måter å skrape YouTube med Python: en sammenligning side om side

Før vi går inn i hver metode, får du her beslutningsmatrisen. Jeg har testet alle fire tilnærmingene og sammenlignet dem etter kriterier som faktisk betyr noe når du skal velge verktøy til et reelt prosjekt.

Kriterium	requests + BS4 (ytInitialData)	Selenium / Playwright	yt-dlp	YouTube Data API	No-code (Thunderbit)
Oppsettkompleksitet	Lav	Middels	Lav	Middels (API-nøkkel)	Ingen
Håndterer JS-rendering	Delvis (JSON-parsing)	Ja	Ja	N/A (strukturert API)	Ja
Hastighet	Rask	Langsom	Rask	Rask	Rask (sky)
Risiko for botdeteksjon	Middels	Høy	Lav	Ingen	Håndteres
Kvote / rate limits	Ingen (men IP-blokkering)	Ingen (men deteksjon)	Ingen	10 000 enheter/dag	Kreditbasert
Uthenting av kommentarer	Vanskelig	Mulig, men komplisert	Innebygd	Innebygd	Avhenger av siden
Transkripsjoner	Nei	Komplekst	Ja	Nei	Nei
Best for	Rask metadata	Søkeresultater, dynamiske sider	Massemetadata + kommentarer	Strukturert data i stor skala	Ikke-programmerere, raske eksportjobber

Kort oppsummert:

Hvilke YouTube-data kan du faktisk hente ut — og med hvilken metode?

Dette er referansetabellen jeg skulle ønske fantes da jeg startet. Ingen enkelt metode dekker alle feltene — og det er nettopp derfor denne artikkelen tar for seg fire.

Datafelt	BS4 (ytInitialData)	Selenium/Playwright	yt-dlp	YouTube API	Thunderbit
Videotittel	✅	✅	✅	✅	✅
Visningstall	✅	✅	✅	✅	✅
Antall likerklikk	⚠️ Ustabilt	✅	✅	✅	✅
Kommentarer (tekst)	❌	⚠️ Komplekst	✅	✅	⚠️
Transkripsjon/undertekster	❌	⚠️	✅	❌	❌
Tags	✅	✅	✅	✅	⚠️
Thumbnail-URL-er	✅	✅	✅	✅	✅
Antall kanalabonnenter	⚠️	✅	✅	✅	✅
Opplastingsdato	✅	✅	✅	✅	✅
Videovarighet	✅	✅	✅	✅	✅
Shorts-spesifikke data	❌	⚠️	✅	⚠️	⚠️

Velg metode ut fra hvilke rader som betyr mest for prosjektet ditt. Hvis du trenger kommentarer og transkripsjoner, er yt-dlp den klare vinneren. Hvis du trenger strukturert statistikk i moderat skala, er API-et best. Hvis du trenger data på to minutter, fortsett til Thunderbit-delen.

Metode 1: Skrap YouTube med Python ved hjelp av requests + BeautifulSoup (ytInitialData-parsing)

Denne metoden utnytter at YouTube legger inn alle sidedata som JSON i rå HTML. Du trenger ikke en nettleser — du må bare vite hvor du skal lete.

• Vanskelighetsgrad: Nybegynner
• Tidsbruk: Ca. 15 minutter
• Dette trenger du: Python 3.10+, requests, beautifulsoup4

Steg 1: Send en GET-forespørsel til YouTube-siden

Send en forespørsel med en realistisk User-Agent-header. Standardheaderen python-requests/2.x blir ofte blokkert umiddelbart — ScrapeOps sin header-guide bekrefter at dette er den største fellen for nybegynnere.

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",  # omgår samtykkesiden i EU
}

url = "https://www.youtube.com/@mkbhd/videos"
response = requests.get(url, headers=HEADERS)
print(response.status_code)  # Bør være 200

CONSENT-cookien er kritisk — uten den vil forespørsler fra EU-regionen videresendes til consent.youtube.com, som serverer HTML uten ytInitialData i det hele tatt.

Steg 2: Parse HTML-en og finn ytInitialData-scriptet

Bruk BeautifulSoup eller regex for å finne <script>-taggen som inneholder var ytInitialData =:

import re
import json

# Hent ut ytInitialData-JSON
match = re.search(
    r"var ytInitialData\s*=\s*({.*?});</script>",
    response.text,
    re.DOTALL
)
if match:
    data = json.loads(match.group(1))
    print("ytInitialData ble hentet ut vellykket")
else:
    print("Fant ikke ytInitialData — sjekk headers/cookies")

En vanlig feil er å bruke en non-greedy .*? med bare }; som sluttsignal. Nestede objektavslutninger dukker opp hele tiden i JSON-en og vil kutte utlesningen for tidlig. Bruk };</script> slik Scrapflys scraper fra 2026 gjør — det er den siste tildelingen i sin egen script-blokk.

Steg 3: Naviger JSON-strukturen for å hente ut videodata

JSON-en er dypt nestet. I stedet for å hardkode stier som ryker hver gang YouTube flytter på strukturen sin (noe som skjer regelmessig — yt-dlp sitt issue-spor dokumenterer flere formatendringer siden 2023), bruk et rekursivt søk etter nøkkel:

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)

# Hent videoinfo fra kanalsiden
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"Fant {len(videos)} videoer")
for v in videos[:5]:
    print(f"  {v['title']} — {v['views']}")

Denne rekursive tilnærmingen er det scrapetube, yt-dlp og Scrapfly alle har endt opp med — den tåler YouTubes hyppige omstrukturering av JSON.

Steg 4: Eksporter de skrapte dataene til CSV eller Excel

import csv

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

print("Data eksportert til youtube_videos.csv")

Når bør du bruke denne metoden — og når bør du la være?

Best for: Rask uthenting av metadata fra noen få kanal- eller videosider. Lettvekts SEO-verktøy. Engangsanalyser der du trenger tittel, visninger og opplastingsdato.

Begrensninger: JSON-strukturen endres — dokumenterte brudd inkluderer refaktoriseringen av likerknappen (2023: toggleButtonRenderer → segmentedLikeDislikeButtonViewModel), refaktoriseringen av beskrivelsen (2023: description.runs[] → attributedDescription.content) og redesignet av kanalens Videos-fane (2022–2023: gridRenderer → richGridRenderer). Datacenters-IP-er blir vanligvis soft-blokkert etter 50–200 forespørsler. Ingen kommentarer, ingen transkripsjoner.

Metode 2: Skrap YouTube med Python ved hjelp av Selenium eller Playwright

Når du må samhandle med siden — scrolle gjennom søkeresultater, klikke faner, utvide beskrivelser — er nettleserautomatisering veien å gå.

• Vanskelighetsgrad: Middels
• Tidsbruk: Ca. 30 minutter
• Dette trenger du: Python 3.10+, Playwright (pip install playwright && playwright install) eller Selenium + ChromeDriver

Jeg anbefaler Playwright fremfor Selenium i nye prosjekter. TestDinos benchmark fra 2026 viser at Playwright er omtrent 1,85× raskere per handling, bruker ~2,1× mindre minne og har ~4× høyere parallell kapasitet enn Selenium. Playwright bruker en vedvarende WebSocket via Chrome DevTools Protocol, mens Selenium bruker WebDriver over HTTP og legger til et oversettelseslag per kommando.

Steg 1: Sett opp Playwright

pip install playwright
playwright install chromium

from playwright.sync_api import sync_playwright

pw = sync_playwright().start()
browser = pw.chromium.launch(headless=False)  # med vindu unngår noen deteksjoner
context = browser.new_context()

# Legg inn samtykkecookie for å omgå EU-siden
context.add_cookies([{
    "name": "SOCS",
    "value": "CAISNQgDEitib3FfaWRlbnRpdHlmcm9udGVuZHVpc2VydmVyXzIwMjMwODI5LjA3X3AxGgJlbiACGgYIgJnPpwY",
    "domain": ".youtube.com",
    "path": "/",
}])

page = context.new_page()

Steg 2: Gå til en YouTube-side og vent på at innholdet lastes

page.goto("https://www.youtube.com/@mkbhd/videos")
page.wait_for_selector("a#video-title-link", timeout=15000)
print("Siden er lastet — videoelementer er synlige")

Hvis du skraper søkeresultater, går du til https://www.youtube.com/results?search_query=your+query i stedet.

Steg 3: Håndter uendelig scrolling for å laste inn flere videoer

YouTube bruker uendelig scrolling på kanalsider og søkeresultater. Her er den klassiske scrollHeight-løkka, tilpasset fra Scrapflys scrolle-guide:

prev_height = -1
max_scrolls = 20  # sett en grense — en kanal med 10 000 videoer kan scrolles i det uendelige
scroll_count = 0

while scroll_count < max_scrolls:
    page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
    page.wait_for_timeout(1500)  # vent på at nytt innhold lastes
    new_height = page.evaluate("document.body.scrollHeight")
    if new_height == prev_height:
        break  # ingen nytt innhold lastet
    prev_height = new_height
    scroll_count += 1

print(f"Scrollet {scroll_count} ganger")

Steg 4: Hent ut videodata fra den rendrerte siden

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"Hentet ut {len(videos)} videoer")

For visningstall og opplastingsdatoer må du hente søskenelementer. Crawlees guide fra 2025 advarer om at id="video-title-link" ikke er universell — YouTube sender ut flere sidevarianter. Det robuste reservalternativet er a[href*="watch"].

Steg 5: Eksporter til CSV eller 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()

Når bør du bruke denne metoden — og når bør du la være?

Best for: Skraping av søkeresultater, interaksjon med dynamiske elementer (klikke faner, utvide beskrivelser), alt som krever en fullt rendret DOM.

Begrensninger: Langsom (~1,5–3 sekunder per video i en scroll-og-hent-flyt). Høy risiko for botdeteksjon — vanlig Selenium setter navigator.webdriver === true, som enhver deteksjon på JS-siden fanger opp umiddelbart. Ressurskrevende (hver nettleserinstans bruker 200–500 MB RAM). For 100 videoer kan du forvente 3–8 minutter i stedet for sekunder med yt-dlp.

Metode 3: Skrap YouTube med Python ved hjelp av yt-dlp

yt-dlp er sveitserkniven blant YouTube-skriptingsverktøy. Det er en community-fork av youtube-dl med 157 000+ GitHub-stjerner, aktive nattlige utgivelser og innebygd støtte for metadata, kommentarer, transkripsjoner og batch-skraping — alt uten behov for nettleser eller API-nøkkel.

• Vanskelighetsgrad: Nybegynner til middels
• Tidsbruk: Ca. 10 minutter
• Dette trenger du: Python 3.10+, pip install yt-dlp

Steg 1: Installer yt-dlp

pip install yt-dlp

Ingen nettleserdrivere, ingen API-nøkler, ingen config-filer.

Steg 2: Hent ut videometadata uten å laste ned videoen

import yt_dlp

opts = {
    "quiet": True,
    "skip_download": True,      # ingen videodata — kun metadata
    "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"Tittel: {info['title']}")
print(f"Visninger: {info['view_count']:,}")
print(f"Likerklikk: {info.get('like_count', 'N/A')}")
print(f"Varighet: {info['duration']}s")
print(f"Opplastingsdato: {info['upload_date']}")
print(f"Kanal: {info['channel']} ({info.get('channel_follower_count', 'N/A')} abonnenter)")
print(f"Tags: {info.get('tags', [])[:5]}")

Et typisk extract_info-kall returnerer 80–120 felt, avhengig av 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 og mer.

Steg 3: Hent kommentarer fra en YouTube-video

opts = {
    "quiet": True,
    "skip_download": True,
    "getcomments": True,
    "extractor_args": {
        "youtube": {
            "max_comments": ["200", "50", "50", "10"],  # totalt, hovedkommentarer, svar per kommentar, svar totalt
            "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"Hentet {len(comments)} kommentarer")
for c in comments[:3]:
    print(f"  [{c.get('like_count', 0)} likes] {c['author']}: {c['text'][:80]}...")

Kommentaruthenting er tregt. yt-dlp Issue #3532 rapporterer kommentarhenting på rundt 30 KB/s — en video med 100 000 kommentarer kan ta timer. Issue #11849 dokumenterer videoer der format-URL-er utløper (~6 timer) før kommentarpaginasjonen er ferdig. Sett max_comments aggressivt for store videoer.

Steg 4: Hent transkripsjoner og undertekster

Verken YouTube Data API eller BS4-parsing kan gi deg fullstendige transkripsjoner. Det er yt-dlps unike fordel.

opts = {
    "quiet": True,
    "skip_download": True,
    "writesubtitles": True,
    "writeautomaticsub": True,
    "subtitleslangs": ["en", "en-orig"],
    "subtitlesformat": "json3",   # maskinlesbar: start/dur i ms + tekst
    "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
    )

# Hent undertekstdata direkte fra info-dict
auto_captions = info.get("automatic_captions", {})
manuelle_undertekster = info.get("subtitles", {})
print(f"Språk for auto-undertekster: {list(auto_captions.keys())[:10]}")
print(f"Språk for manuelle undertekster: {list(manuelle_undertekster.keys())}")

json3-formatet er å foretrekke for maskinell parsing — hvert segment har start/dur i millisekunder pluss tekst-runs. Språkkodene følger BCP-47 (en, en-US, zh-Hans, ja, es).

Steg 5: Skrap flere videoer eller en hel kanal i batch

opts = {
    "quiet": True,
    "skip_download": True,
    "extract_flat": "in_playlist",  # raskt — bare video-IDer og titler
    "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"Fant {len(entries)} videoer på kanalen")
for e in entries[:5]:
    print(f"  {e.get('title', 'N/A')} — {e.get('id')}")

Send inn en kanal-URL, en spilleliste-URL eller til og med et søk (ytsearch10:python scraping), så håndterer yt-dlp pagineringen internt.

Når bør du bruke denne metoden — og når bør du la være?

Best for: Masseuthenting av metadata, kommentarer, transkripsjoner, nedlasting av videoer og skraping av hele kanaler der du trenger hele feltsettet.

Begrensninger: Ikke ideelt for skraping av søkeresultatsider (Selenium/Playwright er bedre der). Anti-bot-kappløpet 2024–2026 har gjort yt-dlp mer krevende å kjøre i stor skala — YouTube håndhever nå BotGuard-attestering og PO Tokens på enkelte klienter. For produksjonsbruk bør du installere pluginet bgutil-ytdlp-pot-provider og bruke --cookies-from-browser chrome (med en engangskonto — yt-dlp-teamet advarer om at cookies fra en ekte Google-konto kan føre til at kontoen blir sperret).

Metode 4: Skrap YouTube med Python ved hjelp av YouTube Data API

Det offisielle YouTube Data API v3 er den mest pålitelige og strukturerte måten å hente YouTube-data på. Responsene er ren JSON, feltene er dokumenterte, og du slipper katt-og-mus-leken med botdeteksjon. Men det er en hake som de fleste guider glatter over: kvotesystemet.

• Vanskelighetsgrad: Middels
• Tidsbruk: Ca. 20 minutter (inkludert oppsett av API-nøkkel)
• Dette trenger du: Python 3.10+, et Google Cloud-prosjekt, pip install google-api-python-client

Steg 1: Skaff en YouTube Data API-nøkkel

1. Gå til Google Cloud Console
2. Opprett et nytt prosjekt (eller velg et eksisterende)
3. Gå til APIs & Services → Library → søk etter "YouTube Data API v3" → Enable
4. Gå til APIs & Services → Credentials → Create Credentials → API Key
5. Kopier nøkkelen — du bruker den i koden nedenfor

Steg 2: Gjør ditt første API-kall

from googleapiclient.discovery import build

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

# Hent detaljer for en bestemt video
response = youtube.videos().list(
    part="snippet,statistics,contentDetails",
    id="dQw4w9WgXcQ"
).execute()

video = response["items"][0]
print(f"Tittel: {video['snippet']['title']}")
print(f"Visninger: {video['statistics']['viewCount']}")
print(f"Likerklikk: {video['statistics'].get('likeCount', 'skjult')}")
print(f"Kommentarer: {video['statistics'].get('commentCount', 'deaktivert')}")
print(f"Varighet: {video['contentDetails']['duration']}")
print(f"Tags: {video['snippet'].get('tags', [])[:5]}")

Responsen er ren, typet og dokumentert. Ingen JSON-arkeologi nødvendig.

Steg 3: Hent videodetaljer, kanalinfo og kommentarer

# Søk etter videoer
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']}")

# Hent kommentarer
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]}")

Realiteten bak YouTube-API-kvoten (det ingen forteller deg)

Dette er delen som skiller en nyttig guide fra en ren kopi-og-lim-oppskrift. Standardtildelingen er 10 000 kvoteenheter per dag, tilbakestilt ved midnatt Pacific Time. Slik koster hvert kall:

API-endepunkt	Kostnad per kall	Maks resultater per kall
search.list	100 enheter	50 resultater
videos.list	1 enhet	50 video-IDer (batch)
channels.list	1 enhet	50 kanal-IDer
commentThreads.list	1 enhet	100 kommentarer
captions.list	50 enheter	N/A

La oss ta regnestykket. Si at du vil skrape 1 000 søkeresultater:

• Søkekall: 1 000 resultater ÷ 50 per side = 20 kall × 100 enheter = 2 000 enheter (20 % av dagsbudsjettet — borte)
• Videodetaljer for disse 1 000 videoene: 1 000 IDer ÷ 50 per batch = 20 kall × 1 enhet = 20 enheter (billig — batchet videos.list er redningen)
• Kommentarer for disse 1 000 videoene (forutsatt 1 side hver): 1 000 kall × 1 enhet = 1 000 enheter

Totalt: rundt 3 020 enheter for et moderat uttak. Men hvis videoene har dype kommentarfelt (50+ sider hver), bruker du raskt opp de resterende 7 000 enhetene. Én video med 50 000 kommentarer = omtrent 500 sider = 500 enheter. Skraper du 20 slike videoer, er du ferdig for dagen.

Prosessen for å øke kvoten krever en full compliance-gjennomgang: URL til personvernpolicy, URL til vilkår, video-demo av appen og begrunnelse med kvotematematikk. Brukererfaringer tyder på at normalt svar fra Google tar 3–5 virkedager, full godkjenning kan ta uker til måneder, og mange søknader blir avvist — særlig brukstilfeller som «jeg vil ha mer data til analyse».

Når du bør bruke API-et: Små til mellomstore prosjekter, når du trenger strukturert og pålitelig data, når kommentarer og kanalstatistikk er viktig, og når du kan leve med kvotetak.

Når skraping er mer fornuftig: Store prosjekter (>10 000 videoer/dag), felter API-et ikke eksponerer (full transkripsjon — captions.download krever OAuth + tillatelse fra videoeier), eller når du trenger mer enn 500 søkeresultater per søk (hard API-grense uansett hva totalResults hevder).

No-code snarveien: Skrap YouTube med Thunderbit (ingen Python nødvendig)

Hvis du trenger Python for en datapipeline, bruk metode 1–4 ovenfor. Men hvis du trenger YouTube-data på 2 minutter — kanskje du er en markedsfører som henter konkurrentstatistikk, eller en utvikler som bare vil ha en rask datauttrekning uten å sette opp et prosjektmiljø — finnes det en raskere vei.

Thunderbit er en AI-webskraper som Chrome-utvidelse, bygget spesielt for situasjoner der kode er overkill. Den fungerer direkte på YouTube-sider i nettleseren din.

Slik skraper du YouTube med Thunderbit i 3 steg

Steg 1: Installer Thunderbit Chrome-utvidelsen og åpne en YouTube-kanalside, en søkeresultatside eller en videoside.

Steg 2: Klikk på "AI Suggest Fields" i Thunderbit-sidepanelet. AI-en leser siden og foreslår kolonner som videotittel, visninger, opplastingsdato, varighet, kanalnavn og thumbnail-URL. Du kan legge til, fjerne eller gi nytt navn til kolonner etter behov.

Steg 3: Klikk "Scrape" og eksporter til Google Sheets, Excel, CSV, Airtable eller Notion. Dataene havner i en ryddig tabell, klar til bruk.

Prøv Thunderbit for YouTube-skraping

Hvem passer dette for?

• Markedsførere som trenger kanaldata om konkurrenter, men ikke koder
• Utviklere som vil ha en rask datauthenting uten å sette opp virtuelt miljø og installere avhengigheter
• Alle som møter anti-bot-vegger — Thunderbit skraper i brukerens egen innloggede nettlesersesjon, som arver cookies og PO-tokens. Dette omgår mange av blokkeringene som plager serverbaserte skrapere
• Thunderbit kan også bruke subpage scraping for å besøke hver videoside og berike tabellen med flere detaljer (som antall likerklikk, beskrivelse og tags)

For et dypere innblikk i hvordan Thunderbit håndterer YouTube spesifikt, sjekk ut Thunderbit YouTube Channel Scraper-template og Thunderbit YouTube-kanalen.

Tips for å skrape YouTube med Python uten å bli blokkert

Disse tipsene gjelder alle de fire Python-metodene. YouTubes anti-bot-mekanismer er vurdert til 6/10 i vanskelighetsgrad av ScrapeOps, med tre hovedsignaler: IP-basert atferdsanalyse, krav til JavaScript-kjøring og stadig skiftende HTML-struktur.

For alle metoder:

• Roter User-Agent-strenger og hele header-settet — Accept, Accept-Language og Sec-CH-UA-client hints må samsvare med den oppgitte UA-en. ScraperAPIs guide fra 2026 har en oppdatert liste.
• Legg inn tilfeldige pauser på 2–8 sekunder mellom forespørsler. Faste intervaller er et deteksjonssignal.
• Bruk residential proxies for alt utover noen få sider. Datacenter-IP-er (AWS, GCP, Hetzner) er praktisk talt døde for YouTube-skraping i 2025–2026.
• Roter sesjon og IP sammen — YouTube knytter sesjoner til IP, og den samme sesjonscookien på to ulike IP-er er et rødt flagg.

For requests + BS4: Sett CONSENT=YES+cb-cookien. Uten den blir EU-forespørsler videresendt til en samtykkeside uten data.

For Selenium/Playwright: Kjør med vindu og xvfb på Linux-servere i stedet for --headless=new — headless Chrome lekker fortsatt nok fingerprint-signaler til at avanserte detektorer finner det. Vurder playwright-stealth, som legger inn rundt 17 unndragelser.

For yt-dlp: Bruk sleep_interval og max_sleep_interval. Installer pluginet bgutil-ytdlp-pot-provider for PO-token-generering. Bruk --cookies-from-browser chrome med en engangskonto.

For API-et: Overvåk kvoteforbruk i Google Cloud Console og batch forespørsler effektivt. Ett enkelt videos.list-kall med 50 kommaseparerte ID-er koster 1 enhet — bruk det.

For Thunderbit: Anti-bot-tiltak håndteres automatisk siden skrapingen skjer i nettlesersesjonen din. Du automatiserer i praksis bare det du ville gjort manuelt.

Er det lov å skrape YouTube med Python?

Det kommer an på hva du skraper, hvordan du skraper det, og hva du gjør med dataene.

Det juridiske landskapet endret seg i 2024 med Meta Platforms v. Bright Data (N.D. Cal., januar 2024), der dommer Chen slo fast at Metas ToS bare forbyr skraping mens man er innlogget, ikke offentlig skraping uten innlogging. Skraping av offentlig tilgjengelige data ble dermed «betydelig mindre risikofylt» etter denne avgjørelsen. På den andre siden endte hiQ v. LinkedIn med en dom på 500 000 dollar mot hiQ for brudd på ToS, CFAA-brudd (falske kontoer) og trespass to chattels — i tillegg til et permanent forføyningsvedtak.

YouTubes egne bruksvilkår er tydelige: «You are not allowed to access the Service using any automated means (such as robots, botnets or scrapers)» med mindre du har skriftlig forhåndstillatelse eller loven tillater det. YouTube Data API er den offisielt godkjente måten å få tilgang til data på.

Noen praktiske tommelfingerregler:

• Skraping av offentlig synlige data til personlig forskning eller ikke-kommersiell analyse er vanligvis mindre risikofylt
• API-et er det tryggeste valget — det er eksplisitt autorisert
• Unngå å skrape privat eller innloggingsbeskyttet innhold, laste ned opphavsrettsbeskyttede videoer for redistribusjon, eller bryte GDPR med persondata fra kommentarer
• YouTube-kommentarer inneholder persondata etter GDPR art. 4(1) — håndter informasjon om EU-borgere med forsiktighet
• Snakk med juridisk rådgiver for kommersielle skrapeprosjekter

Dette er ikke juridisk rådgivning. Landskapet endrer seg raskt — en ny bølge av DMCA §1201-søksmål fra skapere mot AI-selskaper som har skrapet YouTube til treningsdata, omformer situasjonen i 2025–2026.

Hvilken metode bør du bruke for å skrape YouTube med Python?

Beslutningsguiden:

• Trenger du rask metadata fra noen få sider? → Metode 1 (requests + BS4). Rask, lettvekts, ingen avhengigheter utover requests og beautifulsoup4.
• Trenger du å skrape søkeresultater eller samhandle med dynamiske sider? → Metode 2 (Selenium/Playwright). Full nettleserrendering, støtte for uendelig scrolling, men treg og utsatt for deteksjon.
• Trenger du massemetadata, kommentarer eller transkripsjoner? → Metode 3 (yt-dlp). Det mest kapable enkelverktøyet — 157K+ stjerner av en grunn.
• Trenger du strukturert, pålitelig data i moderat skala? → Metode 4 (YouTube Data API). Offisiell, ren, men begrenset av 10 000 enheter/dag.
• Trenger du data på 2 minutter uten å skrive kode? → Thunderbit. Nettleserbasert, AI-drevet, eksporterer til Google Sheets med få klikk.

Ingen enkelt metode dekker alle behov. Bokmerk sammenligningstabellen og referansetabellen for hvilke felt som kan hentes ut — de sparer deg tid på neste prosjekt. Og hvis du vil utforske flere tilnærminger til webskraping, har vi mange guider på Thunderbit-bloggen som dekker alt fra Python-skrapetutorials til å skrape data inn i Google Sheets.

Prøv Thunderbit for YouTube-skraping Get Started Free

Vanlige spørsmål

Kan jeg skrape YouTube uten en API-nøkkel?

Ja. Metode 1 (requests + BS4), 2 (Selenium/Playwright) og 3 (yt-dlp) krever ikke API-nøkkel. Bare metode 4 (YouTube Data API) trenger det. Thunderbit fungerer også uten API-nøkkel — den skraper direkte i nettleseren din.

Hva er den raskeste måten å skrape YouTube med Python på?

For Python er yt-dlp og requests + BS4 raskest — begge unngår nettleseroverhead og kan hente metadata på sekunder per video. yt-dlp er spesielt raskt for batch-jobber siden det håndterer paginering internt. For brukere som ikke bruker Python, er Thunderbit raskest totalt sett siden oppsettstiden er null.

Hvordan skraper jeg YouTube-kommentarer med Python?

yt-dlp har innebygd kommentaruthenting via getcomments-opsjonen — det er den enkleste veien. YouTube Data API støtter også kommentarer via commentThreads.list (1 kvoteenhet per kall, opptil 100 kommentarer per side). Selenium/Playwright kan teknisk gjøre det ved å scrolle og hente rendrerte kommentarelementer, men det er tregt og skjørt.

Kan jeg skrape YouTube Shorts med Python?

Ja. yt-dlp håndterer Shorts-metadata godt — det behandler dem som vanlige videoer med ekstra Shorts-spesifikke felt. YouTube Data API har delvis støtte (måten Shorts-visninger telles på endret seg 30. april 2025 — visninger teller nå enhver avspilling/replay). BS4 og Selenium/Playwright har begrenset Shorts-støtte siden Shorts-hyllen bruker andre DOM-strukturer.

Hvor mange YouTube-videoer kan jeg skrape per dag?

Med YouTube Data API er du begrenset til rundt 10 000 kvoteenheter/dag. Ved å bruke batchede videos.list-kall (50 ID-er per kall for 1 enhet) kan du slå opp opptil 500 000 videostatistikk per dag — men search.list på 100 enheter per kall tømmer budsjettet raskt. Med skrapemetoder (BS4, Selenium, yt-dlp) er grensen praktisk heller enn hardkodet: IP-blokkering slår vanligvis inn etter noen hundre til noen tusen forespørsler per IP per dag, avhengig av proxy-oppsett og forespørselsmønstre. Thunderbit bruker et kreditbasert system knyttet til din plan.

Lær mer

• Hvordan skrape med Python
• Playwright vs Puppeteer
• Beste automatiserte webskrapeverktøy
• Scrapy Python-tutorial
• Skrap LinkedIn med Python