YouTuben kaapiminen Pythonilla: 4 toimivaa menetelmää

Jos olet joskus kokeillut requests.get("https://www.youtube.com/...")-pyyntöä ja etsinyt tuloksesta videoiden otsikoita BeautifulSoupilla, tiedät jo lopputuloksen: vastassa on pelkkä seinällinen tyhjiä <div>-tageja eikä yhtään hyödyllistä dataa.

Tämä on kaikkein yleisin turhautuminen, jonka näen kehittäjillä, jotka yrittävät kaapia YouTubea ensimmäistä kertaa. YouTube on yhden sivun sovellus — se renderöi lähes kaiken asiakaspäässä JavaScriptin avulla. Se HTML, jonka Python-skripti saa takaisin, on vain kuori. Varsinaiset videoiden otsikot, katselukerrat ja metatiedot? Ne piilotetaan massiiviseen ytInitialData-nimiseen JSON-lohkoon, jonka JS lisää sivulle latauksen jälkeen.

Siksi täysin järkevä soup.find("div", class_="ytd-video-renderer") palauttaa None: kyseistä elementtiä ei yksinkertaisesti ole raakassa HTTP-vastauksessa. Kun ymmärsin tämän, koko palapeli loksahti paikoilleen — ja alla olevat neljä menetelmää ovat syntyneet pitkän testailun, rikkomisen ja aivan liian monen GitHub-ongelman lukemisen tuloksena. Käyn läpi jokaisen lähestymistavan, näytän tarkasti, milloin mitäkin kannattaa käyttää, ja lisään loppuun vielä no-code-oikopolun niille, jotka haluavat vain datan ilman projektin pystyttämistä.

Miksi YouTubea kannattaa kaapia Pythonilla?

YouTube ei ole vain videopalvelu — se on datalähde. Kun palvelussa on ja , tarjolla on valtava määrä julkisesti näkyvää tietoa, jota yritykset, tutkijat ja tekijät haluavat analysoida ohjelmallisesti.

Ongelma on, että YouTuben sisäänrakennettu analytiikka näyttää dataa vain omasta kanavastasi. Jos haluat ymmärtää kilpailijan julkaisutahtia, seurata oman alueesi trendaavia aiheita tai analysoida toisten videoiden kommenttien sävyä, sinun täytyy kaapia data itse.

Tässä ovat yleisimmät käytännön käyttötapaukset, joihin olen törmännyt:

Esimerkiksi DJI:n, GoPron ja Insta360:n välinen kilpailija-analyysi osoitti, että — tällainen oivallus ei näy YouTube Studion sisältä.

Miksi requests + BeautifulSoup ei yksin riitä YouTuben kaapimiseen

Ennen kuin mennään toimiviin menetelmiin, sinun pitää ymmärtää, miksi ilmeinen lähestymistapa epäonnistuu. Tämä ei ole akateemista hiustenhalkomista — se säästää sinulta tunteja debuggausta.

"Ilmeinen" tapa näyttää suunnilleen tältä:

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 — joka kerta

Tulos on aina nolla. Kuten toteaa: "Sivu ladattiin dynaamisesti, eikä requests-lib tukee tätä." sanoo sen suoremmin: "Pelkästään requestsin ja BeautifulSoupin avulla et voi suorittaa JavaScriptiä."

selittää mekanismin: YouTube on rakennettu Single Page Applicationiksi (SPA). Kun käytät tavallisia HTTP-pyyntöjä, saat vain alkuperäisen HTML-kuoren — varsinainen sisältö ei ole vielä renderöitynyt. Videoiden data on JavaScript-objekteissa, jotka selain normaalisti suorittaa ja lisää DOMiin.

Hyvä uutinen: YouTube upottaa kaikki tarvitsemasi tiedot raakaan HTML:ään. Ne eivät vain ole DOM-elementeissä — ne ovat kahdessa <script>-tageihin kätketyssä JSON-lohkossa:

• ytInitialData — sivun rakenne, videolistaukset, sitoutumismittarit, kommenttien jatkotekstit
• ytInitialPlayerResponse — videon ydintiedot (otsikko, kuvaus, kesto, formaatit, tekstitykset)

Molemmat saa ulos yhdellä requests.get()-pyynnöllä — selainta ei tarvita — kunhan tiedät, miten ne poimitaan ja parsitaan. Se on alla oleva menetelmä 1.

4 tapaa kaapia YouTubea Pythonilla: rinnakkainen vertailu

Ennen kuin sukellamme jokaiseen menetelmään, tässä on päätösmatriisi. Olen testannut kaikki neljä lähestymistapaa ja verrannut niitä niihin kriteereihin, joilla oikeasti on merkitystä, kun valitset työkalua todelliseen projektiin.

Pikayhteenveto:

Mitä YouTube-dataa voit oikeasti poimia (ja millä menetelmällä)?

Tämä on viitetable, jonka olisin toivonut löytäväni aloittaessani. Mikään yksittäinen menetelmä ei kata kaikkia kenttiä — ja juuri siksi tässä artikkelissa käsitellään neljä tapaa.

Valitse menetelmä sen mukaan, mitkä rivit ovat tärkeimpiä projektillesi. Jos tarvitset kommentteja ja tekstityksiä, yt-dlp on selvä voittaja. Jos tarvitset strukturoitua dataa kohtuullisessa mittakaavassa, API on paras vaihtoehto. Jos tarvitset dataa kahdessa minuutissa, jatka Thunderbit-osioon.

Menetelmä 1: Kaavi YouTube Pythonilla käyttäen requests + BeautifulSoupia (ytInitialData-parsinta)

Tämä menetelmä hyödyntää sitä, että YouTube upottaa kaiken sivudatan JSON-muodossa raakaan HTML:ään. Selainta ei tarvita — tarvitset vain tiedon siitä, mistä data löytyy.

• Vaikeustaso: Aloittelija
• Aikaa kuluu: ~15 minuuttia
• Tarvitset: Python 3.10+, requests, beautifulsoup4

Vaihe 1: Lähetä GET-pyyntö YouTube-sivulle

Lähetä pyyntö realistisella User-Agent-otsakkeella. Oletuksena tuleva python-requests/2.x-otsake blokataan heti — vahvistaa, että tämä on aloittelijoiden suurin sudenkuoppa.

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",  # ohittaa EU:n suostumusmuurin
8}
9url = "https://www.youtube.com/@mkbhd/videos"
10response = requests.get(url, headers=HEADERS)
11print(response.status_code)  # Pitäisi olla 200

CONSENT-eväste on ratkaisevan tärkeä — ilman sitä EU-alueen pyynnöt ohjataan consent.youtube.com-sivulle, joka sisältää HTML:ää ilman ytInitialData-dataa.

Vaihe 2: Parsitse HTML ja etsi ytInitialData-scripti

Käytä BeautifulSoupia tai regexiä löytääksesi <script>-tagin, joka sisältää var ytInitialData =:

1import re
2import json
3# Poimi 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 poimittu onnistuneesti")
12else:
13    print("ytInitialDataa ei löytynyt — tarkista otsakkeet/evästeet")

Yleinen virhe on käyttää ei-ahnetta .*?-kuviota ja päättää poiminta pelkkään };-merkkiin. Sisäkkäiset objektin päättymiset esiintyvät JSONissa jatkuvasti ja katkaisevat poiminnan liian aikaisin. Käytä loppumerkkinä };</script> kuten tekee — se on kyseisen script-lohkon viimeinen sijoitus.

Vaihe 3: Navigoi JSON-rakennetta ja poimi videodata

JSON on syvästi sisäkkäinen. Sen sijaan, että kovakoodaisit polkuja, jotka rikkoutuvat aina kun YouTube järjestää rakennetta uudelleen (mikä tapahtuu usein — dokumentoi useita formaattimuutoksia vuodesta 2023 alkaen), käytä rekursiivista avainhakua:

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# Poimi videoiden tiedot kanavasivulta
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"Löytyi {len(videos)} videota")
23for v in videos[:5]:
24    print(f"  {v['title']} — {v['views']}")

Tämä rekursiivinen lähestymistapa on juuri se, johon , yt-dlp ja Scrapfly kaikki ovat päätyneet — se kestää YouTuben usein muuttuvan JSON-rakenteen.

Vaihe 4: Vie kaavittu data CSV- tai Excel-tiedostoon

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 viety tiedostoon youtube_videos.csv")

Milloin tätä kannattaa käyttää — ja milloin ei

Paras tähän: Nopeat metatietopoiminnat muutamalta kanava- tai videosivulta. Kevyet SEO-työkalut. Yksittäiset analyysit, joissa tarvitset otsikon, katselukerrat ja julkaisupäivän.

Rajoitukset: JSON-rakenne muuttuu — tunnettuja rikkoutumisia ovat mm. tykkäyspainikkeen uudistus (2023: toggleButtonRenderer → segmentedLikeDislikeButtonViewModel), kuvaustekstin uudistus (2023: description.runs[] → attributedDescription.content) ja kanavan Videos-välilehden uudelleensuunnittelu (2022–2023: gridRenderer → richGridRenderer). Datakeskusten IP:t saavat tyypillisesti pehmeän eston 50–200 pyynnön jälkeen. Ei kommentteja, ei transkriptioita.

Menetelmä 2: Kaavi YouTube Pythonilla käyttäen Seleniumia tai Playwrightia

Kun sinun pitää vuorovaikuttaa sivun kanssa — selata hakutuloksia, klikata välilehtiä, avata kuvauksia — selainautomaatio on oikea tapa.

• Vaikeustaso: Keskitaso
• Aikaa kuluu: ~30 minuuttia
• Tarvitset: Python 3.10+, Playwright (pip install playwright && playwright install) tai Selenium + ChromeDriver

Suosittelen uuteen projektiin Playwrightia Seleniumin sijaan. näyttää, että Playwright on noin kuin Selenium. Playwright käyttää pysyvää WebSocket-yhteyttä Chrome DevTools Protocolin kautta, kun taas Selenium käyttää WebDriveriä HTTP:n yli, mikä lisää välikerroksen jokaiseen komentoon.

Vaihe 1: Aseta Playwright käyttöön

1pip install playwright
2playwright install chromium

1from playwright.sync_api import sync_playwright
2pw = sync_playwright().start()
3browser = pw.chromium.launch(headless=False)  # näkyvä selain vähentää joitakin tunnistuksia
4context = browser.new_context()
5# Esitäytetty suostumus-eväste EU-muurin kiertämiseksi
6context.add_cookies([{
7    "name": "SOCS",
8    "value": "CAISNQgDEitib3FfaWRlbnRpdHlmcm9udGVuZHVpc2VydmVyXzIwMjMwODI5LjA3X3AxGgJlbiACGgYIgJnPpwY",
9    "domain": ".youtube.com",
10    "path": "/",
11}])
12page = context.new_page()

Vaihe 2: Siirry YouTube-sivulle ja odota sisällön latautumista

1page.goto("https://www.youtube.com/@mkbhd/videos")
2page.wait_for_selector("a#video-title-link", timeout=15000)
3print("Sivu ladattu — videoelementit näkyvät")

Jos kaavit hakutuloksia, siirry sen sijaan osoitteeseen https://www.youtube.com/results?search_query=your+query.

Vaihe 3: Käsittele ääretön vieritys, jotta saat lisää videoita näkyviin

YouTube käyttää kanavasivuilla ja hakutuloksissa ääretöntä vieritystä. Tässä on klassinen scrollHeight-silmukka, mukailtuna :

1prev_height = -1
2max_scrolls = 20  # rajoita tätä — 10 000 videon kanava vierii loputtomiin
3scroll_count = 0
4while scroll_count < max_scrolls:
5    page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
6    page.wait_for_timeout(1500)  # odota uuden sisällön latautumista
7    new_height = page.evaluate("document.body.scrollHeight")
8    if new_height == prev_height:
9        break  # uutta sisältöä ei latautunut
10    prev_height = new_height
11    scroll_count += 1
12print(f"Vieritettiin {scroll_count} kertaa")

Vaihe 4: Poimi videodata renderöidyltä sivulta

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"Poimittiin {len(videos)} videota")

Katselukertojen ja julkaisupäivien saamiseksi tarvitset sisar-elementit. huomauttaa, että id="video-title-link" ei ole yleispätevä — YouTube julkaisee useita sivuvariaatioita. Kestävä vararatkaisu on a[href*="watch"].

Vaihe 5: Vie data CSV:hen tai Google Sheetiin

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

Milloin tätä kannattaa käyttää — ja milloin ei

Paras tähän: Hakutulosten kaapiminen, dynaamisten sivuelementtien kanssa työskentely (välilehtien klikkaus, kuvausten avaaminen), kaikki tilanteet, joissa tarvitset täysin renderöidyn DOMin.

Rajoitukset: Hidas (~1,5–3 sekuntia per video vieritys-poiminta -virrassa). Korkea anti-bot-tunnistuksen riski — tavallinen Selenium asettaa navigator.webdriver === true, jonka . Resurssisyöppö (yksi selaininstanssi käyttää 200–500 Mt RAM:ia). 100 videon kohdalla aikaa voi mennä 3–8 minuuttia sekuntien sijaan, kuten yt-dlp:llä.

Menetelmä 3: Kaavi YouTube Pythonilla käyttäen yt-dlp:tä

yt-dlp on YouTube-kaapimisen sveitsiläinen linkkuveitsi. Se on youtube-dl:n yhteisöhaara, jolla on , aktiiviset yöjulkaisut ja sisäänrakennettu tuki metatiedoille, kommenteille, tekstityksille ja massakaavinnalle — ilman selainta tai API-avainta.

• Vaikeustaso: Aloittelijasta keskitasoon
• Aikaa kuluu: ~10 minuuttia
• Tarvitset: Python 3.10+, pip install yt-dlp

Vaihe 1: Asenna yt-dlp

1pip install yt-dlp

Ei selainajureita, ei API-avaimia, ei asetustiedostoja.

Vaihe 2: Poimi videon metatiedot lataamatta videota

1import yt_dlp
2opts = {
3    "quiet": True,
4    "skip_download": True,      # ei videobittejä — vain metatiedot
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"Otsikko: {info['title']}")
13print(f"Katselukerrat: {info['view_count']:,}")
14print(f"Tykkäykset: {info.get('like_count', 'N/A')}")
15print(f"Kesto: {info['duration']} s")
16print(f"Julkaisupäivä: {info['upload_date']}")
17print(f"Kanava: {info['channel']} ({info.get('channel_follower_count', 'N/A')} tilaajaa)")
18print(f"Tagit: {info.get('tags', [])[:5]}")

Tyypillinen extract_info-kutsu palauttaa 80–120 kenttää videon tilasta riippuen: 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 ja paljon muuta.

Vaihe 3: Poimi kommentit YouTube-videolta

1opts = {
2    "quiet": True,
3    "skip_download": True,
4    "getcomments": True,
5    "extractor_args": {
6        "youtube": {
7            "max_comments": ["200", "50", "50", "10"],  # yhteensä, pääkommentit, vastaukset per kommentti, vastaukset yhteensä
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"Noudettiin {len(comments)} kommenttia")
19for c in comments[:3]:
20    print(f"  [{c.get('like_count', 0)} tykkäystä] {c['author']}: {c['text'][:80]}...")

Kommenttien poiminta on hidasta. raportoi kommenttien haun nopeudeksi noin 30 KB/s — video, jossa on 100 000 kommenttia, voi viedä tunteja. dokumentoi videoita, joissa formaattien URL-osoitteet vanhenevat (~6 tunnissa) ennen kuin kommenttien sivutus ehtii valmistua. Aseta max_comments aggressiivisesti suurille videoille.

Vaihe 4: Poimi transkriptiot ja tekstitykset

Sekä YouTube Data API että BS4-parsinta eivät anna täydellisiä transkriptioita. Tämä on yt-dlp:n ainutlaatuinen etu.

1opts = {
2    "quiet": True,
3    "skip_download": True,
4    "writesubtitles": True,
5    "writeautomaticsub": True,
6    "subtitleslangs": ["en", "en-orig"],
7    "subtitlesformat": "json3",   # koneellisesti parsittava: start/dur millisekunteina + teksti
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# Käytä tekstitysdataa suoraan info-diktiosta
16auto_captions = info.get("automatic_captions", {})
17manuaaliset = info.get("subtitles", {})
18print(f"Automaattisten tekstitysten kielet: {list(auto_captions.keys())[:10]}")
19print(f"Manuaalisten tekstitysten kielet: {list(manuaaliset.keys())}")

json3-muoto on paras koneelliseen parsintaan — jokaisella segmentillä on start/dur millisekunteina sekä tekstirivit. Kielikoodit ovat BCP-47-muotoa (en, en-US, zh-Hans, ja, es).

Vaihe 5: Kaavi useita videoita tai kokonainen kanava kerralla

1opts = {
2    "quiet": True,
3    "skip_download": True,
4    "extract_flat": "in_playlist",  # nopea — vain video-ID:t ja otsikot
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"Kanavalta löytyi {len(entries)} videota")
15for e in entries[:5]:
16    print(f"  {e.get('title', 'N/A')} — {e.get('id')}")

Voit antaa kanava-URL:n, soittolistan URL:n tai jopa hakulauseen (ytsearch10:python scraping), ja yt-dlp hoitaa sivutuksen sisäisesti.

Milloin tätä kannattaa käyttää — ja milloin ei

Paras tähän: Massamääräinen metatiedon poiminta, kommentit, transkriptiot, videoiden lataaminen, koko kanavan kaapiminen, kun tarvitset täyden kenttäjoukon.

Rajoitukset: Ei ihanteellinen hakutulossivujen kaapimiseen (Selenium/Playwright toimii siihen paremmin). Vuoden 2024–2026 anti-bot-varustelu on tehnyt yt-dlp:n käytöstä suuremmassa mittakaavassa monimutkaisempaa — YouTube valvoo nyt joillakin asiakkailla . Tuotantokäyttöön asenna -lisäosa ja käytä --cookies-from-browser chrome -asetusta (kertakäyttöisellä tilillä — yt-dlp-tiimi varoittaa, että oikean Google-tilin evästeiden käyttäminen voi johtaa tilin bännäykseen).

Menetelmä 4: Kaavi YouTube Pythonilla käyttäen YouTube Data API:a

Virallinen YouTube Data API v3 on luotettavin ja rakenteellisin tapa saada YouTube-dataa. Vastaukset ovat siistiä JSONia, kentät on dokumentoitu, eikä anti-bot-peliä tarvitse pelata. Mutta mukana on yksi koukku, jonka useimmat ohjeet sivuuttavat: kiintiöjärjestelmä.

• Vaikeustaso: Keskitaso
• Aikaa kuluu: ~20 minuuttia (sisältäen API-avaimen luomisen)
• Tarvitset: Python 3.10+, Google Cloud -projekti, pip install google-api-python-client

Vaihe 1: Hanki YouTube Data API -avain

1. Mene
2. Luo uusi projekti (tai valitse olemassa oleva)
3. Siirry kohtaan APIs & Services → Library → etsi "YouTube Data API v3" → Enable
4. Siirry kohtaan APIs & Services → Credentials → Create Credentials → API Key
5. Kopioi avain — käytät sitä alla olevassa koodissa

Vaihe 2: Tee ensimmäinen API-kutsu

1from googleapiclient.discovery import build
2API_KEY = "YOUR_API_KEY_HERE"
3youtube = build("youtube", "v3", developerKey=API_KEY)
4# Hae tietoja tietystä videosta
5response = youtube.videos().list(
6    part="snippet,statistics,contentDetails",
7    id="dQw4w9WgXcQ"
8).execute()
9video = response["items"][0]
10print(f"Otsikko: {video['snippet']['title']}")
11print(f"Katselukerrat: {video['statistics']['viewCount']}")
12print(f"Tykkäykset: {video['statistics'].get('likeCount', 'piilotettu')}")
13print(f"Kommentit: {video['statistics'].get('commentCount', 'pois käytöstä')}")
14print(f"Kesto: {video['contentDetails']['duration']}")
15print(f"Tagit: {video['snippet'].get('tags', [])[:5]}")

Vastaus on siisti, tyypitetty ja dokumentoitu. JSON-arkeologiaa ei tarvita.

Vaihe 3: Poimi videotiedot, kanavatiedot ja kommentit

1# Hae videoita
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# Hae kommentit
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']} tykkäystä] {comment['authorDisplayName']}: {comment['textDisplay'][:80]}")

YouTube API:n kiintiörealiteetti (se, mistä kukaan ei kerro)

Tämä on se osuus, joka erottaa oikeasti hyödyllisen oppaan pelkästä kopioi-liitä-oppaasta. Oletuskiintiö on , ja se nollautuu Tyynenmeren ajan keskiyöllä. Tässä on eri kutsujen kustannus:

Tehdäänpä matematiikka. Oletetaan, että haluat kaapia 1 000 hakutulosta:

• Hakukutsut: 1 000 tulosta ÷ 50 per sivu = 20 kutsua × 100 yksikköä = 2 000 yksikköä (20 % päiväbudjetista — mennyt)
• Videotiedot näille 1 000 videolle: 1 000 ID:tä ÷ 50 per erä = 20 kutsua × 1 yksikkö = 20 yksikköä (halpaa — erissä tehty videos.list pelastaa tilanteen)
• Kommentit näille 1 000 videolle (oletetaan 1 sivu per video): 1 000 kutsua × 1 yksikkö = 1 000 yksikköä

Yhteensä: noin 3 020 yksikköä melko vaatimattomaan kaavintaan. Mutta jos videoilla on syviä kommenttiketjuja (50+ sivua per video), poltat loppukiintiön nopeasti. Video, jossa on 50 000 kommenttia = noin 500 sivua = 500 yksikköä. Kaavi 20 tällaista videota, niin päivän kiintiö on käytetty.

vaatii täyden compliance-tarkastuksen: tietosuojasivun URL, käyttöehtojen URL, videokävelyn sovelluksesta ja perustelun kiintiölaskelmineen. Yhteisön raporttien mukaan Googlen vastaus tulee tyypillisesti 3–5 arkipäivässä, lopullinen hyväksyntä voi kestää viikoista kuukausiin, ja moni hakemus hylätään — etenkin "haluan enemmän dataa analyysiä varten" -tyyppiset käyttötapaukset.

Milloin API kannattaa valita: Pieni tai keskisuuri mittakaava, kun tarvitset jäsenneltyä ja luotettavaa dataa, kun kommentit ja kanavatilastot ovat tärkeitä, ja kun kiintiöraja on hyväksyttävissä.

Milloin kaapiminen on järkevämpää: Suuret projektit (>10 000 videota/päivä), kentät joita API ei paljasta (täydet transkriptiot — captions.download vaatii OAuthin ja videon omistajan oikeudet), tai kun tarvitset enemmän kuin 500 hakutulosta per haku (kovakoodattu API-rajoitus riippumatta totalResults-väitteestä).

No-code-oikotie: Kaavi YouTube Thunderbitillä (Pythonia ei tarvita)

Jos tarvitset Pythonia dataputkeen, käytä yllä olevia menetelmiä 1–4. Mutta jos tarvitset YouTube-dataa kahdessa minuutissa — ehkä olet markkinoija, joka hakee kilpailijatilastoja, tai kehittäjä, joka haluaa vain nopean datapullin ilman projektin ympäristön pystyttämistä — on olemassa nopeampi reitti.

on AI-web-scraper Chrome-laajennus, jonka rakensimme juuri tilanteisiin, joissa koodin kirjoittaminen on liioittelua. Se toimii suoraan YouTube-sivuilla selaimessasi.

Näin kaivat YouTube-dataa Thunderbitillä 3 askeleessa

Vaihe 1: Asenna ja avaa YouTuben kanavasivu, hakutulossivu tai videosivu.

Vaihe 2: Klikkaa Thunderbit-sivupalkissa "AI Suggest Fields". AI lukee sivun ja ehdottaa sarakkeita kuten videon otsikko, katselukerrat, julkaisupäivä, kesto, kanavan nimi ja pikkukuvan URL. Voit lisätä, poistaa tai nimetä sarakkeet uudelleen tarpeen mukaan.

Vaihe 3: Klikkaa "Scrape" ja vie data Google Sheetsiin, Exceliin, CSV:hen, Airtableen tai Notioniin. Data päätyy siistiin taulukkoon, valmiina käytettäväksi.

Kenelle tämä sopii

• Markkinoijille, jotka tarvitsevat kilpailijakanavien dataa mutta eivät koodaa
• Kehittäjille, jotka haluavat nopean datapullin ilman virtuaaliympäristön ja riippuvuuksien asennusta
• Kaikille, jotka törmäävät anti-bot-muureihin — Thunderbit kaapii käyttäjän omassa kirjautuneessa selainistunnossa, jolloin se perii evästeesi ja PO-tokenisi. Tämä ohittaa monia serveripuolen kaapijoiden kohtaamia blokkeja
• Thunderbit voi käyttää myös vieraillakseen jokaisella videosivulla ja rikastaa taulukkoa lisätiedoilla (tykkäykset, kuvaus, tagit)

Syvempi katsaus siihen, miten Thunderbit käsittelee YouTubea, löytyy ja .

Vinkkejä YouTuben kaapimiseen Pythonilla ilman estoa

Nämä vinkit pätevät kaikkiin neljään Python-menetelmään. YouTuben anti-bot-suojaukset arvioidaan , ja kolme pääsignaalia ovat: IP:n käyttäytymisanalyysi, JS-suoritusvaatimukset ja usein muuttuva HTML-rakenne.

Kaikille menetelmille:

• Kierrätä User-Agent-otsakkeita ja koko header-settiä — Accept, Accept-Language, Sec-CH-UA-asiakastiedot täytyy täsmätä ilmoitetun UA:n kanssa. sisältää ajantasaisen listan.
• Lisää satunnaiset 2–8 sekunnin viiveet pyyntöjen väliin. Tasaväliset pyynnöt ovat tunnistussignaali.
• Käytä residential-proxyja kaikkeen, mikä ylittää muutaman sivun. Datakeskus-IP:t (AWS, GCP, Hetzner) ovat .
• Kierrätä sessio ja IP yhdessä — YouTube sitoo sessiot IP-osoitteeseen, ja sama sessioeväste kahdessa eri IP:ssä on punainen lippu.

requests + BS4: Aseta CONSENT=YES+cb-eväste. Ilman sitä EU-pyynnöt ohjautuvat suostumussivulle, jossa ei ole dataa.

Selenium/Playwright: Aja näkyvää selainta xvfb:n kanssa Linux-palvelimilla mieluummin kuin --headless=new-tilassa — headless Chrome jättää edelleen tarpeeksi sormenjälkiä kehittyneille tunnistimille. Harkitse , joka lisää noin 17 kiertoa.

yt-dlp: Käytä sleep_interval- ja max_sleep_interval-asetuksia. Asenna -lisäosa PO-tokenien luontiin. Käytä --cookies-from-browser chrome -asetusta kertakäyttöisellä tilillä.

API: Seuraa kiintiön käyttöä ja eräytä pyynnöt tehokkaasti. Yksi videos.list-kutsu 50 pilkulla erotetulla ID:llä maksaa 1 yksikön — käytä sitä.

Thunderbit: Anti-bot-suojaukset hoidetaan automaattisesti, koska kaavinta tapahtuu omassa selainistunnossasi. Automatisoit käytännössä vain sen, mitä tekisit käsin.

Onko YouTuben kaapiminen Pythonilla laillista?

Se riippuu siitä, mitä kaavit, miten kaavit ja mitä teet datalla.

Oikeudellinen tilanne muuttui vuonna 2024 tapauksessa Meta Platforms v. Bright Data (N.D. Cal., tammikuu 2024), jossa . Julkisesti saatavilla olevan datan kaapiminen muuttui tämän jälkeen "merkittävästi vähemmän riskialttiiksi". Toisaalta hiQ v. LinkedIn päättyi käyttöehtojen rikkomisesta, CFAA-rikkomuksista (valetilit) ja irtaimen vahingoittamisesta — sekä pysyvään kielto-oikeuteen.

YouTuben omat ovat yksiselitteiset: "Et saa käyttää palvelua automatisoiduin keinoin (kuten robotit, botnetit tai scraperit)" ilman etukäteistä kirjallista lupaa tai sovellettavan lain sallimana. YouTube Data API on virallisesti hyväksytty tapa käyttää dataa.

Muutama käytännön nyrkkisääntö:

• Julkisesti näkyvän datan kaapiminen henkilökohtaista tutkimusta tai ei-kaupallista analyysiä varten on yleensä matalamman riskin toimintaa
• API on turvallisin reitti — se on nimenomaisesti valtuutettu
• Vältä yksityisen/sisäänkirjautumisen takana olevan sisällön kaapimista, tekijänoikeudella suojattujen videoiden lataamista edelleen ja GDPR-rikkomuksia, jos käsittelet kommenttien henkilötietoja
• YouTube-kommentit sisältävät GDPR:n 4 artiklan 1 kohdan mukaista henkilötietoa — käsittele EU-alueen rekisteröityjen tietoja huolellisesti
• Kysy oikeudellista neuvontaa kaupallisissa kaavintaprojekteissa

Tämä ei ole oikeudellista neuvontaa. Tilanne muuttuu nopeasti — uusi aalto , jotka kaapivat YouTube-dataa koulutusdataa varten, muokkaa kenttää vuosina 2025–2026.

Minkä menetelmän valitset YouTuben kaapimiseen Pythonilla?

Päätösohje:

• Tarvitsetko nopeaa metatietoa muutamalta sivulta? → Menetelmä 1 (requests + BS4). Nopea, kevyt, ei muita riippuvuuksia kuin requests ja beautifulsoup4.
• Tarvitsetko hakutulosten kaapimista tai vuorovaikutusta dynaamisten sivujen kanssa? → Menetelmä 2 (Selenium/Playwright). Täysi selainrenderöinti, tuki äärettömälle vieritykselle, mutta hidas ja tunnistusalttiimpi.
• Tarvitsetko massamääräistä metatietoa, kommentteja tai transkriptioita? → Menetelmä 3 (yt-dlp). Kyvykkäin yksittäinen työkalu — syystä.
• Tarvitsetko strukturoitua, luotettavaa dataa keskisuuressa mittakaavassa? → Menetelmä 4 (YouTube Data API). Virallinen, siisti, mutta -kiintiön rajoittama.
• Tarvitsetko dataa kahdessa minuutissa ilman koodausta? → . Selainpohjainen, AI-avusteinen, vie Google Sheetiin klikkauksilla.

Mikään yksittäinen menetelmä ei kata kaikkia käyttötapauksia. Lisää kirjanmerkkeihin yllä oleva vertailutaulukko ja poimittavien kenttien referenssi — ne säästävät aikaa seuraavassa projektissasi. Ja jos haluat tutkia lisää , Thunderbit-blogissa on runsaasti oppaita aina .

UKK

Voinko kaapia YouTubea ilman API-avainta?

Kyllä. Menetelmät 1 (requests + BS4), 2 (Selenium/Playwright) ja 3 (yt-dlp) eivät vaadi API-avainta. Vain menetelmä 4 (YouTube Data API) tarvitsee sellaisen. Thunderbit toimii myös ilman API-avainta — se kaapii suoraan selaimessasi.

Mikä on nopein tapa kaapia YouTubea Pythonilla?

Pythonin puolella yt-dlp ja requests + BS4 ovat nopeimpia — molemmat ohittavat selainylikuorman ja voivat hakea metatiedot sekunneissa per video. yt-dlp on erityisen nopea eräajoissa, koska se hoitaa sivutuksen sisäisesti. Ei-Python-käyttäjille Thunderbit on kokonaisuutena nopein, koska käyttöönottoa ei käytännössä ole.

Miten kaavin YouTube-kommentteja Pythonilla?

yt-dlp:ssä on sisäänrakennettu kommenttien poiminta getcomments-asetuksella — se on yksinkertaisin reitti. YouTube Data API tukee myös kommentteja commentThreads.list-metodilla (1 kiintiöyksikkö per kutsu, enintään 100 kommenttia per sivu). Selenium/Playwrightilla se onnistuu teknisesti vierittämällä ja poimimalla renderöidyt kommenttielementit, mutta se on hidasta ja haavoittuvaa.

Voinko kaapia YouTube Shorts -sisältöä Pythonilla?

Kyllä. yt-dlp käsittelee Shorts-metadataa hyvin — se näkee ne tavallisina videoina, joilla on lisäksi Shorts-kohtaisia kenttiä. YouTube Data API:lla on osittainen tuki (Shorts-katselukertojen laskenta — katselukerta lasketaan nyt jokaisesta toistokerran aloituksesta/uudelleentoistosta). BS4:llä ja Selenium/Playwrightilla Shorts-tuki on rajallinen, koska Shorts-hylly käyttää eri DOM-rakenteita.

Kuinka monta YouTube-videota voin kaapia päivässä?

YouTube Data API:lla raja on noin 10 000 kiintiöyksikköä päivässä. Kun käytät eräytettyjä videos.list-kutsuja (50 ID:tä per kutsu, 1 yksikkö), se tarkoittaa jopa 500 000 videon statushakua päivässä — mutta search.list vie 100 yksikköä per kutsu, joten budjetti hupenee nopeasti. Kaavintamenetelmissä (BS4, Selenium, yt-dlp) raja on käytännöllinen eikä kovakoodattu: IP-estot alkavat tyypillisesti muutaman sadan tai muutaman tuhannen pyynnön jälkeen per IP per päivä, riippuen proxy-setupista ja pyyntötavoista. Thunderbit käyttää pistepohjaista järjestelmää, joka sidotaan .

Lue lisää