Estrarre dati da YouTube con Python: 4 metodi che funzionano davvero

Se hai mai provato requests.get("https://www.youtube.com/...") e poi hai passato il risultato a BeautifulSoup alla ricerca dei titoli dei video, conosci già come va a finire: ti ritrovi davanti a una distesa di tag <div> vuoti e zero dati davvero utili.

È la frustrazione più comune che vedo tra gli sviluppatori che provano a estrarre dati da YouTube per la prima volta. YouTube è una single-page application: quasi tutto viene renderizzato lato client tramite JavaScript. L’HTML che riceve il tuo script Python è solo una struttura vuota. I titoli, il numero di visualizzazioni e i metadati reali? Sono nascosti in un enorme blocco JSON chiamato ytInitialData, che viene iniettato dal JS dopo il caricamento della pagina.

Quindi il tuo innocente soup.find("div", class_="ytd-video-renderer") restituisce None perché quell’elemento, nel response HTTP grezzo, semplicemente non esiste. Quando ho capito questo, il puzzle finalmente ha trovato il suo posto — e i quattro metodi qui sotto sono il risultato di tanti test, vari bug e di una quantità imbarazzante di issue su GitHub lette fino in fondo. Ti guiderò in ogni approccio, ti mostrerò esattamente quando usarlo e, alla fine, ti lascerò anche una scorciatoia no-code per chi vuole solo i dati, senza perdere tempo con l’ambientazione del progetto.

Perché estrarre dati da YouTube con Python?

YouTube non è solo una piattaforma video: è una fonte dati con . Con e , c’è una quantità enorme di informazioni pubbliche che aziende, ricercatori e creator vogliono analizzare in modo programmatico.

Il punto è che le analytics integrate di YouTube mostrano i dati solo del tuo canale. Se vuoi capire la frequenza di pubblicazione di un concorrente, monitorare gli argomenti di tendenza nella tua nicchia o analizzare il sentiment del pubblico nei commenti di video altrui, devi fare scraping.

Ecco i casi d’uso più comuni che ho visto nel mondo reale:

Un’analisi competitiva tra DJI, GoPro e Insta360, per esempio, ha mostrato che — un tipo di insight impossibile da ottenere da YouTube Studio.

Perché requests + BeautifulSoup da soli non bastano per YouTube

Prima di vedere i metodi che funzionano, devi capire perché l’approccio ovvio fallisce. Non è una questione teorica: ti farà risparmiare ore di debug.

L’approccio “naturale” assomiglia più o meno a questo:

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 — sempre

Il risultato è sempre zero. Come spiega il : “La pagina è stata caricata dinamicamente, cosa non supportata dalla libreria requests.” La è ancora più diretta: “Usando solo requests e BeautifulSoup non puoi eseguire JavaScript.”

spiega il meccanismo: YouTube è costruito come una Single Page Application (SPA). Con le semplici richieste HTTP ricevi solo l’HTML iniziale, cioè il guscio della pagina — il contenuto vero non è ancora stato renderizzato. I dati dei video sono nascosti in oggetti JavaScript che un browser normalmente eseguirebbe e inserirebbe nel DOM.

La buona notizia è che YouTube incorpora davvero tutti i dati necessari nell’HTML grezzo. Solo che non li mette in elementi DOM: li inserisce in due blocchi JSON dentro tag <script>:

• ytInitialData — struttura della pagina, elenco video, metriche di engagement, token di continuazione dei commenti
• ytInitialPlayerResponse — metadati video principali (titolo, descrizione, durata, formati, sottotitoli)

Entrambi sono accessibili con una singola requests.get() — senza browser — una volta capito come estrarli e analizzarli. È il Metodo 1 qui sotto.

4 modi per estrarre dati da YouTube con Python: confronto diretto

Prima di entrare nei dettagli, ecco la griglia decisionale. Ho testato tutti e quattro gli approcci confrontandoli in base ai criteri che contano davvero quando devi scegliere uno strumento per un progetto reale.

Sintesi rapida:

Quali dati di YouTube puoi davvero estrarre, e con quale metodo?

Questa è la tabella di riferimento che avrei voluto avere quando ho iniziato. Nessun singolo metodo copre tutti i campi — ed è proprio per questo che questo articolo ne presenta quattro.

Scegli il metodo in base alle righe che contano davvero per il tuo progetto. Se ti servono commenti e trascrizioni, yt-dlp è il vincitore netto. Se ti servono statistiche strutturate su scala moderata, l’API è la scelta migliore. Se vuoi i dati in due minuti, continua a leggere la sezione su Thunderbit.

Metodo 1: estrarre dati da YouTube con Python usando requests + BeautifulSoup (parsing di ytInitialData)

Questo metodo sfrutta il fatto che YouTube inserisce tutti i dati della pagina come JSON nell’HTML grezzo. Non ti serve un browser: devi solo sapere dove guardare.

• Difficoltà: Principiante
• Tempo necessario: ~15 minuti
• Cosa ti serve: Python 3.10+, requests, beautifulsoup4

Passo 1: invia una richiesta GET alla pagina YouTube

Invia la richiesta con un User-Agent realistico. L’header predefinito python-requests/2.x viene bloccato subito — la conferma che questo è l’errore più comune per chi inizia.

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",  # bypassa il blocco consenso UE
8}
9url = "https://www.youtube.com/@mkbhd/videos"
10response = requests.get(url, headers=HEADERS)
11print(response.status_code)  # Dovrebbe essere 200

Il cookie CONSENT è fondamentale: senza di esso, le richieste provenienti dall’UE vengono reindirizzate a consent.youtube.com, che restituisce HTML privo di ytInitialData.

Passo 2: analizza l’HTML e individua lo script ytInitialData

Usa BeautifulSoup o una regex per trovare il tag <script> che contiene var ytInitialData =:

1import re
2import json
3# Estrai il JSON di 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 estratto con successo")
12else:
13    print("ytInitialData non trovato — controlla header/cookie")

Errore comune: usare un .*? non greedily con solo }; come terminatore finale. I chiusori di oggetti annidati compaiono continuamente nel JSON e taglieranno l’estrazione troppo presto. Usa };</script> come fa — è l’ultima assegnazione nel proprio blocco script.

Passo 3: naviga la struttura JSON per estrarre i dati video

Il JSON è profondamente annidato. Invece di hardcodare percorsi che si rompono ogni volta che YouTube riorganizza la struttura (cosa che accade regolarmente — il documenta più cambi di formato dal 2023 in poi), usa una ricerca ricorsiva delle chiavi:

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# Estrai le info dei video dalla pagina del canale
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"Trovati {len(videos)} video")
23for v in videos[:5]:
24    print(f"  {v['title']} — {v['views']}")

Questo approccio ricorsivo è quello su cui si sono convergenti , yt-dlp e Scrapfly: resiste bene ai frequenti cambi di struttura JSON di YouTube.

Passo 4: esporta i dati estratti in CSV o 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("Dati esportati in youtube_videos.csv")

Quando usare questo metodo e quando no

Ideale per: estrarre rapidamente metadati da poche pagine di canali o video. Strumenti SEO leggeri. Analisi spot in cui servono titolo, visualizzazioni e data di pubblicazione.

Limiti: la struttura JSON cambia — tra le rotture documentate ci sono il refactor del pulsante like (2023: toggleButtonRenderer → segmentedLikeDislikeButtonViewModel), il refactor della descrizione (2023: description.runs[] → attributedDescription.content) e il redesign della scheda Video del canale (2022–2023: gridRenderer → richGridRenderer). Gli IP dei datacenter vengono in genere soft-blockati dopo 50–200 richieste. Niente commenti, niente trascrizioni.

Metodo 2: estrarre dati da YouTube con Python usando Selenium o Playwright

Quando devi interagire con la pagina — scorrere i risultati di ricerca, cliccare schede, espandere descrizioni — l’automazione del browser è la strada giusta.

• Difficoltà: Intermedio
• Tempo necessario: ~30 minuti
• Cosa ti serve: Python 3.10+, Playwright (pip install playwright && playwright install) oppure Selenium + ChromeDriver

Per i nuovi progetti consiglio Playwright rispetto a Selenium. I mostrano Playwright circa rispetto a Selenium. Playwright usa un WebSocket persistente tramite Chrome DevTools Protocol, mentre Selenium usa WebDriver su HTTP, aggiungendo un livello di traduzione per ogni comando.

Passo 1: configura Playwright

1pip install playwright
2playwright install chromium

1from playwright.sync_api import sync_playwright
2pw = sync_playwright().start()
3browser = pw.chromium.launch(headless=False)  # modalità visibile aiuta a evitare alcune rilevazioni
4context = browser.new_context()
5# Inserisci in anticipo il cookie del consenso per bypassare il blocco UE
6context.add_cookies([{
7    "name": "SOCS",
8    "value": "CAISNQgDEitib3FfaWRlbnRpdHlmcm9udGVuZHVpc2VydmVyXzIwMjMwODI5LjA3X3AxGgJlbiACGgYIgJnPpwY",
9    "domain": ".youtube.com",
10    "path": "/",
11}])
12page = context.new_page()

Passo 2: apri una pagina YouTube e attendi il caricamento dei contenuti

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

Se stai facendo scraping dei risultati di ricerca, usa invece https://www.youtube.com/results?search_query=la+tua+query.

Passo 3: gestisci lo scroll infinito per caricare più video

YouTube usa lo scroll infinito nelle pagine dei canali e nei risultati di ricerca. Ecco il classico loop su scrollHeight, adattato dalla :

1prev_height = -1
2max_scrolls = 20  # limita questo — un canale da 10K video scorrerebbe all'infinito
3scroll_count = 0
4while scroll_count < max_scrolls:
5    page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
6    page.wait_for_timeout(1500)  # attendi il caricamento di nuovo contenuto
7    new_height = page.evaluate("document.body.scrollHeight")
8    if new_height == prev_height:
9        break  # nessun nuovo contenuto caricato
10    prev_height = new_height
11    scroll_count += 1
12print(f"Scroll eseguiti: {scroll_count}")

Passo 4: estrai i dati video dal DOM renderizzato

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"Estratti {len(videos)} video")

Per visualizzazioni e date di pubblicazione, dovrai prendere anche gli elementi fratelli. La avverte che id="video-title-link" non è universale — YouTube distribuisce varianti di pagina diverse. Il fallback robusto è a[href*="watch"].

Passo 5: esporta in CSV o 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()

Quando usare questo metodo e quando no

Ideale per: scraping dei risultati di ricerca, interazione con elementi dinamici della pagina (clic su schede, espansione descrizioni), tutto ciò che richiede un DOM completamente renderizzato.

Limiti: lento (~1,5–3 secondi per video in un flusso scroll+estrazione). Alto rischio di rilevamento anti-bot — Selenium vanilla imposta navigator.webdriver === true, che . Molto esigente in termini di risorse (ogni istanza del browser usa 200–500 MB di RAM). Per 100 video, aspettati 3–8 minuti invece di secondi con yt-dlp.

Metodo 3: estrarre dati da YouTube con Python usando yt-dlp

yt-dlp è il coltellino svizzero dello scraping di YouTube. È un fork comunitario di youtube-dl con , release notturne attive e supporto integrato per metadati, commenti, trascrizioni e scraping in batch — tutto senza browser o chiave API.

• Difficoltà: Da principiante a intermedio
• Tempo necessario: ~10 minuti
• Cosa ti serve: Python 3.10+, pip install yt-dlp

Passo 1: installa yt-dlp

1pip install yt-dlp

Nessun driver del browser, nessuna chiave API, nessun file di configurazione.

Passo 2: estrai i metadati del video senza scaricarlo

1import yt_dlp
2opts = {
3    "quiet": True,
4    "skip_download": True,      # niente byte video — solo metadati
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"Titolo: {info['title']}")
13print(f"Visualizzazioni: {info['view_count']:,}")
14print(f"Like: {info.get('like_count', 'N/A')}")
15print(f"Durata: {info['duration']}s")
16print(f"Data di pubblicazione: {info['upload_date']}")
17print(f"Canale: {info['channel']} ({info.get('channel_follower_count', 'N/A')} iscritti)")
18print(f"Tag: {info.get('tags', [])[:5]}")

Una tipica chiamata extract_info restituisce 80–120 campi, a seconda dello stato del video: 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 e altro ancora.

Passo 3: estrai i commenti da un video YouTube

1opts = {
2    "quiet": True,
3    "skip_download": True,
4    "getcomments": True,
5    "extractor_args": {
6        "youtube": {
7            "max_comments": ["200", "50", "50", "10"],  # totale, principali, risposte per, risposte totali
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"Commenti recuperati: {len(comments)}")
19for c in comments[:3]:
20    print(f"  [{c.get('like_count', 0)} like] {c['author']}: {c['text'][:80]}...")

L’estrazione dei commenti è lenta. La segnala un recupero commenti a circa 30 KB/s — un video con 100.000 commenti può richiedere ore. La documenta video in cui gli URL dei formati scadono (circa 6 ore) prima che la paginazione dei commenti finisca. Imposta max_comments in modo aggressivo per i video grandi.

Passo 4: estrai trascrizioni e sottotitoli

Né la YouTube Data API né il parsing con BS4 possono darti trascrizioni complete. Questo è il vantaggio esclusivo di yt-dlp.

1opts = {
2    "quiet": True,
3    "skip_download": True,
4    "writesubtitles": True,
5    "writeautomaticsub": True,
6    "subtitleslangs": ["en", "en-orig"],
7    "subtitlesformat": "json3",   # adatto al parsing automatico: start/dur in ms + testo
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# Accedi ai dati dei sottotitoli direttamente dal dizionario info
16auto_captions = info.get("automatic_captions", {})
17manual_subs = info.get("subtitles", {})
18print(f"Lingue auto-caption: {list(auto_captions.keys())[:10]}")
19print(f"Lingue sottotitoli manuali: {list(manual_subs.keys())}")

Il formato json3 è preferibile per il parsing automatico: ogni segmento ha start/dur in millisecondi più il testo. I codici lingua seguono BCP-47 (en, en-US, zh-Hans, ja, es).

Passo 5: fai scraping in batch di più video o di un intero canale

1opts = {
2    "quiet": True,
3    "skip_download": True,
4    "extract_flat": "in_playlist",  # veloce — solo ID e titoli video
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"Trovati {len(entries)} video nel canale")
15for e in entries[:5]:
16    print(f"  {e.get('title', 'N/A')} — {e.get('id')}")

Passa un URL di canale, di playlist o persino una query di ricerca (ytsearch10:python scraping) e yt-dlp gestirà internamente la paginazione.

Quando usare questo metodo e quando no

Ideale per: estrazione massiva di metadati, commenti, trascrizioni, download di video, scraping di interi canali quando ti serve l’intero set di campi.

Limiti: non è la scelta migliore per le pagine dei risultati di ricerca (per quello Selenium/Playwright è più adatto). La corsa agli armamenti anti-bot del 2024–2026 ha reso yt-dlp più complesso da usare su larga scala: YouTube ora applica in alcuni client . Per l’uso in produzione, installa il plugin e usa --cookies-from-browser chrome (con un account di test — il team di yt-dlp avverte che i cookie di un account Google reale possono portare al ban di quell’account).

Metodo 4: estrarre dati da YouTube con la YouTube Data API

La YouTube Data API v3 ufficiale è il modo più affidabile e strutturato per ottenere dati da YouTube. Le risposte sono JSON puliti, i campi sono documentati e non esiste il gioco del gatto e del topo contro i bot. Ma c’è un dettaglio che molti tutorial sorvolano: il sistema di quota.

• Difficoltà: Intermedio
• Tempo necessario: ~20 minuti (incluso setup della chiave API)
• Cosa ti serve: Python 3.10+, un progetto Google Cloud, pip install google-api-python-client

Passo 1: ottieni una chiave API della YouTube Data API

1. Vai alla
2. Crea un nuovo progetto (o selezionane uno esistente)
3. Vai su APIs & Services → Library → cerca "YouTube Data API v3" → Enable
4. Vai su APIs & Services → Credentials → Create Credentials → API Key
5. Copia la chiave — la userai nel codice qui sotto

Passo 2: fai la tua prima chiamata API

1from googleapiclient.discovery import build
2API_KEY = "YOUR_API_KEY_HERE"
3youtube = build("youtube", "v3", developerKey=API_KEY)
4# Recupera i dettagli di un video specifico
5response = youtube.videos().list(
6    part="snippet,statistics,contentDetails",
7    id="dQw4w9WgXcQ"
8).execute()
9video = response["items"][0]
10print(f"Titolo: {video['snippet']['title']}")
11print(f"Visualizzazioni: {video['statistics']['viewCount']}")
12print(f"Like: {video['statistics'].get('likeCount', 'nascosti')}")
13print(f"Commenti: {video['statistics'].get('commentCount', 'disabilitati')}")
14print(f"Durata: {video['contentDetails']['duration']}")
15print(f"Tag: {video['snippet'].get('tags', [])[:5]}")

La risposta è pulita, tipizzata e documentata. Nessuna archeologia del JSON richiesta.

Passo 3: estrai dettagli video, info del canale e commenti

1# Cerca video
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# Recupera commenti
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']} like] {comment['authorDisplayName']}: {comment['textDisplay'][:80]}")

La realtà delle quote della YouTube API (quello che nessuno ti dice)

Questa è la sezione che separa una guida utile da un tutorial da copia-incolla. L’assegnazione predefinita è di , con reset a mezzanotte Pacific Time. Ecco il costo delle chiamate principali:

Facciamo due conti. Supponiamo tu voglia estrarre 1.000 risultati di ricerca:

• Chiamate di ricerca: 1.000 risultati ÷ 50 per pagina = 20 chiamate × 100 unità = 2.000 unità (il 20% del budget giornaliero, già sparito)
• Dettagli video per quei 1.000 video: 1.000 ID ÷ 50 per batch = 20 chiamate × 1 unità = 20 unità (economico — videos.list in batch è la parte che salva il budget)
• Commenti per quei 1.000 video (supponendo una pagina ciascuno): 1.000 chiamate × 1 unità = 1.000 unità

Totale: circa 3.020 unità per uno scraping modesto. Ma se quei video hanno thread di commenti profondi (50+ pagine ciascuno), bruci rapidamente le restanti 7.000 unità. Un video con 50.000 commenti = circa 500 pagine = 500 unità. Scraping di 20 video così e hai finito la giornata.

Il richiede un audit completo di conformità: URL della privacy policy, URL dei termini di servizio, video demo dell’app, giustificazione matematica della quota. Le segnalazioni della community indicano in genere una risposta di Google in 3–5 giorni lavorativi, mentre l’approvazione completa può richiedere settimane o mesi; molte domande vengono respinte, soprattutto nei casi “voglio più dati per analisi”.

Quando usare l’API: scala piccola o media, quando servono dati strutturati e affidabili, quando commenti e statistiche del canale sono importanti, quando puoi accettare il limite di quota.

Quando ha più senso fare scraping: progetti su larga scala (>10K video/giorno), campi non esposti dall’API (trascrizioni complete — captions.download richiede OAuth e il permesso del proprietario del video), oppure quando ti servono più di 500 risultati di ricerca per query (limite duro dell’API, indipendente da quanto dice totalResults).

La scorciatoia no-code: estrarre dati da YouTube con Thunderbit (senza usare Python)

Se ti serve Python per una pipeline dati, usa i Metodi 1–4 qui sopra. Ma se ti servono dati YouTube in 2 minuti — magari sei un marketer che vuole le statistiche dei competitor, o uno sviluppatore che vuole un’estrazione rapida senza configurare un ambiente di progetto — c’è una strada più veloce.

è un’estensione Chrome con AI web scraper che abbiamo creato apposta per i casi in cui scrivere codice è eccessivo. Funziona direttamente sulle pagine di YouTube nel tuo browser.

Come estrarre dati da YouTube con Thunderbit in 3 passi

Passo 1: installa l’ e apri una pagina di canale YouTube, una pagina di risultati di ricerca o una pagina video.

Passo 2: fai clic su "AI Suggest Fields" nella sidebar di Thunderbit. L’AI legge la pagina e propone colonne come titolo video, visualizzazioni, data di pubblicazione, durata, nome del canale e URL della miniatura. Puoi aggiungere, rimuovere o rinominare le colonne secondo necessità.

Passo 3: fai clic su "Scrape" ed esporta in Google Sheets, Excel, CSV, Airtable o Notion. I dati finiscono in una tabella pulita, pronta all’uso.

A chi è adatto

• Marketer che hanno bisogno dei dati dei canali competitor ma non sanno programmare
• Sviluppatori che vogliono un’estrazione veloce senza configurare virtual environment e dipendenze
• Chiunque incontri blocchi anti-bot — Thunderbit esegue lo scraping nella sessione del browser già autenticata dell’utente, ereditando cookie e PO token. Questo aggira molti dei problemi di blocco che colpiscono gli scraper server-side
• Thunderbit può anche usare lo per visitare ogni pagina video e arricchire la tabella con dettagli aggiuntivi (like count, descrizione, tag)

Per un approfondimento su come Thunderbit gestisce specificamente YouTube, dai un’occhiata al e al .

Consigli per estrarre dati da YouTube con Python senza farsi bloccare

Questi consigli valgono per tutti e quattro i metodi Python. Le misure anti-bot di YouTube sono valutate , con tre segnali principali: analisi comportamentale dell’IP, necessità di esecuzione JS e struttura HTML che cambia spesso.

Per tutti i metodi:

• Ruota gli User-Agent e l’intero set di header — Accept, Accept-Language, Sec-CH-UA e i client hints devono essere coerenti con l’UA dichiarato. La ha una lista aggiornata.
• Inserisci ritardi casuali di 2–8 secondi tra le richieste. Gli intervalli fissi sono un segnale di detection.
• Usa proxy residential per qualsiasi scraping oltre poche pagine. Gli IP dei datacenter (AWS, GCP, Hetzner) sono .
• Ruota sessione e IP insieme — YouTube collega le sessioni agli IP, e lo stesso cookie di sessione che appare su due IP diversi è un campanello d’allarme.

Per requests + BS4: imposta il cookie CONSENT=YES+cb. Senza di esso, le richieste dall’UE vengono reindirizzate a una pagina di consenso senza dati.

Per Selenium/Playwright: su server Linux esegui il browser in modalità visibile con xvfb invece di --headless=new — il headless di Chrome lascia ancora abbastanza tracce per rilevatori sofisticati. Valuta , che applica circa 17 tecniche di evasione.

Per yt-dlp: usa le opzioni sleep_interval e max_sleep_interval. Installa il plugin per la generazione dei PO Token. Usa --cookies-from-browser chrome con un account di test.

Per l’API: monitora l’uso della quota tramite la e ottimizza le richieste in batch. Una singola chiamata videos.list con 50 ID separati da virgola costa 1 unità — sfruttala.

Per Thunderbit: le misure anti-bot vengono gestite automaticamente perché lo scraping avviene nella tua sessione del browser. In pratica stai automatizzando ciò che faresti manualmente.

È legale estrarre dati da YouTube con Python?

Dipende da cosa estrai, da come lo fai e da cosa fai poi con quei dati.

Il panorama legale è cambiato nel 2024 con Meta Platforms v. Bright Data (N.D. Cal., gennaio 2024), dove . Dopo questa decisione, lo scraping di dati pubblicamente accessibili è diventato “significativamente meno rischioso”. Dall’altra parte, hiQ v. LinkedIn si è chiuso con una per violazione dei ToS, violazioni del CFAA (account falsi) e trespass to chattels — oltre a un’ingiunzione permanente.

I sono espliciti: “Non è consentito accedere al Servizio tramite mezzi automatizzati (come robot, botnet o scraper)”, salvo autorizzazione scritta preventiva o quando previsto dalla legge applicabile. Il modo ufficialmente autorizzato per accedere ai dati è la YouTube Data API.

Alcune regole pratiche:

• Estrarre dati pubblicamente visibili per ricerca personale o analisi non commerciale è in genere meno rischioso
• L’API è il percorso più sicuro: è esplicitamente autorizzata
• Evita di fare scraping di contenuti privati o protetti da login, di scaricare video coperti da copyright per redistribuirli o di violare il GDPR con dati personali presenti nei commenti
• I commenti YouTube contengono dati personali ai sensi dell’art. 4(1) GDPR — tratta con attenzione le informazioni degli interessati UE
• Per progetti commerciali di scraping, consulta un legale

Questo non è un parere legale. Il quadro normativo sta cambiando velocemente — una nuova ondata di che hanno raccolto dati da YouTube per l’addestramento sta ridisegnando il settore nel 2025–2026.

Quale metodo dovresti usare per estrarre dati da YouTube con Python?

Guida decisionale:

• Ti servono metadati rapidi da poche pagine? → Metodo 1 (requests + BS4). Veloce, leggero, senza dipendenze oltre a requests e beautifulsoup4.
• Ti servono i risultati di ricerca o pagine dinamiche? → Metodo 2 (Selenium/Playwright). Rendering completo del browser, supporto per scroll infinito, ma lento e soggetto a detection.
• Ti servono metadati in massa, commenti o trascrizioni? → Metodo 3 (yt-dlp). Lo strumento singolo più completo — per un motivo.
• Ti servono dati strutturati e affidabili su scala moderata? → Metodo 4 (YouTube Data API). Ufficiale, pulito, ma limitato da .
• Ti servono dati in 2 minuti senza scrivere codice? → . Basato su browser, potenziato da AI, esporta in Google Sheets in pochi clic.

Nessun metodo singolo copre tutti gli scenari. Salva nei preferiti la tabella comparativa e la tabella dei campi estraibili qui sopra: ti faranno risparmiare tempo nel prossimo progetto. E se vuoi esplorare altri , sul blog Thunderbit trovi molte guide che coprono tutto, dai a .

FAQ

Posso estrarre dati da YouTube senza chiave API?

Sì. I Metodi 1 (requests + BS4), 2 (Selenium/Playwright) e 3 (yt-dlp) non richiedono una chiave API. Solo il Metodo 4 (YouTube Data API) la richiede. Anche Thunderbit funziona senza alcuna chiave API: esegue lo scraping direttamente nel tuo browser.

Qual è il modo più veloce per estrarre dati da YouTube con Python?

Per Python, yt-dlp e requests + BS4 sono i più veloci: entrambi evitano il sovraccarico del browser e possono estrarre metadati in pochi secondi per video. yt-dlp è particolarmente rapido per operazioni in batch, perché gestisce internamente la paginazione. Per chi non usa Python, Thunderbit è il più veloce in assoluto perché non richiede alcun setup.

Come posso estrarre i commenti di YouTube con Python?

yt-dlp ha l’estrazione commenti integrata tramite l’opzione getcomments — è la via più semplice. Anche la YouTube Data API supporta i commenti tramite commentThreads.list (1 unità di quota per chiamata, fino a 100 commenti per pagina). Selenium/Playwright può farlo tecnicamente scorrendo e leggendo gli elementi commento renderizzati, ma è lento e fragile.

Posso estrarre i video Shorts di YouTube con Python?

Sì. yt-dlp gestisce bene i metadati degli Shorts — li tratta come video normali con campi aggiuntivi specifici per gli Shorts. La YouTube Data API ha un supporto parziale (il conteggio visualizzazioni degli Shorts — ora conta ogni avvio/ripetizione della riproduzione). BS4 e Selenium/Playwright hanno un supporto limitato per gli Shorts, perché la sezione Shorts usa strutture DOM diverse.

Quanti video YouTube posso estrarre al giorno?

Con la YouTube Data API sei limitato a circa 10.000 unità di quota al giorno. Usando chiamate videos.list in batch (50 ID per chiamata, 1 unità), puoi arrivare fino a 500.000 lookup di statistiche video al giorno — ma search.list, che costa 100 unità per chiamata, consuma il budget molto in fretta. Con i metodi di scraping (BS4, Selenium, yt-dlp) il limite è pratico, non codificato: i blocchi IP in genere iniziano dopo alcune centinaia o alcune migliaia di richieste per IP al giorno, a seconda della configurazione dei proxy e dei pattern di richiesta. Thunderbit usa un sistema basato su crediti legato al tuo .

Scopri di più