Cómo Extraer los Datos de un Canal de YouTube en JSON

Abre cualquier canal de YouTube y los números que ves están redondeados. Un vídeo muestra “1,2 M de visitas”, un canal muestra “340 mil suscriptores” y un recuento de comentarios pone “4,5 mil”. Están bien para una persona que echa un vistazo a la página. No sirven de nada si estás construyendo un panel, ordenando el catálogo de un creador o siguiendo el crecimiento semana a semana. Necesitas las cifras exactas, y las necesitas como datos estructurados, no como texto extraído de una página renderizada.

Esta guía explica cómo obtener la lista completa de vídeos de un canal de YouTube con recuentos exactos, duraciones de vídeo y fechas de publicación en JSON limpio. Cubre la API oficial de datos de YouTube, dónde se interpone en tu camino y cómo saltarte todo el proceso cuando solo quieres los datos.

Por Qué los Números de la Página Están Redondeados

YouTube abrevia los recuentos públicos a propósito. La página de reproducción y la del canal están hechas para leerse con facilidad, así que 1.234.567 se convierte en “1,2 M”. Los recuentos de suscriptores se redondean aún más: desde 2019 YouTube los publica con tres cifras significativas, así que “340 mil” podría ser cualquier valor entre 340.000 y 340.999.

Si extraes esas cadenas directamente del HTML, heredas el redondeo. Peor aún, lo heredas de forma inconsistente. El mismo canal puede mostrar “1,2 M” en un sitio y “1.234.567” en un tooltip, y el marcado alrededor de esos valores cambia a menudo. Convertir texto abreviado a enteros reales (“2,4 M” a 2.400.000) también descarta una precisión que nunca podrás recuperar.

Los números exactos sí existen. Simplemente no están en el texto orientado a las personas. Para leerlos de forma fiable vas a una fuente de datos hecha para máquinas.

Opción 1: La API de Datos de YouTube

Google publica la API de datos de YouTube v3, y es el punto de partida correcto. Devuelve viewCount, likeCount y commentCount exactos para los vídeos, además de estadísticas a nivel de canal. Esta es la forma del trabajo.

Consigue una Clave de API

Crea un proyecto en la consola de Google Cloud, activa la API de datos de YouTube v3 y genera una clave de API. Los datos públicos de solo lectura no necesitan OAuth, así que una clave normal es suficiente para empezar.

Resuelve el Canal

Necesitas el ID del canal (empieza por UC...). Si solo tienes un identificador como @nombrecanal, llama a channels.list con forHandle para resolverlo. Esa misma llamada devuelve las estadísticas del canal que quieres:

import requests

API_KEY = "TU_CLAVE"
BASE = "https://www.googleapis.com/youtube/v3"

def get_channel(handle):
    r = requests.get(f"{BASE}/channels", params={
        "part": "snippet,statistics,contentDetails",
        "forHandle": handle,
        "key": API_KEY,
    })
    r.raise_for_status()
    item = r.json()["items"][0]
    stats = item["statistics"]
    uploads = item["contentDetails"]["relatedPlaylists"]["uploads"]
    return {
        "channelId": item["id"],
        "title": item["snippet"]["title"],
        "subscriberCount": int(stats.get("subscriberCount", 0)),
        "videoCount": int(stats["videoCount"]),
        "viewCount": int(stats["viewCount"]),
        "uploadsPlaylist": uploads,
    }

Ten en cuenta que subscriberCount vuelve redondeado incluso desde la API. Es una política de Google, no una limitación del scraping. Los recuentos de visitas de los vídeos, en cambio, son exactos.

Recorre las Subidas

Cada canal tiene una lista de reproducción oculta de “subidas” que contiene todos sus vídeos públicos. Recórrela con playlistItems.list, reúne los IDs de los vídeos y agrúpalos en lotes en videos.list (hasta 50 por llamada) para leer estadísticas y duraciones:

def get_video_ids(uploads_playlist, limit=200):
    ids, page = [], None
    while len(ids) < limit:
        r = requests.get(f"{BASE}/playlistItems", params={
            "part": "contentDetails",
            "playlistId": uploads_playlist,
            "maxResults": 50,
            "pageToken": page,
            "key": API_KEY,
        })
        data = r.json()
        ids += [i["contentDetails"]["videoId"] for i in data["items"]]
        page = data.get("nextPageToken")
        if not page:
            break
    return ids[:limit]

def get_videos(video_ids):
    out = []
    for i in range(0, len(video_ids), 50):
        chunk = video_ids[i:i + 50]
        r = requests.get(f"{BASE}/videos", params={
            "part": "snippet,statistics,contentDetails",
            "id": ",".join(chunk),
            "key": API_KEY,
        })
        for v in r.json()["items"]:
            s, c = v["statistics"], v["contentDetails"]
            out.append({
                "id": v["id"],
                "title": v["snippet"]["title"],
                "publishedAt": v["snippet"]["publishedAt"],
                "duration": c["duration"],            # ISO-8601, p. ej. PT12M30S
                "viewCount": int(s.get("viewCount", 0)),
                "likeCount": int(s.get("likeCount", 0)),
                "commentCount": int(s.get("commentCount", 0)),
            })
    return out

Eso te da números exactos. La pega es el campo duration: vuelve como una cadena ISO-8601 tipo PT12M30S, no en segundos. Lo conviertes tú mismo con la librería isodate o con un pequeño parser.

Vigila la Cuota

Aquí es donde la API de datos muerde. Cada proyecto recibe 10.000 unidades de cuota al día por defecto. Una llamada a videos.list o playlistItems.list cuesta 1 unidad, lo que suena generoso hasta que estás paginando cientos de canales. Y search.list (que podrías usar para encontrar canales) cuesta 100 unidades por llamada, así que unos pocos cientos de búsquedas agotan el día entero.

Para un solo canal la cuota gratuita sobra. Para monitorizar miles de canales de forma programada, o pides un aumento de cuota a Google (un formulario y una revisión) o repartes las peticiones a lo largo de varios días. Ninguna de las dos opciones es divertida cuando tienes una fecha límite.

Opción 2: Sáltate la Configuración y Obtén JSON Directamente

Si no quieres un proyecto de Google Cloud, una clave de API, cálculos de cuota y tu propio bucle de paginación, puedes pasar un identificador o una URL de canal a una API de scraping y recibir los mismos datos estructurados en una sola llamada.

El endpoint youtube-channel de ScrapeUnblocker lee las subidas de un canal y devuelve cada vídeo con viewCount, likeCount y commentCount exactos, una duration tanto en ISO-8601 como en un durationSeconds listo para usar, la description y una marca de tiempo publishedAt. El resumen del canal incluye subscriberCount, videoCount, el viewCount total y el identificador. Un parámetro limit (de 1 a 200) controla cuánto avanzas más allá del primer lote.

import requests

resp = requests.post(
    "https://api.scrapeunblocker.com/content/youtube-channel",
    headers={"x-scrapeunblocker-key": "TU_CLAVE"},
    json={"channel": "@nombrecanal", "limit": 100},
)
data = resp.json()

print(data["channel"]["subscriberCount"], "suscriptores")
for v in data["videos"]:
    print(v["publishedAt"], v["durationSeconds"], v["viewCount"], v["title"])

Obtienes una sola carga JSON con las estadísticas del canal y la lista de vídeos ya parseada, incluido durationSeconds para que te ahorres la conversión ISO-8601. No hay cuota que presupuestar ni clave que aprovisionar con Google. Elige esto cuando prefieras dedicar tu tiempo al análisis en lugar de a la fontanería de la API.

Qué Hacer con los Datos

Una vez que tienes números exactos por vídeo en JSON, empieza el trabajo útil:

• Ordena un catálogo. Ordena por viewCount para encontrar los verdaderos éxitos de un canal, o por visitas por día desde publishedAt para detectar vídeos que aún están subiendo.
• Sigue el crecimiento. Guarda el viewCount y el videoCount del canal de forma programada y compáralos para medir el impulso, no números vanidosos.
• Calcula tasas de interacción. likeCount / viewCount y commentCount / viewCount solo tienen sentido con cifras exactas. Los recuentos redondeados convierten las proporciones en ruido.
• Estudia la cadencia y la duración. Agrupa durationSeconds y publishedAt para ver si los vídeos más largos o más cortos de un creador rinden mejor, y con qué frecuencia publica.

Preguntas Frecuentes

¿Los recuentos de visitas de los vídeos de YouTube son exactos o redondeados? El viewCount, likeCount y commentCount de un vídeo desde la API de datos son enteros exactos. Solo subscriberCount está redondeado, a tres cifras significativas, y eso es una política de Google que se aplica a cualquier forma de leerlo.

¿Está permitido hacer scraping de datos públicos de YouTube? Leer datos públicos y no personales como las estadísticas públicas de un vídeo suele tener menos riesgo que acceder a información privada o personal, pero sigues sujeto a las Condiciones de Servicio de YouTube y a la ley local. Recoge solo datos públicos, respeta los límites de tasa y, si tienes cualquier duda sobre un uso concreto, consulta con un abogado.

¿Por qué la duración del vídeo se devuelve como PT12M30S? Ese es el formato de duración ISO-8601, que la API de datos de YouTube usa para duration. PT12M30S significa 12 minutos y 30 segundos. Conviértelo a segundos con una librería como isodate, o usa una fuente que ya devuelva un durationSeconds numérico.

¿Cuántos vídeos puedo extraer de un canal? Todos los vídeos públicos viven en la lista de reproducción oculta de “subidas” del canal, así que no hay un tope más allá de hasta dónde pagines. Con la API de datos sigues nextPageToken hasta que se agota; con un endpoint de scraping fijas un limit (hasta 200 por petición aquí) y paginas desde ahí.

Cómo Obtener Datos Limpios de YouTube

Los números exactos que quieres nunca están en el texto redondeado de la página, así que hacer scraping del HTML es la herramienta equivocada. Léelos en cambio desde una fuente estructurada: la API de datos de YouTube si te va bien gestionar claves y cuota, o una API de scraping cuando prefieras recibir JSON parseado en una sola llamada.

Si quieres saltarte la configuración de Google Cloud y el parseo de ISO-8601, ScrapeUnblocker devuelve los vídeos de un canal con recuentos exactos, duraciones en segundos y fechas de publicación en JSON limpio. Consulta la documentación para ver la forma completa de la respuesta y los demás endpoints de datos.