Skrapa YouTube med Python: 4 metoder som faktiskt fungerar

Om du någonsin har testat requests.get("https://www.youtube.com/...") och sedan granskat resultatet med BeautifulSoup i jakt på videotitlar, känner du redan till slutet: du fick tillbaka en vägg av tomma <div>-taggar och exakt noll användbar data.

Det är den vanligaste frustrationen jag ser hos utvecklare som försöker skrapa YouTube för första gången. YouTube är en single-page application — nästan allt renderas på klientsidan via JavaScript. HTML:en som ditt Python-skript får är bara ett skal. De faktiska videotitlarna, visningsräkningarna och metadatan? De ligger gömda i ett massivt JSON-block som heter ytInitialData, och det injiceras av JS efter att sidan har laddats.

Så din fullt rimliga soup.find("div", class_="ytd-video-renderer") returnerar None, eftersom elementet bokstavligen inte finns i det råa HTTP-svaret. När jag väl förstod det föll hela pusslet på plats — och metoderna nedan är resultatet av mycket testande, en del haverier och alldeles för många GitHub-ärenden. Jag går igenom varje metod, visar exakt när du ska använda vad, och lägger dessutom in en no-code-genväg på slutet för dig som bara vill ha datan utan att sätta upp ett helt projekt.

Varför skrapa YouTube med Python över huvud taget?

YouTube är inte bara en videoplattform — det är en datakälla med . Med och finns det enorma mängder offentligt synlig information som företag, forskare och kreatörer vill analysera programmatiskt.

Haken är att YouTubes inbyggda analys bara visar data för din egen kanal. Om du vill förstå en konkurrents publiceringstakt, följa trendande ämnen i din nisch eller analysera publikens reaktioner i kommentarer på någon annans videor, då behöver du skrapa.

Här är de vanligaste användningsfallen jag har sett i verkligheten:

En konkurrensanalys av DJI vs. GoPro vs. Insta360 visade till exempel att — en typ av insikt som är osynlig inne i YouTube Studio.

Varför requests + BeautifulSoup inte räcker för att skrapa YouTube

Innan vi går vidare till metoderna som faktiskt fungerar behöver du förstå varför det självklara angreppssättet misslyckas. Det här är inte akademiskt — det sparar dig timmar av felsökning.

Det ”självklara” upplägget ser ungefär ut så här i teorin:

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 — varje gång

Resultatet blir alltid noll. Som säger: ”Sidan laddades dynamiskt, vilket inte stöds av requests-biblioteket.” är ännu tydligare: ”Med bara requests och BeautifulSoup kan du inte köra JavaScript.”

förklarar mekaniken: YouTube är byggt som en Single Page Application (SPA). När du använder vanliga HTTP-förfrågningar får du bara det första HTML-skalet — själva innehållet har ännu inte renderats. Videodatat ligger i JavaScript-objekt som en webbläsare normalt kör och injicerar i DOM:en.

Det positiva är att YouTube faktiskt bäddar in all data du behöver i den råa HTML:en. Den ligger bara inte i DOM-element — den ligger i två JSON-block i <script>-taggar:

• ytInitialData — sidstruktur, videolistor, engagemangsstatistik, continuation tokens för kommentarer
• ytInitialPlayerResponse — kärnmetadata för videon (titel, beskrivning, längd, format, undertexter)

Båda går att hämta med en enda requests.get() — ingen webbläsare krävs — när du väl vet hur du extraherar och tolkar dem. Det är metod 1 nedan.

4 sätt att skrapa YouTube med Python: jämförelse sida vid sida

Innan vi går in i varje metod, här är beslutstabellen. Jag har testat alla fyra angreppssätt och jämfört dem utifrån det som faktiskt spelar roll när du väljer verktyg för ett riktigt projekt.

Kort sammanfattning:

Vilken YouTube-data kan du faktiskt extrahera – och med vilken metod?

Det här är referenstabellen jag önskar att jag hade när jag började. Ingen enskild metod täcker alla fält — och det är precis därför den här artikeln tar upp fyra stycken.

Välj metod utifrån vilka rader som är viktigast för ditt projekt. Om du behöver kommentarer och transkriptioner är yt-dlp den tydliga vinnaren. Om du behöver strukturerad statistik i medelstor skala är API:t bäst. Om du vill ha data inom två minuter, fortsätt till Thunderbit-delen.

Metod 1: Skrapa YouTube med Python med requests + BeautifulSoup (ytInitialData-tolkning)

Den här metoden utnyttjar att YouTube bäddar in all siddata som JSON i den råa HTML:en. Du behöver ingen webbläsare — du behöver bara veta var du ska leta.

• Svårighetsgrad: Nybörjare
• Tidsåtgång: ~15 minuter
• Du behöver: Python 3.10+, requests, beautifulsoup4

Steg 1: Skicka en GET-förfrågan till YouTube-sidan

Skicka en förfrågan med en realistisk User-Agent-header. Standardhuvudet python-requests/2.x blockeras direkt — bekräftar att detta är den vanligaste fallgropen för nybörjare.

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",  # kringgår EU:s samtyckesvägg
8}
9url = "https://www.youtube.com/@mkbhd/videos"
10response = requests.get(url, headers=HEADERS)
11print(response.status_code)  # Bör vara 200

CONSENT-cookien är avgörande — utan den omdirigeras förfrågningar från EU ofta till consent.youtube.com, som levererar HTML utan någon ytInitialData alls.

Steg 2: Tolka HTML:en och hitta ytInitialData-scriptet

Använd BeautifulSoup eller ett regex för att hitta <script>-taggen som innehåller var ytInitialData =:

1import re
2import json
3# Extrahera 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 extraherad lyckades")
12else:
13    print("ytInitialData hittades inte — kontrollera headers/cookies")

Ett vanligt misstag är att använda en icke-girig .*? med bara }; som avslutningsmarkör. Nästlade objektavslut förekommer hela tiden inuti JSON:en och gör att du klipper av fångsten för tidigt. Använd };</script> som gör — det är den sista tilldelningen i just det scriptblocket.

Steg 3: Navigera JSON-strukturen för att extrahera videodata

JSON:en är djupt nästlad. I stället för att hårdkoda sökvägar som går sönder varje gång YouTube ändrar strukturen (vilket händer regelbundet — dokumenterar flera formatändringar sedan 2023), använd en rekursiv nyckelsökning:

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# Extrahera videoinfo från kanalens sida
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"Hittade {len(videos)} videor")
23for v in videos[:5]:
24    print(f"  {v['title']} — {v['views']}")

Det här rekursiva angreppssättet är det som , yt-dlp och Scrapfly till slut landade i — det överlever YouTubes frekventa omstrukturering av JSON:en.

Steg 4: Exportera den skrapade datan till CSV eller 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 exporterad till youtube_videos.csv")

När du ska använda den här metoden – och när du inte ska det

Bäst för: Snabba metadatautdrag från ett fåtal kanal- eller videosidor. Lätta SEO-verktyg. Engångsanalyser där du behöver titel, visningar och uppladdningsdatum.

Begränsningar: JSON-strukturen ändras — dokumenterade brytningar inkluderar omarbetningen av gilla-knappen (2023: toggleButtonRenderer → segmentedLikeDislikeButtonViewModel), omarbetningen av beskrivningen (2023: description.runs[] → attributedDescription.content) och omdesignen av kanalens Videos-flik (2022–2023: gridRenderer → richGridRenderer). Datacenter-IP:er blir vanligtvis mjukt blockerade efter 50–200 förfrågningar. Inga kommentarer, inga transkriptioner.

Metod 2: Skrapa YouTube med Python med Selenium eller Playwright

När du behöver interagera med sidan — scrolla genom sökresultat, klicka på flikar, fälla ut beskrivningar — är webbläsarautomation rätt väg.

• Svårighetsgrad: Medel
• Tidsåtgång: ~30 minuter
• Du behöver: Python 3.10+, Playwright (pip install playwright && playwright install) eller Selenium + ChromeDriver

Jag rekommenderar Playwright framför Selenium för nya projekt. visar att Playwright är ungefär jämfört med Selenium. Playwright använder en ihållande WebSocket via Chrome DevTools Protocol medan Selenium använder WebDriver över HTTP, vilket lägger till ett översättningslager per kommando.

Steg 1: Installera Playwright

1pip install playwright
2playwright install chromium

1from playwright.sync_api import sync_playwright
2pw = sync_playwright().start()
3browser = pw.chromium.launch(headless=False)  # synligt läge minskar viss detektering
4context = browser.new_context()
5# Förinställ samtyckescookie för att kringgå EU-väggen
6context.add_cookies([{
7    "name": "SOCS",
8    "value": "CAISNQgDEitib3FfaWRlbnRpdHlmcm9udGVuZHVpc2VydmVyXzIwMjMwODI5LjA3X3AxGgJlbiACGgYIgJnPpwY",
9    "domain": ".youtube.com",
10    "path": "/",
11}])
12page = context.new_page()

Steg 2: Gå till en YouTube-sida och vänta på att innehållet laddas

1page.goto("https://www.youtube.com/@mkbhd/videos")
2page.wait_for_selector("a#video-title-link", timeout=15000)
3print("Sidan laddad — videoelement synliga")

Om du skrapar sökresultat går du i stället till https://www.youtube.com/results?search_query=din+s%C3%B6kning.

Steg 3: Hantera oändlig scroll för att ladda fler videor

YouTube använder oändlig scroll på kanalsidor och sökresultat. Här är den klassiska scrollHeight-loopen, anpassad från :

1prev_height = -1
2max_scrolls = 20  # sätt en gräns — en kanal med 10K videor skulle annars scrollas i all oändlighet
3scroll_count = 0
4while scroll_count < max_scrolls:
5    page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
6    page.wait_for_timeout(1500)  # vänta på att nytt innehåll laddas
7    new_height = page.evaluate("document.body.scrollHeight")
8    if new_height == prev_height:
9        break  # inget nytt innehåll laddades
10    prev_height = new_height
11    scroll_count += 1
12print(f"Scrollade {scroll_count} gånger")

Steg 4: Extrahera videodata från den renderade sidan

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"Extraherade {len(videos)} videor")

För visningsantal och uppladdningsdatum behöver du hämta syskon-element. varnar för att id="video-title-link" inte är universellt — YouTube levererar flera olika sidvarianter. Det robusta reservalternativet är a[href*="watch"].

Steg 5: Exportera till CSV eller 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()

När du ska använda den här metoden – och när du inte ska det

Bäst för: Skrapning av sökresultat, interaktion med dynamiska sidmoment (klicka på flikar, fälla ut beskrivningar), allt som kräver en fullt renderad DOM.

Begränsningar: Långsamt (~1,5–3 sekunder per video i ett scroll-och-extrahera-flöde). Hög risk för anti-bot-detektering — ren Selenium sätter navigator.webdriver === true, vilket . Resurskrävande (varje webbläsarinstans använder 200–500 MB RAM). För 100 videor får du räkna med 3–8 minuter i stället för sekunder med yt-dlp.

Metod 3: Skrapa YouTube med Python med yt-dlp

yt-dlp är YouTube-skrapningens schweiziska armékniv. Det är en community-fork av youtube-dl med , aktiva nattliga releaser och inbyggt stöd för metadata, kommentarer, transkriptioner och batchskrapning — helt utan webbläsare eller API-nyckel.

• Svårighetsgrad: Nybörjare till medel
• Tidsåtgång: ~10 minuter
• Du behöver: Python 3.10+, pip install yt-dlp

Steg 1: Installera yt-dlp

1pip install yt-dlp

Inga webbläsardrivrutiner, inga API-nycklar, inga konfigurationsfiler.

Steg 2: Extrahera videometadata utan att ladda ner

1import yt_dlp
2opts = {
3    "quiet": True,
4    "skip_download": True,      # inga videobytes — bara 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"Visningar: {info['view_count']:,}")
14print(f"Gilla-markeringar: {info.get('like_count', 'N/A')}")
15print(f"Längd: {info['duration']}s")
16print(f"Uppladdningsdatum: {info['upload_date']}")
17print(f"Kanal: {info['channel']} ({info.get('channel_follower_count', 'N/A')} prenumeranter)")
18print(f"Taggar: {info.get('tags', [])[:5]}")

Ett typiskt extract_info-anrop returnerar 80–120 fält beroende på videons status: 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 och mer.

Steg 3: Extrahera kommentarer från en 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"],  # totalt, föräldrar, svar per, svar totalt
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"Hämtade {len(comments)} kommentarer")
19for c in comments[:3]:
20    print(f"  [{c.get('like_count', 0)} likes] {c['author']}: {c['text'][:80]}...")

Kommentarshämtning är långsam. rapporterar att kommentarhämtning går i ungefär 30 KB/s — en video med 100 000 kommentarer kan ta timmar. dokumenterar videor där format-URL:er löper ut (cirka 6 timmar) innan kommentarspagineringen är klar. Sätt max_comments aggressivt för stora videor.

Steg 4: Extrahera transkriptioner och undertexter

Varken YouTube Data API eller BS4-analys kan ge dig fullständiga transkriptioner. Det här är yt-dlp:s unika fördel.

1opts = {
2    "quiet": True,
3    "skip_download": True,
4    "writesubtitles": True,
5    "writeautomaticsub": True,
6    "subtitleslangs": ["en", "en-orig"],
7    "subtitlesformat": "json3",   # maskinläsbart: start/dur i ms + text
8    "outtmpl": "%(id)s.%(ext)s",
9}
10with yt_dlp.YoutubeDL(opts) as ydl:
11    info = ydl.extract_info(
12        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
13        download=False
14    )
15# Kom åt undertextsdata direkt från info-dict:en
16auto_captions = info.get("automatic_captions", {})
17manual_subs = info.get("subtitles", {})
18print(f"Språk för automatiska undertexter: {list(auto_captions.keys())[:10]}")
19print(f"Språk för manuella undertexter: {list(manual_subs.keys())}")

Formatet json3 är bäst för maskinell tolkning — varje segment har start/dur i millisekunder plus textsegment. Språkkoderna följer BCP-47 (en, en-US, zh-Hans, ja, es).

Steg 5: Batchskrapa flera videor eller en hel kanal

1opts = {
2    "quiet": True,
3    "skip_download": True,
4    "extract_flat": "in_playlist",  # snabbt — bara video-ID:n och titlar
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"Hittade {len(entries)} videor på kanalen")
15for e in entries[:5]:
16    print(f"  {e.get('title', 'N/A')} — {e.get('id')}")

Skicka en kanal-URL, en spelliste-URL eller till och med en sökfråga (ytsearch10:python scraping) så hanterar yt-dlp pagineringen internt.

När du ska använda den här metoden – och när du inte ska det

Bäst för: Massuttag av metadata, kommentarer, transkriptioner, videonedladdning, kanalomfattande skrapningar där du behöver hela fältuppsättningen.

Begränsningar: Inte idealisk för att skrapa sökresultatsidor (Selenium/Playwright är bättre där). Anti-bot-kapprustningen 2024–2026 har gjort yt-dlp mer komplext att köra i stor skala — YouTube kräver nu för vissa klienter. För produktionsbruk bör du installera pluginet och använda --cookies-from-browser chrome (med ett engångskonto — yt-dlp-teamet varnar för att cookies från ett riktigt Google-konto kan göra att kontot blir spärrat).

Metod 4: Skrapa YouTube med Python med YouTube Data API

Det officiella YouTube Data API v3 är det mest pålitliga och strukturerade sättet att hämta YouTube-data. Svaren är ren JSON, fälten är dokumenterade och det finns inget anti-bot-katt-och-råtta-spel. Men det finns en hake som många guider hoppar över: kvotsystemet.

• Svårighetsgrad: Medel
• Tidsåtgång: ~20 minuter (inklusive API-nyckeluppsättning)
• Du behöver: Python 3.10+, ett Google Cloud-projekt, pip install google-api-python-client

Steg 1: Skaffa en YouTube Data API-nyckel

1. Gå till
2. Skapa ett nytt projekt (eller välj ett befintligt)
3. Gå till APIs & Services → Library → sök efter "YouTube Data API v3" → Enable
4. Gå till APIs & Services → Credentials → Create Credentials → API Key
5. Kopiera nyckeln — du använder den i koden nedan

Steg 2: Gör ditt första API-anrop

1from googleapiclient.discovery import build
2API_KEY = "YOUR_API_KEY_HERE"
3youtube = build("youtube", "v3", developerKey=API_KEY)
4# Hämta detaljer för en specifik 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"Visningar: {video['statistics']['viewCount']}")
12print(f"Gilla-markeringar: {video['statistics'].get('likeCount', 'dold')}")
13print(f"Kommentarer: {video['statistics'].get('commentCount', 'avstängda')}")
14print(f"Längd: {video['contentDetails']['duration']}")
15print(f"Taggar: {video['snippet'].get('tags', [])[:5]}")

Svaret är rent, typat och dokumenterat. Ingen JSON-arkeologi behövs.

Steg 3: Extrahera videodetaljer, kanalinfo och kommentarer

1# Sök efter videor
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# Hämta kommentarer
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]}")

Den verkliga sanningen om YouTube API-kvoterna

Det här är delen som skiljer en användbar guide från en copy-paste-tutorial. Standardtilldelningen är , återställd vid midnatt Pacific Time. Så här mycket kostar varje anrop:

Nu till matematiken. Säg att du vill skrapa 1 000 sökresultat:

• Sökanrop: 1 000 resultat ÷ 50 per sida = 20 anrop × 100 enheter = 2 000 enheter (20 % av din dagliga budget — borta)
• Videodetaljer för dessa 1 000 videor: 1 000 ID:n ÷ 50 per batch = 20 anrop × 1 enhet = 20 enheter (billigt — batchade videos.list är räddningen)
• Kommentarer för dessa 1 000 videor (om vi antar 1 sida per video): 1 000 anrop × 1 enhet = 1 000 enheter

Totalt: cirka 3 020 enheter för en ganska modest skrapning. Men om videorna har djupa kommentarstrådar (50+ sidor vardera) bränner du snabbt igenom de återstående 7 000 enheterna. En video med 50 000 kommentarer = ungefär 500 sidor = 500 enheter. Skrapa 20 sådana videor och du är klar för dagen.

kräver en fullständig regelefterlevnadsgranskning: URL till integritetspolicy, URL till användarvillkor, videogenomgång av appen, motivering för kvotmatematiken. Erfarenheter från communityn tyder på att Googles svar ofta kommer inom 3–5 arbetsdagar, men fullständigt godkännande kan ta veckor till månader, och många ansökningar avslås — särskilt use cases i stil med ”jag vill ha mer data för analys”.

När API:t passar: Små till medelstora volymer, när du behöver strukturerad och pålitlig data, när kommentarer och kanalstatistik är viktiga och när du kan leva med kvottaket.

När skrapning är mer rimligt: Stora projekt (>10K videor/dag), fält som API:t inte exponerar (fullständiga transkriptioner — captions.download kräver OAuth + ägarbehörighet för videon), eller när du behöver mer än 500 sökresultat per fråga (hård API-gräns oavsett påstått totalResults).

No-code-genvägen: skrapa YouTube med Thunderbit (ingen Python krävs)

Om du behöver Python för en datakedja, använd metoderna 1–4 ovan. Men om du behöver YouTube-data på 2 minuter — kanske är du marknadsförare som tar fram konkurrentstatistik, eller utvecklare som bara vill ha ett snabbt datauttag utan att sätta upp en projektmiljö — finns det en snabbare väg.

är ett AI-webbskrapnings-tillägg för Chrome som vi byggt specifikt för situationer där kod är överkurs. Det fungerar direkt på YouTube-sidor i din webbläsare.

Så skrapar du YouTube med Thunderbit i 3 steg

Steg 1: Installera och öppna en YouTube-kanalsida, en sökresultatsida eller en videosida.

Steg 2: Klicka på "AI Suggest Fields" i Thunderbit-sidofältet. AI:n läser sidan och föreslår kolumner som videotitel, visningar, uppladdningsdatum, längd, kanalnamn och thumbnail-URL. Du kan lägga till, ta bort eller byta namn på kolumner efter behov.

Steg 3: Klicka på "Scrape" och exportera till Google Sheets, Excel, CSV, Airtable eller Notion. Datan landar i en ren tabell, redo att användas.

Vem detta passar för

• Marknadsförare som behöver konkurrentdata från kanaler men inte kodar
• Utvecklare som vill ha ett snabbt datauttag utan att sätta upp en virtuell miljö och installera beroenden
• Alla som stöter på anti-bot-väggar — Thunderbit skrapar i användarens egna inloggade webbläsarsession, vilket innebär att cookies och PO-tokens följer med. Det kringgår många av de blockeringsproblem som plågar serverbaserade skrapare
• Thunderbit kan också använda för att besöka varje videosida och berika tabellen med fler detaljer (antal gilla-markeringar, beskrivning, taggar)

Vill du se mer om hur Thunderbit hanterar YouTube specifikt, kolla in och .

Tips för att skrapa YouTube med Python utan att bli blockerad

De här tipsen gäller alla fyra Python-metoder. YouTubes anti-bot-försvar bedöms till , med tre huvudsignaler: IP-baserad beteendeanalys, krav på JS-exekvering och HTML-struktur som ändras ofta.

För alla metoder:

• Rotera User-Agent-strängar och hela headeruppsättningen — Accept, Accept-Language, Sec-CH-UA och klienthintar måste alla matcha den UA du anger. har en aktuell lista.
• Lägg in slumpmässiga pauser på 2–8 sekunder mellan förfrågningar. Fasta intervall är en detekteringssignal.
• Använd residential proxies för allt som är mer än ett fåtal sidor. Datacenter-IP:er (AWS, GCP, Hetzner) är .
• Rotera session + IP tillsammans — YouTube kopplar sessioner till IP, och samma session-cookie på två olika IP-adresser är en varningssignal.

För requests + BS4: Sätt cookien CONSENT=YES+cb. Utan den hamnar EU-förfrågningar på en samtyckessida utan data.

För Selenium/Playwright: Kör synligt läge med xvfb på Linux-servrar i stället för --headless=new — headless Chrome läcker fortfarande tillräckligt med fingeravtryck för mer avancerade detektorer. Överväg , som tillämpar runt 17 olika kringgåenden.

För yt-dlp: Använd alternativen sleep_interval och max_sleep_interval. Installera pluginet för PO Token-generering. Använd --cookies-from-browser chrome med ett engångskonto.

För API:t: Följ kvotanvändningen i och batcha anrop effektivt. Ett enda videos.list-anrop med 50 kommaseparerade ID:n kostar 1 enhet — använd det.

För Thunderbit: Anti-bot-skydd hanteras automatiskt eftersom skrapningen sker i din webbläsarsession. Du automatiserar i praktiken bara det du ändå skulle ha gjort manuellt.

Är det lagligt att skrapa YouTube med Python?

Det beror på vad du skrapar, hur du skrapar det och vad du gör med datan.

Den juridiska bilden förändrades 2024 med Meta Platforms v. Bright Data (N.D. Cal., januari 2024), där . Att skrapa offentligt tillgänglig data blev ”avsevärt mindre riskfyllt” efter den domen. Å andra sidan slutade hiQ v. LinkedIn med en för brott mot användarvillkor, CFAA-överträdelser (fejkade konton) och trespass to chattels — plus ett permanent föreläggande.

YouTubes egna är tydliga: ”Du får inte använda automatiserade medel (som robotar, botnät eller scrapers) för att komma åt tjänsten” annat än med skriftligt förhandstillstånd eller där tillämplig lag tillåter det. YouTube Data API är den officiellt godkända vägen att komma åt data.

Några praktiska tumregler:

• Skrapning av offentligt synlig data för personlig forskning eller icke-kommersiell analys innebär generellt lägre risk
• API:t är säkraste vägen — det är uttryckligen auktoriserat
• Undvik att skrapa privat/inloggningsskyddat innehåll, ladda ner upphovsrättsskyddade videor för vidare spridning eller bryta mot GDPR med persondata från kommentarer
• YouTube-kommentarer innehåller personuppgifter enligt GDPR art. 4(1) — hantera information om EU-registrerade personer varsamt
• Rådfråga jurist för kommersiella skrapningsprojekt

Det här är inte juridisk rådgivning. Läget förändras snabbt — en ny våg av som skrapat YouTube för träningsdata omformar landskapet 2025–2026.

Vilken metod ska du använda för att skrapa YouTube med Python?

Beslutsguiden:

• Behöver du snabb metadata från några få sidor? → Metod 1 (requests + BS4). Snabb, lätt, inga beroenden utöver requests och beautifulsoup4.
• Behöver du skrapa sökresultat eller interagera med dynamiska sidor? → Metod 2 (Selenium/Playwright). Full webbläsarrendering, stöd för oändlig scroll, men långsam och känslig för detektering.
• Behöver du massmetadata, kommentarer eller transkriptioner? → Metod 3 (yt-dlp). Det mest kapabla enskilda verktyget — av en anledning.
• Behöver du strukturerad, pålitlig data i medelstor skala? → Metod 4 (YouTube Data API). Officiellt, rent, men begränsat av kvot till .
• Behöver du data inom 2 minuter utan att skriva kod? → . Webbläsarbaserat, AI-drivet, exporterar till Google Sheets med några klick.

Ingen enskild metod täcker alla användningsfall. Spara jämförelsetabellen och referensen över extraherbara fält ovan — de kommer att spara tid i ditt nästa projekt. Och om du vill utforska fler har vi gott om guider i Thunderbit-bloggen, från till .

Vanliga frågor

Kan jag skrapa YouTube utan API-nyckel?

Ja. Metod 1 (requests + BS4), 2 (Selenium/Playwright) och 3 (yt-dlp) kräver ingen API-nyckel. Bara metod 4 (YouTube Data API) behöver en. Thunderbit fungerar också utan API-nyckel — det skrapar direkt i din webbläsare.

Vad är det snabbaste sättet att skrapa YouTube med Python?

För Python är yt-dlp och requests + BS4 snabbast — båda undviker webbläsaröverhead och kan hämta metadata på sekunder per video. yt-dlp är särskilt snabbt för batchjobb eftersom det hanterar paginering internt. För icke-Python-användare är Thunderbit snabbast totalt eftersom uppsättningstiden är noll.

Hur skrapar jag YouTube-kommentarer med Python?

yt-dlp har inbyggd extrahering av kommentarer via alternativet getcomments — det är den enklaste vägen. YouTube Data API stöder också kommentarer via commentThreads.list (1 kvotenhet per anrop, upp till 100 kommentarer per sida). Selenium/Playwright kan tekniskt göra det genom att scrolla och extrahera renderade kommentarselement, men det är långsamt och skört.

Kan jag skrapa YouTube Shorts med Python?

Ja. yt-dlp hanterar Shorts-metadata bra — det behandlar dem som vanliga videor med extra Shorts-specifika fält. YouTube Data API har delvis stöd (beräkningen av Shorts-visningar — nu räknas varje uppspelning eller omspelning). BS4 och Selenium/Playwright har begränsat Shorts-stöd eftersom Shorts-hyllan använder andra DOM-strukturer.

Hur många YouTube-videor kan jag skrapa per dag?

Med YouTube Data API är du begränsad till ungefär 10 000 kvotenheter per dag. Med batchade videos.list-anrop (50 ID:n per anrop för 1 enhet) kan du teoretiskt slå upp upp till 500 000 videostatistikposter per dag — men search.list kostar 100 enheter per anrop och äter snabbt upp budgeten. Med skrapmetoderna (BS4, Selenium, yt-dlp) är gränsen praktisk snarare än hårdkodad: IP-blockeringar brukar slå till efter några hundra till några tusen förfrågningar per IP och dag, beroende på proxyupplägg och mönster. Thunderbit använder ett kreditbaserat system kopplat till din .

Läs mer