Python · YouTube
Scraping YouTube con Python
Fare scraping di YouTube con un browser significa scorrere liste infinite, aspettare gli script e analizzare un markup che cambia spesso. La YouTube Data API ufficiale richiede un progetto Google Cloud e raziona le richieste con una quota giornaliera. Questa guida prende una terza strada: fai scraping di YouTube con Python chiamando l'API di everydata.io, che legge le pagine pubbliche di YouTube e le restituisce come JSON.
Costruisci tre piccoli script: uno scraper YouTube per i risultati di ricerca, che scorre le pagine dei risultati e le salva in CSV, uno che elenca gli ultimi video di un canale e uno che recupera tutti i dettagli di un video – visualizzazioni, like, numero di commenti, data di pubblicazione, durata, categoria e tag.
Aggiornato il · di everydata.io
Cosa avrai alla fine
- Uno script Python che estrae in videos.csv i risultati di ricerca di YouTube per qualsiasi query.
- Gli ultimi video di qualsiasi canale tramite ID del canale, URL dell'handle o URL del canale.
- I dettagli completi di un video tramite ID, con una funzione helper riutilizzabile che gestisce rate limit e nuovi tentativi.
Cosa ti serve
- Python 3.10 o superiore e il pacchetto
requests(pip install requests). - Una chiave API gratuita di everydata.io – creala qui.
- Una ricerca, un canale o un video di cui vuoi fare scraping.
01Perché fare scraping di YouTube tramite API?
YouTube costruisce le sue pagine con JavaScript e carica altri risultati mentre scorri, quindi una semplice richiesta HTTP ottiene pochi dati utilizzabili e un headless browser deve scorrere, aspettare e analizzare. L'API YouTube di everydata.io fa questo lavoro sul server: ogni chiamata restituisce una pagina di risultati, con un cursor per la successiva.
Rispetto alla YouTube Data API ufficiale non c'è nessuna schermata OAuth, nessun progetto Google Cloud e nessuna quota giornaliera di unità – solo la tua chiave everydata.io. Ogni chiamata è una richiesta del tuo piano, e le risposte con stato 5xx non vengono conteggiate.
02Scrivi una piccola funzione helper per le richieste
Metti la chiave nell'ambiente (export EVERYDATA_API_KEY="ds_your_key") e salva questa funzione come everydata.py. Aspetta quando invii troppe richieste insieme (stato 429, la risposta indica quanti secondi) e riprova una volta una pagina che non è stata caricata (5xx).
import os
import re
import time
import requests
API = "https://api.everydata.io"
KEY = os.environ["EVERYDATA_API_KEY"]
def api_get(path: str, params: dict) -> dict:
"""GET an everydata.io endpoint. Waits when rate limited (429) and retries a failed page load (5xx) once."""
retried = False
for _ in range(4):
resp = requests.get(f"{API}{path}", params=params, headers={"x-api-key": KEY}, timeout=60)
if resp.status_code == 429:
wait = re.search(r"in (\d+) seconds", resp.text)
time.sleep(int(wait.group(1)) + 1 if wait else 60)
continue
if resp.status_code >= 500 and not retried:
retried = True # 5xx answers are not counted against your quota
time.sleep(10)
continue
resp.raise_for_status()
return resp.json()
raise RuntimeError("still rate limited after several waits – try again later")03Estrai i risultati di ricerca di YouTube in un file CSV
L'endpoint di ricerca accetta una query più languageCode e countryCode facoltativi (predefiniti en e US) e restituisce l'elenco dei risultati in items e un cursor per la pagina successiva. I risultati mescolano video, canali e playlist, quindi lo script tiene solo type video.
"""Scrape YouTube search results for a query into videos.csv – several pages via the cursor."""
import csv
from everydata import api_get # the helper from step 2, saved as everydata.py
QUERY = "lofi hip hop"
MAX_PAGES = 3 # every page is one request
rows, cursor = [], None
for page in range(1, MAX_PAGES + 1):
params = {"query": QUERY, "languageCode": "en", "countryCode": "US"}
if cursor:
params["cursor"] = cursor
data = api_get("/ytb/youtube-search-videos", params)
for item in data["items"]:
if item["type"] != "video": # results also contain channels and playlists
continue
rows.append({
"page": page,
"video_id": item["videoId"],
"title": item["title"],
"channel": item["channelName"],
"views": item["viewCount"],
"published": item["publishedTimeText"],
"duration_s": item["duration"],
"live": item["isLive"],
})
cursor = data.get("cursor")
if not cursor:
break
with open("videos.csv", "w", newline="") as f:
writer = csv.DictWriter(f, fieldnames=list(rows[0]))
writer.writeheader()
writer.writerows(rows)
print(len(rows), "videos saved to videos.csv")Una versione abbreviata dell'esempio documentato per la query lofi hip hop:
{
"responseStatus": "PAGE_FOUND",
"responseMessage": "Page successfully found!",
"query": "lofi hip hop",
"estimatedResults": 2407972,
"items": [
{
"type": "video",
"videoId": "n61ULEU7CO0",
"title": "Best of lofi hip hop 2021 ✨ [beats to relax/study to]",
"channelId": "UCSJ4gkVC6NrvII8umztf0Ow",
"channelName": "Lofi Girl",
"viewCount": 57439529,
"viewCountText": "57,439,529 views",
"publishedTimeText": "4 years ago",
"duration": 22258,
"durationText": "6:10:58",
"isLive": false
}
]
}viewCount è un numero che puoi ordinare e sommare; viewCountText è l'etichetta che mostra YouTube. Per le dirette l'etichetta dice "watching" e duration è null. Nei risultati di ricerca publishedTimeText è relativo ("4 years ago") – la chiamata dei dettagli video restituisce il publishedAt esatto.
04Scraping dei video di un canale YouTube
Per un singolo canale, passa in id il suo ID, l'URL dell'handle (https://www.youtube.com/@WWE) o l'URL del canale. filter sceglie la scheda: videos_latest (predefinito), streams_latest, shorts_latest o live_now. Per le pagine successive usa cursor, come nello script di ricerca.
from everydata import api_get
data = api_get("/ytb/youtube-channel-videos", {"id": "https://www.youtube.com/@WWE", "filter": "videos_latest"})
for item in data["items"]:
print(item["videoId"], item["viewCount"], item["publishedTimeText"], item["title"])
next_page = data["cursor"] # pass as cursor=... for the next page{
"responseStatus": "PAGE_FOUND",
"responseMessage": "Page successfully found!",
"channelId": "UCJ5v_MCY6GNUBTO8-D3XoAg",
"filter": "videos_latest",
"items": [
{
"type": "video",
"videoId": "b7kl_pcHa0A",
"title": "Blake Monroe vows to get payback against Giulia: SmackDown exclusive, Sept. 18, 2026",
"viewCount": 6800,
"viewCountText": "6.8K views",
"publishedTimeText": "47 minutes ago",
"duration": 110,
"durationText": "1:50"
}
]
}05Scraping dei dettagli dei video YouTube
Le liste di ricerca e dei canali ti danno gli ID dei video. Per la scheda completa di un video – numero esatto di visualizzazioni, like e commenti, data di pubblicazione, categoria, tag e altro – chiama l'endpoint dei dettagli video con l'ID o l'URL del video.
from everydata import api_get
v = api_get("/ytb/youtube-video-details", {"id": "kJQP7kiw5Fk"})
print(v["title"], "by", v["channelName"])
print(v["viewCount"], "views,", v["likeCount"], "likes,", v["commentCount"], "comments")
print("published", v["publishedAt"], "| duration", v["durationText"], "| category", v["category"])
print("tags:", ", ".join(v["tags"])){
"responseStatus": "PAGE_FOUND",
"responseMessage": "Page successfully found!",
"videoId": "kJQP7kiw5Fk",
"title": "Luis Fonsi - Despacito ft. Daddy Yankee",
"channelName": "LuisFonsiVEVO",
"viewCount": 9125159593,
"likeCount": 56673581,
"commentCount": 4300000,
"publishedAt": "2017-01-12T21:00:02-08:00",
"duration": 282,
"durationText": "4:42",
"category": "Music",
"tags": [
"Calypso",
"Despacito"
]
}Per seguire questi numeri nel tempo, la guida alle statistiche dei video YouTube li salva a intervalli programmati. Per la sezione commenti di un video, vedi l'API dei commenti YouTube.
06Costi e limiti dello scraping di YouTube
- Ogni pagina di ricerca, pagina di canale e consultazione di un video è una richiesta. Tre pagine di ricerca più i dettagli di 20 video fanno 23 richieste; il piano gratuito include 100 richieste al mese.
- I risultati seguono
languageCodeecountryCode, come fa YouTube per un visitatore di quel paese. - Solo dati pubblici: i video privati, eliminati o bloccati nella regione rispondono con HTTP 404 invece che con un oggetto compilato a metà.
Endpoint usati in questa guida
Search Videos · API YouTube
Channel Videos · API YouTube
Video Details · API YouTube
Cos'altro puoi fare con questi dati
Metadati YouTube in JSON – titolo, visualizzazioni, like, commenti, durata, tag, miniature, sottotitoli – per ID o URL. Senza OAuth né quota Data API.
Statistiche pubbliche dei canali YouTube via REST: iscritti, numero di video, verifica, ultimi video, live, Shorts e playlist per channel ID o @handle.
Scraping commenti YouTube per ID o URL: testo, autore, like, risposte, flag fissato e cuore, con paginazione a cursore nelle risposte. Senza OAuth.
Provalo con i tuoi dati
Il piano gratuito include 100 richieste al mese, utilizzabili su ogni piattaforma – abbastanza per seguire questa guida dall'inizio alla fine.