Scrape YouTube w Pythonie: 4 metody, które naprawdę działają

Jeśli kiedykolwiek próbowałeś czegoś w stylu requests.get("https://www.youtube.com/...") i potem analizowałeś wynik w BeautifulSoup, szukając tytułów filmów, to znasz już finał: dostajesz ścianę pustych tagów <div> i dokładnie zero sensownych danych.

To najczęstsza frustracja, jaką widzę u programistów, którzy po raz pierwszy próbują pobierać dane z YouTube. YouTube to aplikacja typu single-page application — prawie wszystko renderuje po stronie klienta za pomocą JavaScriptu. HTML, który dostaje Twój skrypt Python, to tylko skorupa. Prawdziwe tytuły filmów, liczby wyświetleń i metadane? Są schowane w ogromnym obiekcie JSON o nazwie ytInitialData, który JavaScript wstrzykuje po załadowaniu strony.

Dlatego Twoje całkiem logiczne soup.find("div", class_="ytd-video-renderer") zwraca None, bo taki element dosłownie nie istnieje w surowej odpowiedzi HTTP. Gdy to zrozumiałem, wszystko nagle zaczęło mieć sens — a cztery metody poniżej są efektem wielu testów, połamanych prób i przekopywania się przez zbyt wiele wątków na GitHubie. Przeprowadzę Cię przez każde podejście, pokażę dokładnie, kiedy którego użyć, a na końcu dorzucę też rozwiązanie bez kodowania dla osób, które po prostu chcą dane bez całej konfiguracji projektu.

Dlaczego w ogóle scrapować YouTube w Pythonie?

YouTube to nie tylko platforma wideo — to kopalnia danych dla . Przy i mamy do czynienia z ogromną ilością publicznie widocznych informacji, które firmy, badacze i twórcy chcą analizować automatycznie.

Problem w tym, że wbudowana analityka YouTube pokazuje dane tylko dla Twojego kanału. Jeśli chcesz sprawdzić częstotliwość publikacji konkurencji, śledzić gorące tematy w swojej niszy albo analizować sentyment odbiorców na podstawie komentarzy pod cudzymi filmami, musisz scrapować dane.

Oto najczęstsze realne zastosowania, które widzę:

Przykładowo, analiza konkurencyjna DJI vs. GoPro vs. Insta360 pokazała, że — takich wniosków nie widać z poziomu YouTube Studio.

Dlaczego samo requests + BeautifulSoup nie wystarczy do scrapowania YouTube

Zanim przejdziemy do metod, które działają, musisz zrozumieć dlaczego oczywiste podejście zawodzi. To nie jest teoria akademicka — oszczędzi Ci godzin debugowania.

„Oczywista” metoda wygląda mniej więcej tak:

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 — za każdym razem

Wynik jest zawsze zerowy. Jak pisze : „Strona została wczytana dynamicznie, a requests tego nie obsługuje”. mówi wprost: „Samo requests i BeautifulSoup nie potrafią wykonać JavaScriptu”.

wyjaśnia mechanizm: YouTube działa jako Single Page Application (SPA). Przy zwykłych żądaniach HTTP dostajesz tylko początkową powłokę HTML — właściwa treść nie została jeszcze wyrenderowana. Dane wideo są ukryte w obiektach JavaScript, które przeglądarka normalnie wykonuje i wstrzykuje do DOM.

Dobra wiadomość: YouTube naprawdę umieszcza wszystkie potrzebne dane w surowym HTML. Po prostu nie są one w elementach DOM, tylko w dwóch blokach JSON wewnątrz tagów <script>:

• ytInitialData — struktura strony, listy filmów, metryki zaangażowania, tokeny do kontynuacji komentarzy
• ytInitialPlayerResponse — podstawowe metadane filmu (tytuł, opis, czas trwania, formaty, napisy)

Oba są dostępne przez jedno requests.get() — bez przeglądarki — jeśli wiesz, jak je wyciągnąć i sparsować. To właśnie będzie Metoda 1.

4 sposoby na scrapowanie YouTube w Pythonie: porównanie obok siebie

Zanim przejdziemy do każdej metody, oto tabela decyzyjna. Przetestowałem wszystkie cztery podejścia i porównałem je pod kątem kryteriów, które naprawdę mają znaczenie przy wyborze narzędzia do prawdziwego projektu.

Szybkie podsumowanie:

Jakie dane z YouTube możesz faktycznie wyciągnąć — i którą metodą?

To jest tabela referencyjna, którą chciałem mieć, kiedy zaczynałem. Żadna pojedyncza metoda nie pokrywa wszystkich pól — właśnie dlatego ten artykuł opisuje cztery.

Wybierz metodę w zależności od tego, które wiersze są dla Ciebie najważniejsze. Jeśli potrzebujesz komentarzy i transkrypcji, yt-dlp jest wyraźnym zwycięzcą. Jeśli potrzebujesz ustrukturyzowanych statystyk na średnią skalę, API będzie najlepszym wyborem. Jeśli potrzebujesz danych w dwie minuty, czytaj dalej sekcję o Thunderbit.

Metoda 1: Scrapowanie YouTube w Pythonie przez requests + BeautifulSoup (parsowanie ytInitialData)

Ta metoda wykorzystuje fakt, że YouTube osadza wszystkie dane strony jako JSON wewnątrz surowego HTML. Nie potrzebujesz przeglądarki — potrzebujesz tylko wiedzieć, gdzie szukać.

• Poziom trudności: początkujący
• Czas potrzebny: około 15 minut
• Czego potrzebujesz: Python 3.10+, requests, beautifulsoup4

Krok 1: Wyślij żądanie GET do strony YouTube

Wyślij żądanie z realistycznym nagłówkiem User-Agent. Domyślny nagłówek python-requests/2.x bywa od razu blokowany — potwierdza, że to najczęstsza pułapka dla początkujących.

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",  # omija ekran zgody w UE
8}
9url = "https://www.youtube.com/@mkbhd/videos"
10response = requests.get(url, headers=HEADERS)
11print(response.status_code)  # powinno być 200

Cookie CONSENT jest kluczowe — bez niego żądania z regionu UE są przekierowywane do consent.youtube.com, które zwraca HTML bez ytInitialData.

Krok 2: Sparsuj HTML i znajdź skrypt ytInitialData

Użyj BeautifulSoup albo regexa, aby znaleźć tag <script> zawierający var ytInitialData =:

1import re
2import json
3# Wyciągnięcie JSON-a ytInitialData
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 zostało poprawnie wyciągnięte")
12else:
13    print("Nie znaleziono ytInitialData — sprawdź nagłówki/cookies")

Częsty błąd: używanie niedoskonałego, niechciwego .*? z samym }; jako znacznikiem końca. W JSON-ie bardzo często pojawiają się zagnieżdżone zamknięcia obiektów, przez co dopasowanie urwie się za wcześnie. Użyj };</script>, tak jak robi to — to ostatnie przypisanie w jego własnym bloku skryptu.

Krok 3: Przejdź przez strukturę JSON i wyciągnij dane wideo

JSON jest mocno zagnieżdżony. Zamiast sztywno wpisywać ścieżki, które psują się za każdym razem, gdy YouTube przestawia strukturę (co zdarza się regularnie — dokumentuje kilka zmian formatu od 2023 roku), użyj rekurencyjnego wyszukiwania po kluczu:

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# Wyciąganie informacji o filmach z kanału
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"Znaleziono {len(videos)} filmów")
23for v in videos[:5]:
24    print(f"  {v['title']} — {v['views']}")

To podejście rekurencyjne jest tym, do czego doszły , yt-dlp i Scrapfly — dobrze znosi częste zmiany struktury JSON-a w YouTube.

Krok 4: Eksportuj dane do CSV lub Excela

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("Dane wyeksportowano do youtube_videos.csv")

Kiedy użyć tej metody, a kiedy nie

Najlepsza do: szybkiego pobierania metadanych z kilku stron kanału lub pojedynczych filmów. Lekkich narzędzi SEO. Jednorazowych analiz, w których potrzebujesz tytułu, wyświetleń i daty publikacji.

Ograniczenia: Struktura JSON się zmienia — znane przypadki obejmują przebudowę przycisku polubień (2023: toggleButtonRenderer → segmentedLikeDislikeButtonViewModel), refaktor opisu (2023: description.runs[] → attributedDescription.content) oraz redesign zakładki Videos na kanale (2022–2023: gridRenderer → richGridRenderer). IP z centrów danych zwykle są miękko blokowane po 50–200 żądaniach. Brak komentarzy, brak transkrypcji.

Metoda 2: Scrapowanie YouTube w Pythonie z Selenium lub Playwright

Gdy musisz wchodzić w interakcję ze stroną — przewijać wyniki wyszukiwania, klikać zakładki, rozwijać opisy — automatyzacja przeglądarki jest właściwym rozwiązaniem.

• Poziom trudności: średnio zaawansowany
• Czas potrzebny: około 30 minut
• Czego potrzebujesz: Python 3.10+, Playwright (pip install playwright && playwright install) albo Selenium + ChromeDriver

Do nowych projektów polecam Playwright zamiast Selenium. pokazują, że Playwright działa mniej więcej niż Selenium. Playwright używa trwałego WebSocketu przez Chrome DevTools Protocol, podczas gdy Selenium działa przez WebDriver po HTTP, dodając warstwę tłumaczenia dla każdej komendy.

Krok 1: Skonfiguruj Playwright

1pip install playwright
2playwright install chromium

1from playwright.sync_api import sync_playwright
2pw = sync_playwright().start()
3browser = pw.chromium.launch(headless=False)  # tryb z interfejsem zmniejsza część detekcji
4context = browser.new_context()
5# Ustaw cookie zgody, aby ominąć ekran UE
6context.add_cookies([{
7    "name": "SOCS",
8    "value": "CAISNQgDEitib3FfaWRlbnRpdHlmcm9udGVuZHVpc2VydmVyXzIwMjMwODI5LjA3X3AxGgJlbiACGgYIgJnPpwY",
9    "domain": ".youtube.com",
10    "path": "/",
11}])
12page = context.new_page()

Krok 2: Wejdź na stronę YouTube i poczekaj na załadowanie treści

1page.goto("https://www.youtube.com/@mkbhd/videos")
2page.wait_for_selector("a#video-title-link", timeout=15000)
3print("Strona załadowana — elementy wideo są widoczne")

Jeśli scrapujesz wyniki wyszukiwania, zamiast tego przejdź na https://www.youtube.com/results?search_query=twoje+zapytanie.

Krok 3: Obsłuż nieskończone przewijanie, aby załadować więcej filmów

YouTube używa nieskończonego przewijania na stronach kanałów i wyników wyszukiwania. Oto klasyczna pętla scrollHeight, zaadaptowana z :

1prev_height = -1
2max_scrolls = 20  # ogranicz to — kanał z 10 tys. filmów będzie przewijał się bez końca
3scroll_count = 0
4while scroll_count < max_scrolls:
5    page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
6    page.wait_for_timeout(1500)  # poczekaj, aż załaduje się nowa treść
7    new_height = page.evaluate("document.body.scrollHeight")
8    if new_height == prev_height:
9        break  # nie załadowano nowej treści
10    prev_height = new_height
11    scroll_count += 1
12print(f"Przewinięto {scroll_count} razy")

Krok 4: Wyciągnij dane wideo z wyrenderowanej strony

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"Wyodrębniono {len(videos)} filmów")

Aby pobrać liczbę wyświetleń i daty publikacji, trzeba sięgnąć po sąsiednie elementy. ostrzega, że id="video-title-link" nie jest uniwersalne — YouTube stosuje kilka wariantów strony. Bezpiecznym fallbackiem jest a[href*="watch"].

Krok 5: Eksport do CSV lub 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()

Kiedy użyć tej metody, a kiedy nie

Najlepsza do: scrapowania wyników wyszukiwania, pracy z dynamicznymi elementami strony (klikaniem zakładek, rozwijaniem opisów), wszystkiego, co wymaga w pełni wyrenderowanego DOM-u.

Ograniczenia: Wolne działanie (~1,5–3 sekundy na film w przepływie przewijanie + ekstrakcja). Wysokie ryzyko wykrycia anty-bot — zwykły Selenium ustawia navigator.webdriver === true, co . Duże zużycie zasobów (każda instancja przeglądarki zajmuje 200–500 MB RAM). Dla 100 filmów licz od 3 do 8 minut zamiast sekund, jak w yt-dlp.

Metoda 3: Scrapowanie YouTube w Pythonie z użyciem yt-dlp

yt-dlp to szwajcarski scyzoryk do scrapowania YouTube. To społecznościowy fork youtube-dl z , aktywnymi nightly release’ami oraz wbudowaną obsługą metadanych, komentarzy, transkrypcji i masowego scrapowania — bez potrzeby używania przeglądarki czy klucza API.

• Poziom trudności: początkujący do średnio zaawansowanego
• Czas potrzebny: około 10 minut
• Czego potrzebujesz: Python 3.10+, pip install yt-dlp

Krok 1: Zainstaluj yt-dlp

1pip install yt-dlp

Bez sterowników przeglądarki, bez kluczy API, bez plików konfiguracyjnych.

Krok 2: Pobierz metadane filmu bez pobierania samego wideo

1import yt_dlp
2opts = {
3    "quiet": True,
4    "skip_download": True,      # brak bajtów wideo — tylko metadane
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"Tytuł: {info['title']}")
13print(f"Wyświetlenia: {info['view_count']:,}")
14print(f"Polubienia: {info.get('like_count', 'N/A')}")
15print(f"Czas trwania: {info['duration']}s")
16print(f"Data publikacji: {info['upload_date']}")
17print(f"Kanał: {info['channel']} ({info.get('channel_follower_count', 'N/A')} subskrypcji)")
18print(f"Tagi: {info.get('tags', [])[:5]}")

Typowe wywołanie extract_info zwraca 80–120 pól, zależnie od stanu filmu: 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 i wiele więcej.

Krok 3: Pobierz komentarze z filmu YouTube

1opts = {
2    "quiet": True,
3    "skip_download": True,
4    "getcomments": True,
5    "extractor_args": {
6        "youtube": {
7            "max_comments": ["200", "50", "50", "10"],  # łącznie, rodzice, odpowiedzi na komentarz, odpowiedzi łącznie
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"Pobrano {len(comments)} komentarzy")
19for c in comments[:3]:
20    print(f"  [{c.get('like_count', 0)} polubień] {c['author']}: {c['text'][:80]}...")

Ekstrakcja komentarzy jest wolna. raportuje pobieranie komentarzy z prędkością ok. 30 KB/s — film z 100 tys. komentarzy może pobierać się godzinami. opisuje filmy, w których adresy URL formatów wygasają (~6 godzin) zanim zakończy się paginacja komentarzy. Przy dużych filmach ustaw max_comments bardzo agresywnie.

Krok 4: Pobierz transkrypcje i napisy

Ani YouTube Data API, ani parsowanie BS4 nie da Ci pełnych transkrypcji. To unikalna przewaga yt-dlp.

1opts = {
2    "quiet": True,
3    "skip_download": True,
4    "writesubtitles": True,
5    "writeautomaticsub": True,
6    "subtitleslangs": ["en", "en-orig"],
7    "subtitlesformat": "json3",   # przyjazne dla maszyn: start/dur w ms + tekst
8    "outtmpl": "%(id)s.%(ext)s",
9}
10with yt_dlp.YoutubeDL(opts) as ydl:
11    info = ydl.extract_info(
12        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
13        download=False
14    )
15# Dostęp do danych napisów bezpośrednio z dict info
16auto_captions = info.get("automatic_captions", {})
17manuall_subs = info.get("subtitles", {})
18print(f"Języki automatycznych napisów: {list(auto_captions.keys())[:10]}")
19print(f"Języki ręcznych napisów: {list(manuall_subs.keys())}")

Format json3 jest preferowany do parsowania maszynowego — każdy segment ma start/dur w milisekundach oraz fragmenty tekstu. Kody języków to BCP-47 (en, en-US, zh-Hans, ja, es).

Krok 5: Masowe pobieranie wielu filmów lub całego kanału

1opts = {
2    "quiet": True,
3    "skip_download": True,
4    "extract_flat": "in_playlist",  # szybko — tylko ID filmów i tytuły
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"Na kanale znaleziono {len(entries)} filmów")
15for e in entries[:5]:
16    print(f"  {e.get('title', 'N/A')} — {e.get('id')}")

Przekaż URL kanału, URL playlisty albo nawet zapytanie wyszukiwania (ytsearch10:python scraping), a yt-dlp sam obsłuży paginację.

Kiedy użyć tej metody, a kiedy nie

Najlepsza do: masowego pobierania metadanych, komentarzy, transkrypcji, pobierania filmów, scrapowania całych kanałów, gdy potrzebujesz pełnego zestawu pól.

Ograniczenia: nie jest idealna do scrapowania stron wyników wyszukiwania (tu lepszy jest Selenium/Playwright). Wyścig anty-bot z lat 2024–2026 sprawił, że uruchamianie yt-dlp na dużą skalę stało się bardziej złożone — YouTube egzekwuje teraz na niektórych klientach . W produkcji zainstaluj wtyczkę i używaj --cookies-from-browser chrome (na testowym koncie — zespół yt-dlp ostrzega, że cookies z prawdziwego konta Google mogą doprowadzić do jego bana).

Metoda 4: Scrapowanie YouTube w Pythonie przez YouTube Data API

Oficjalne YouTube Data API v3 to najbardziej niezawodny i najbardziej ustrukturyzowany sposób pobierania danych z YouTube. Odpowiedzi są czystym JSON-em, pola są udokumentowane i nie ma gry w kotka i myszkę z anty-botami. Jest jednak haczyk, który większość poradników pomija: system quota.

• Poziom trudności: średnio zaawansowany
• Czas potrzebny: około 20 minut (wraz z konfiguracją klucza API)
• Czego potrzebujesz: Python 3.10+, projekt w Google Cloud, pip install google-api-python-client

Krok 1: Zdobądź klucz YouTube Data API

1. Wejdź do
2. Utwórz nowy projekt (lub wybierz istniejący)
3. Przejdź do APIs & Services → Library → wyszukaj „YouTube Data API v3” → Enable
4. Wejdź do APIs & Services → Credentials → Create Credentials → API Key
5. Skopiuj klucz — użyjesz go w kodzie poniżej

Krok 2: Wykonaj pierwsze wywołanie API

1from googleapiclient.discovery import build
2API_KEY = "YOUR_API_KEY_HERE"
3youtube = build("youtube", "v3", developerKey=API_KEY)
4# Pobranie szczegółów konkretnego filmu
5response = youtube.videos().list(
6    part="snippet,statistics,contentDetails",
7    id="dQw4w9WgXcQ"
8).execute()
9video = response["items"][0]
10print(f"Tytuł: {video['snippet']['title']}")
11print(f"Wyświetlenia: {video['statistics']['viewCount']}")
12print(f"Polubienia: {video['statistics'].get('likeCount', 'ukryte')}")
13print(f"Komentarze: {video['statistics'].get('commentCount', 'wyłączone')}")
14print(f"Czas trwania: {video['contentDetails']['duration']}")
15print(f"Tagi: {video['snippet'].get('tags', [])[:5]}")

Odpowiedź jest czysta, typowana i udokumentowana. Bez archeologii JSON-owej.

Krok 3: Pobierz szczegóły filmu, informacje o kanale i komentarze

1# Wyszukiwanie filmów
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# Pobieranie komentarzy
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']} polubień] {comment['authorDisplayName']}: {comment['textDisplay'][:80]}")

Rzeczywistość quota YouTube API (tego nikt nie mówi)

To jest sekcja, która odróżnia użyteczny poradnik od tutoriala do kopiuj-wklej. Domyślny przydział to , resetowanych o północy czasu pacyficznego. Oto koszt poszczególnych wywołań:

Teraz matematyka. Załóżmy, że chcesz scrapować 1000 wyników wyszukiwania:

• Wywołania wyszukiwania: 1000 wyników ÷ 50 na stronę = 20 wywołań × 100 jednostek = 2000 jednostek (20% dziennego budżetu — i znika)
• Szczegóły filmów dla tych 1000 wyników: 1000 ID ÷ 50 w paczce = 20 wywołań × 1 jednostka = 20 jednostek (tanio — videos.list w paczce to prawdziwy ratunek)
• Komentarze dla tych 1000 filmów (zakładając 1 stronę na film): 1000 wywołań × 1 jednostka = 1000 jednostek

Razem: około 3020 jednostek dla umiarkowanego scrapingu. Ale jeśli te filmy mają rozbudowane wątki komentarzy (50+ stron każdy), bardzo szybko zużyjesz pozostałe 7000 jednostek. Film z 50 000 komentarzy = około 500 stron = 500 jednostek. Scrapujesz 20 takich filmów i limit dnia się kończy.

Proces wymaga pełnego audytu zgodności: URL polityki prywatności, URL regulaminu, wideo pokazującego działanie aplikacji, uzasadnienie matematyki quota. Z raportów społeczności wynika, że typowa odpowiedź Google trwa 3–5 dni roboczych, pełna akceptacja może zająć tygodnie lub miesiące, a wiele wniosków zostaje odrzuconych — szczególnie w przypadkach typu „chcę więcej danych do analizy”.

Kiedy używać API: na małą i średnią skalę, gdy potrzebujesz ustrukturyzowanych i wiarygodnych danych, gdy liczą się komentarze i statystyki kanału, i gdy możesz zaakceptować limit quota.

Kiedy scraping ma większy sens: projekty na dużą skalę (>10 tys. filmów dziennie), pola, których API nie udostępnia (pełne transkrypcje — captions.download wymaga OAuth i uprawnień właściciela filmu), albo gdy potrzebujesz więcej niż 500 wyników wyszukiwania na jedno zapytanie (twardy limit API, niezależnie od deklarowanego totalResults).

Szybka ścieżka bez kodu: scrapowanie YouTube z Thunderbit (bez Pythona)

Jeśli potrzebujesz Pythona do pipeline’u danych, użyj powyższych metod 1–4. Ale jeśli chcesz dane z YouTube w 2 minuty — być może jesteś marketerem zbierającym statystyki konkurencji albo developerem, który chce po prostu szybki eksport bez konfigurowania środowiska — istnieje szybsza droga.

to rozszerzenie do Chrome oparte na AI, stworzone właśnie na takie sytuacje, gdy pisanie kodu to przesada. Działa bezpośrednio na stronach YouTube w Twojej przeglądarce.

Jak scrapować YouTube z Thunderbit w 3 krokach

Krok 1: Zainstaluj i otwórz stronę kanału YouTube, stronę wyników wyszukiwania albo stronę filmu.

Krok 2: Kliknij „AI Suggest Fields” w panelu bocznym Thunderbit. AI odczyta stronę i zasugeruje kolumny, takie jak tytuł filmu, wyświetlenia, data publikacji, czas trwania, nazwa kanału i URL miniatury. Możesz dodawać, usuwać lub zmieniać nazwy kolumn według potrzeb.

Krok 3: Kliknij „Scrape” i wyeksportuj dane do Google Sheets, Excela, CSV, Airtable lub Notion. Dane trafiają do czystej tabeli, gotowej do użycia.

Dla kogo to jest

• Marketerzy, którzy potrzebują danych z kanałów konkurencji, ale nie kodują
• Developerzy, którzy chcą szybki eksport danych bez tworzenia virtual environment i instalowania zależności
• Każdy, kto wpada na ściany anty-bot — Thunderbit scrapuje w Twojej zalogowanej sesji przeglądarki, więc dziedziczy cookies i PO tokens. Omija to wiele problemów blokad, które nękają scrapery po stronie serwera
• Thunderbit może też używać , aby wejść na każdą stronę filmu i wzbogacić tabelę o dodatkowe szczegóły (liczba polubień, opis, tagi)

Jeśli chcesz głębiej zobaczyć, jak Thunderbit radzi sobie konkretnie z YouTube, sprawdź oraz .

Jak scrapować YouTube w Pythonie, żeby nie zostać zablokowanym

Te wskazówki dotyczą wszystkich czterech metod w Pythonie. Mechanizmy anty-bot YouTube są oceniane jako , a działają głównie na trzech sygnałach: analizie zachowania IP, wymaganiu wykonywania JS oraz często zmieniającej się strukturze HTML.

Dla wszystkich metod:

• Rotuj nie tylko User-Agent, ale cały zestaw nagłówków — Accept, Accept-Language, Sec-CH-UA muszą zgadzać się z deklarowanym UA. Aktualną listę znajdziesz w .
• Dodawaj losowe opóźnienia 2–8 sekund między żądaniami. Stałe odstępy to sygnał detekcyjny.
• Używaj proxy residential przy czymkolwiek większym niż kilka stron. IP z centrów danych (AWS, GCP, Hetzner) są .
• Rotuj jednocześnie sesję i IP — YouTube wiąże sesje z IP, więc ten sam cookie sesyjny na dwóch różnych IP to czerwona flaga.

Dla requests + BS4: ustaw cookie CONSENT=YES+cb. Bez niego żądania z UE zostają przekierowane na stronę zgody bez danych.

Dla Selenium/Playwright: uruchamiaj w trybie z interfejsem z xvfb na serwerach Linux zamiast --headless=new — headless Chrome nadal ujawnia wystarczająco dużo fingerprintów, by zaawansowane detektory mogły go rozpoznać. Rozważ , które stosuje około 17 obejść.

Dla yt-dlp: używaj opcji sleep_interval i max_sleep_interval. Zainstaluj wtyczkę do generowania PO Tokenów. Korzystaj z --cookies-from-browser chrome na testowym koncie.

Dla API: monitoruj wykorzystanie quota w i efektywnie grupuj żądania. Jedno wywołanie videos.list z 50 ID oddzielonymi przecinkami kosztuje 1 jednostkę — wykorzystuj to.

Dla Thunderbit: mechanizmy anty-bot są obsługiwane automatycznie, bo scrapowanie odbywa się w Twojej sesji przeglądarki. W praktyce automatyzujesz po prostu to, co robiłbyś ręcznie.

Czy scrapowanie YouTube w Pythonie jest legalne?

To zależy od tego, co scrapujesz, jak to robisz i co potem robisz z tymi danymi.

Sytuacja prawna zmieniła się w 2024 roku wraz ze sprawą Meta Platforms v. Bright Data (N.D. Cal., styczeń 2024), gdzie . Dostęp do publicznie dostępnych danych stał się po tym wyroku „znacznie mniej ryzykowny”. Z drugiej strony, sprawa hiQ v. LinkedIn zakończyła się wyrokiem za naruszenie ToS, naruszenia CFAA (fałszywe konta) i trespass to chattels — plus stały zakaz sądowy.

Własne są jednoznaczne: „Nie wolno Ci korzystać z usługi przy użyciu automatycznych środków (takich jak roboty, botnety lub scrapery)” — chyba że masz wcześniejszą pisemną zgodę albo pozwala na to obowiązujące prawo. YouTube Data API to oficjalnie zatwierdzona droga dostępu do danych.

Kilka praktycznych zasad:

• Scrapowanie publicznie widocznych danych do badań osobistych lub analizy niekomercyjnej jest zwykle mniej ryzykowne
• API to najbezpieczniejsza ścieżka — jest wprost autoryzowane
• Unikaj scrapowania treści prywatnych / za ekranem logowania, pobierania chronionych prawem autorskim filmów do dalszej dystrybucji oraz naruszania GDPR przez dane osobowe z komentarzy
• Komentarze YouTube zawierają dane osobowe w rozumieniu GDPR art. 4(1) — informacje o osobach z UE należy przetwarzać ostrożnie
• W projektach komercyjnych skonsultuj się z prawnikiem

To nie jest porada prawna. Sytuacja zmienia się szybko — nowa fala pozwów , które scrapowały YouTube do danych treningowych, przekształca ten obszar w latach 2025–2026.

Którą metodę wybrać do scrapowania YouTube w Pythonie?

Przewodnik decyzyjny:

• Potrzebujesz szybkich metadanych z kilku stron? → Metoda 1 (requests + BS4). Szybka, lekka, bez zależności poza requests i beautifulsoup4.
• Chcesz scrapować wyniki wyszukiwania albo interakcje z dynamicznymi stronami? → Metoda 2 (Selenium/Playwright). Pełne renderowanie przeglądarki, obsługa nieskończonego scrollowania, ale wolna i podatna na wykrycie.
• Potrzebujesz masowych metadanych, komentarzy albo transkrypcji? → Metoda 3 (yt-dlp). Najbardziej wszechstronne pojedyncze narzędzie — nie bez powodu ma .
• Potrzebujesz ustrukturyzowanych, niezawodnych danych na średnią skalę? → Metoda 4 (YouTube Data API). Oficjalna, czysta, ale ograniczona quota do .
• Potrzebujesz danych w 2 minuty bez pisania kodu? → . Oparte na przeglądarce, z AI, eksport do Google Sheets kilkoma kliknięciami.

Żadna metoda nie pokrywa wszystkich przypadków użycia. Zapisz sobie tabelę porównawczą i tabelę pól danych powyżej — zaoszczędzą Ci czasu przy następnym projekcie. A jeśli chcesz poznać więcej , na blogu Thunderbit mamy mnóstwo poradników, od po .

FAQ

Czy mogę scrapować YouTube bez klucza API?

Tak. Metody 1 (requests + BS4), 2 (Selenium/Playwright) i 3 (yt-dlp) nie wymagają klucza API. Tylko Metoda 4 (YouTube Data API) go potrzebuje. Thunderbit również działa bez żadnego klucza API — scrapuje bezpośrednio w Twojej przeglądarce.

Jaki jest najszybszy sposób scrapowania YouTube w Pythonie?

W Pythonie najszybsze są yt-dlp i requests + BS4 — oba omijają narzut przeglądarki i potrafią pobierać metadane w kilka sekund na film. yt-dlp jest szczególnie szybki przy operacjach wsadowych, bo sam obsługuje paginację. Dla osób spoza Pythona Thunderbit jest najszybszy ogólnie, bo nie wymaga żadnej konfiguracji.

Jak scrapować komentarze z YouTube w Pythonie?

yt-dlp ma wbudowaną ekstrakcję komentarzy przez opcję getcomments — to najprostsza ścieżka. YouTube Data API też obsługuje komentarze przez commentThreads.list (1 jednostka quota za wywołanie, do 100 komentarzy na stronę). Selenium/Playwright też da się do tego użyć, przewijając i wyciągając wyrenderowane elementy komentarzy, ale jest to wolne i kruche.

Czy mogę scrapować YouTube Shorts w Pythonie?

Tak. yt-dlp dobrze obsługuje metadane Shorts — traktuje je jak zwykłe filmy z dodatkowymi polami specyficznymi dla Shorts. YouTube Data API ma częściowe wsparcie (liczenie wyświetleń Shorts — views liczy teraz każde rozpoczęcie odtwarzania / ponowne odtworzenie). BS4 i Selenium/Playwright mają ograniczone wsparcie dla Shorts, ponieważ sekcja Shorts korzysta z innych struktur DOM.

Ile filmów z YouTube mogę scrapować dziennie?

W przypadku YouTube Data API jesteś ograniczony do około 10 000 jednostek quota dziennie. Przy batched videos.list (50 ID na wywołanie za 1 jednostkę) daje to nawet 500 000 odczytów statystyk filmów dziennie — ale search.list kosztujące 100 jednostek na wywołanie szybko zjada budżet. W metodach scrapujących (BS4, Selenium, yt-dlp) limit jest praktyczny, a nie zapisany na sztywno: blokady IP zwykle wchodzą po kilkuset do kilku tysięcy żądań dziennie na jedno IP, zależnie od proxy i wzorca ruchu. Thunderbit korzysta z systemu kredytów przypisanego do Twojego .

Dowiedz się więcej