Raspando YouTube con Python: 4 métodos que sí funcionan

Si alguna vez probaste requests.get("https://www.youtube.com/...") y luego analizaste el resultado con BeautifulSoup buscando títulos de videos, ya sabes cómo termina la historia: te devuelve una pared de <div> vacíos y exactamente cero datos útiles.

Esa es la frustración más común que veo entre desarrolladores que intentan extraer datos de YouTube por primera vez. YouTube es una aplicación de una sola página, así que renderiza casi todo del lado del cliente con JavaScript. El HTML que recibe tu script de Python es solo una carcasa. ¿Los títulos, las visualizaciones y los metadatos reales? Están escondidos dentro de un enorme bloque JSON llamado ytInitialData, que JavaScript inyecta después de que la página carga.

Por eso tu razonable soup.find("div", class_="ytd-video-renderer") devuelve None: ese elemento literalmente no existe en la respuesta HTTP en bruto. Cuando entendí esto, todo encajó. Los cuatro métodos de abajo son el resultado de muchas pruebas, varios errores y demasiadas issues de GitHub leídas. Te mostraré cada enfoque, cuándo conviene usarlo y, al final, te dejaré una alternativa sin código para quien solo quiera los datos sin montar un proyecto completo.

¿Por qué extraer datos de YouTube con Python?

YouTube no es solo una plataforma de video: es una fuente de datos con . Con y , hay una cantidad enorme de información pública que empresas, investigadores y creadores quieren analizar de forma programática.

El problema es que las analíticas integradas de YouTube solo muestran datos de tu propio canal. Si quieres entender la frecuencia de publicación de un competidor, seguir temas en tendencia de tu nicho o analizar el sentimiento de la audiencia en comentarios de videos ajenos, necesitas hacer scraping.

Estos son los casos de uso reales más comunes que he visto:

Por ejemplo, un análisis competitivo entre DJI, GoPro e Insta360 encontró que — una información imposible de ver desde YouTube Studio.

Por qué requests + BeautifulSoup por sí solos no pueden extraer YouTube

Antes de ver los métodos que sí funcionan, hay que entender por qué falla el enfoque obvio. No es una curiosidad académica: te ahorrará horas de depuración.

El enfoque “evidente” se vería más o menos así:

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

El resultado siempre es cero. Como dice la : “La página se cargó de forma dinámica, algo que la librería requests no soporta”. La lo resume sin rodeos: “Con requests y BeautifulSoup solos no puedes ejecutar JavaScript”.

La aclara el mecanismo: YouTube está construido como una Single Page Application (SPA). Cuando haces una solicitud HTTP básica, solo recibes el HTML inicial — el contenido real todavía no se ha renderizado. Los datos del video están dentro de objetos JavaScript que un navegador ejecutaría e inyectaría en el DOM.

La buena noticia: YouTube sí incrusta todos los datos necesarios en el HTML en bruto. Solo que no están en elementos DOM, sino en dos bloques JSON dentro de etiquetas <script>:

• ytInitialData — estructura de la página, listados de videos, métricas de interacción, tokens de continuación de comentarios
• ytInitialPlayerResponse — metadatos principales del video (título, descripción, duración, formatos, subtítulos)

Ambos se pueden obtener con un solo requests.get() — sin navegador — una vez que sabes cómo extraerlos y analizarlos. Ese es el Método 1.

4 formas de extraer YouTube con Python: comparación lado a lado

Antes de entrar en cada método, aquí tienes la matriz de decisión. Probé las cuatro opciones y las comparé con los criterios que realmente importan al elegir una herramienta para un proyecto real.

Resumen rápido:

¿Qué datos de YouTube puedes extraer realmente y con qué método?

Esta es la tabla de referencia que me habría encantado tener cuando empecé. Ningún método cubre todos los campos, y precisamente por eso este artículo cubre cuatro.

Elige el método según qué filas importen más para tu proyecto. Si necesitas comentarios y transcripciones, yt-dlp gana claramente. Si necesitas estadísticas estructuradas a escala moderada, la API es la mejor opción. Si necesitas datos en dos minutos, sigue leyendo la sección de Thunderbit.

Método 1: extraer YouTube con Python usando requests + BeautifulSoup (parseo de ytInitialData)

Este método aprovecha que YouTube incrusta todos los datos de la página como JSON dentro del HTML en bruto. No necesitas navegador; solo necesitas saber dónde buscar.

• Dificultad: Principiante
• Tiempo necesario: ~15 minutos
• Lo que necesitas: Python 3.10+, requests, beautifulsoup4

Paso 1: enviar una petición GET a la página de YouTube

Haz la solicitud con un encabezado User-Agent realista. El encabezado predeterminado python-requests/2.x se bloquea de inmediato — la confirma que este es el error más común para principiantes.

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",  # evita la página de consentimiento de la UE
8}
9url = "https://www.youtube.com/@mkbhd/videos"
10response = requests.get(url, headers=HEADERS)
11print(response.status_code)  # debería ser 200

La cookie CONSENT es clave: sin ella, las solicitudes desde la UE se redirigen a consent.youtube.com, que devuelve HTML sin ningún ytInitialData.

Paso 2: analizar el HTML y localizar el script de ytInitialData

Usa BeautifulSoup o una expresión regular para encontrar la etiqueta <script> que contiene var ytInitialData =:

1import re
2import json
3# Extraer JSON de 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 extraído correctamente")
12else:
13    print("No se encontró ytInitialData; revisa encabezados y cookies")

Un error frecuente es usar .*? no codicioso con solo }; como marcador final. Los cierres de objetos anidados aparecen constantemente dentro del JSON y truncarán la captura demasiado pronto. Usa };</script> como hace : es la última asignación dentro de su propio bloque script.

Paso 3: navegar la estructura JSON para extraer los datos del video

El JSON está profundamente anidado. En lugar de codificar rutas fijas que se rompen cada vez que YouTube reordena la estructura (algo que ocurre a menudo — el documenta varios cambios de formato desde 2023), usa una búsqueda recursiva de claves:

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# Extraer información de videos desde la página del canal
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"Encontrados {len(videos)} videos")
23for v in videos[:5]:
24    print(f"  {v['title']} — {v['views']}")

Este enfoque recursivo es el que terminaron usando , yt-dlp y Scrapfly; sobrevive a los cambios frecuentes de estructura JSON de YouTube.

Paso 4: exportar los datos extraídos a 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("Datos exportados a youtube_videos.csv")

Cuándo usar este método y cuándo no

Ideal para: extraer metadatos rápidamente de unas pocas páginas de canal o video. Herramientas SEO ligeras. Análisis puntuales donde necesitas título, visualizaciones y fecha de publicación.

Limitaciones: la estructura JSON cambia — entre las roturas documentadas están la refactorización del botón de like (2023: toggleButtonRenderer → segmentedLikeDislikeButtonViewModel), la refactorización de la descripción (2023: description.runs[] → attributedDescription.content) y el rediseño de la pestaña Videos del canal (2022–2023: gridRenderer → richGridRenderer). Las IPs de centros de datos suelen sufrir bloqueos suaves después de 50–200 solicitudes. Sin comentarios, sin transcripciones.

Método 2: extraer YouTube con Python usando Selenium o Playwright

Cuando necesitas interactuar con la página — desplazarte por resultados de búsqueda, hacer clic en pestañas, expandir descripciones — la automatización del navegador es la mejor opción.

• Dificultad: Intermedia
• Tiempo necesario: ~30 minutos
• Lo que necesitas: Python 3.10+, Playwright (pip install playwright && playwright install) o Selenium + ChromeDriver

Recomiendo Playwright sobre Selenium para proyectos nuevos. Los muestran que Playwright es aproximadamente que Selenium. Playwright usa un WebSocket persistente mediante Chrome DevTools Protocol, mientras que Selenium usa WebDriver sobre HTTP, lo que añade una capa de traducción por cada comando.

Paso 1: configurar Playwright

1pip install playwright
2playwright install chromium

1from playwright.sync_api import sync_playwright
2pw = sync_playwright().start()
3browser = pw.chromium.launch(headless=False)  # headful evita algunas detecciones
4context = browser.new_context()
5# Preestablecer cookie de consentimiento para evitar la barrera de la UE
6context.add_cookies([{
7    "name": "SOCS",
8    "value": "CAISNQgDEitib3FfaWRlbnRpdHlmcm9udGVuZHVpc2VydmVyXzIwMjMwODI5LjA3X3AxGgJlbiACGgYIgJnPpwY",
9    "domain": ".youtube.com",
10    "path": "/",
11}])
12page = context.new_page()

Paso 2: ir a una página de YouTube y esperar a que cargue el contenido

1page.goto("https://www.youtube.com/@mkbhd/videos")
2page.wait_for_selector("a#video-title-link", timeout=15000)
3print("Página cargada: los elementos de video ya son visibles")

Si estás extrayendo resultados de búsqueda, navega en su lugar a https://www.youtube.com/results?search_query=your+query.

Paso 3: manejar el scroll infinito para cargar más videos

YouTube usa scroll infinito en las páginas de canal y en los resultados de búsqueda. Aquí tienes el bucle clásico de scrollHeight, adaptado de la :

1prev_height = -1
2max_scrolls = 20  # limita esto; un canal de 10K videos podría desplazarse eternamente
3scroll_count = 0
4while scroll_count < max_scrolls:
5    page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
6    page.wait_for_timeout(1500)  # espera a que cargue contenido nuevo
7    new_height = page.evaluate("document.body.scrollHeight")
8    if new_height == prev_height:
9        break  # no se cargó más contenido
10    prev_height = new_height
11    scroll_count += 1
12print(f"Se desplazó {scroll_count} veces")

Paso 4: extraer datos de video desde la página renderizada

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"Extraídos {len(videos)} videos")

Para los conteos de visualizaciones y las fechas de publicación, tendrás que capturar elementos hermanos. La advierte que id="video-title-link" no es universal: YouTube publica varias variantes de página. El respaldo más robusto es a[href*="watch"].

Paso 5: exportar a 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()

Cuándo usar este método y cuándo no

Ideal para: extraer resultados de búsqueda, interactuar con elementos dinámicos de la página (clic en pestañas, expandir descripciones) y cualquier caso que requiera un DOM completamente renderizado.

Limitaciones: lento (~1.5–3 segundos por video en un flujo de desplazamiento y extracción). Alto riesgo de detección anti-bot — Selenium vanilla deja navigator.webdriver === true, que . Consume muchos recursos: cada instancia del navegador usa 200–500 MB de RAM. Para 100 videos, espera entre 3 y 8 minutos, frente a segundos con yt-dlp.

Método 3: extraer YouTube con Python usando yt-dlp

yt-dlp es la navaja suiza del scraping de YouTube. Es un fork comunitario de youtube-dl con , lanzamientos nocturnos activos y soporte integrado para metadatos, comentarios, transcripciones y scraping por lotes — todo sin navegador ni clave API.

• Dificultad: De principiante a intermedia
• Tiempo necesario: ~10 minutos
• Lo que necesitas: Python 3.10+, pip install yt-dlp

Paso 1: instalar yt-dlp

1pip install yt-dlp

Sin drivers del navegador, sin claves API, sin archivos de configuración.

Paso 2: extraer metadatos del video sin descargarlo

1import yt_dlp
2opts = {
3    "quiet": True,
4    "skip_download": True,      # no descarga video, solo metadatos
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"Título: {info['title']}")
13print(f"Visualizaciones: {info['view_count']:,}")
14print(f"Likes: {info.get('like_count', 'N/A')}")
15print(f"Duración: {info['duration']}s")
16print(f"Fecha de publicación: {info['upload_date']}")
17print(f"Canal: {info['channel']} ({info.get('channel_follower_count', 'N/A')} subs)")
18print(f"Etiquetas: {info.get('tags', [])[:5]}")

Una llamada típica a extract_info devuelve entre 80 y 120 campos según el estado 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 y más.

Paso 3: extraer comentarios de un video de YouTube

1opts = {
2    "quiet": True,
3    "skip_download": True,
4    "getcomments": True,
5    "extractor_args": {
6        "youtube": {
7            "max_comments": ["200", "50", "50", "10"],  # total, comentarios principales, respuestas por hilo, respuestas totales
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"Se obtuvieron {len(comments)} comentarios")
19for c in comments[:3]:
20    print(f"  [{c.get('like_count', 0)} likes] {c['author']}: {c['text'][:80]}...")

La extracción de comentarios es lenta. El reporta una velocidad de ~30 KB/s al obtener comentarios: un video con 100K comentarios puede tardar horas. El documenta videos cuyos URLs de formatos expiran (~6 horas) antes de que termine la paginación de comentarios. Para videos grandes, ajusta max_comments de forma agresiva.

Paso 4: extraer transcripciones y subtítulos

Ni la YouTube Data API ni el parseo con BS4 pueden darte transcripciones completas. Esa es la gran ventaja de yt-dlp.

1opts = {
2    "quiet": True,
3    "skip_download": True,
4    "writesubtitles": True,
5    "writeautomaticsub": True,
6    "subtitleslangs": ["en", "en-orig"],
7    "subtitlesformat": "json3",   # apto para parseo automático: start/dur en ms + texto
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# Acceder directamente a los subtítulos desde el diccionario info
16auto_captions = info.get("automatic_captions", {})
17manu_subs = info.get("subtitles", {})
18print(f"Idiomas de subtítulos automáticos: {list(auto_captions.keys())[:10]}")
19print(f"Idiomas de subtítulos manuales: {list(manu_subs.keys())}")

El formato json3 es el preferido para parseo automático: cada segmento incluye start/dur en milisegundos además del texto. Los códigos de idioma siguen BCP-47 (en, en-US, zh-Hans, ja, es).

Paso 5: extraer en lote varios videos o un canal completo

1opts = {
2    "quiet": True,
3    "skip_download": True,
4    "extract_flat": "in_playlist",  # rápido: solo IDs y títulos
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"Se encontraron {len(entries)} videos en el canal")
15for e in entries[:5]:
16    print(f"  {e.get('title', 'N/A')} — {e.get('id')}")

Puedes pasar una URL de canal, una URL de playlist o incluso una búsqueda (ytsearch10:python scraping) y yt-dlp se encarga de la paginación internamente.

Cuándo usar este método y cuándo no

Ideal para: extracción masiva de metadatos, comentarios, transcripciones, descargas de videos y scrapes a nivel de canal donde necesitas el conjunto completo de campos.

Limitaciones: no es ideal para páginas de resultados de búsqueda (Selenium/Playwright suele ser mejor ahí). La guerra anti-bot de 2024–2026 ha hecho que yt-dlp sea más complejo de ejecutar a escala: ahora YouTube aplica en algunos clientes. Para uso en producción, instala el plugin y usa --cookies-from-browser chrome (con una cuenta desechable; el equipo de yt-dlp advierte que las cookies de una cuenta real de Google pueden acabar bloqueando esa cuenta).

Método 4: extraer YouTube con Python usando la YouTube Data API

La API oficial YouTube Data API v3 es la forma más confiable y estructurada de obtener datos de YouTube. Las respuestas son JSON limpio, los campos están documentados y no hay juego del gato y el ratón contra anti-bots. Pero hay una trampa que la mayoría de tutoriales pasa por alto: el sistema de cuotas.

• Dificultad: Intermedia
• Tiempo necesario: ~20 minutos (incluida la configuración de la clave API)
• Lo que necesitas: Python 3.10+, un proyecto de Google Cloud, pip install google-api-python-client

Paso 1: obtener una clave de la YouTube Data API

1. Ve a
2. Crea un proyecto nuevo o selecciona uno existente
3. Entra en APIs y servicios → Biblioteca → busca "YouTube Data API v3" → Habilitar
4. Ve a APIs y servicios → Credenciales → Crear credenciales → Clave de API
5. Copia la clave: la usarás en el código de abajo

Paso 2: hacer tu primera llamada a la API

1from googleapiclient.discovery import build
2API_KEY = "YOUR_API_KEY_HERE"
3youtube = build("youtube", "v3", developerKey=API_KEY)
4# Obtener detalles de un video concreto
5response = youtube.videos().list(
6    part="snippet,statistics,contentDetails",
7    id="dQw4w9WgXcQ"
8).execute()
9video = response["items"][0]
10print(f"Título: {video['snippet']['title']}")
11print(f"Visualizaciones: {video['statistics']['viewCount']}")
12print(f"Likes: {video['statistics'].get('likeCount', 'ocultos')}")
13print(f"Comentarios: {video['statistics'].get('commentCount', 'desactivados')}")
14print(f"Duración: {video['contentDetails']['duration']}")
15print(f"Etiquetas: {video['snippet'].get('tags', [])[:5]}")

La respuesta es limpia, tipada y documentada. No hace falta arqueología JSON.

Paso 3: extraer detalles del video, información del canal y comentarios

1# Buscar videos
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# Obtener comentarios
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']} likes] {comment['authorDisplayName']}: {comment['textDisplay'][:80]}")

La realidad de las cuotas de la API de YouTube

Esta es la sección que separa una guía útil de un tutorial de copiar y pegar. La asignación predeterminada es de , que se reinicia a medianoche hora del Pacífico. Esto cuesta cada llamada:

Hagamos números. Supongamos que quieres extraer 1,000 resultados de búsqueda:

• Llamadas de búsqueda: 1,000 resultados ÷ 50 por página = 20 llamadas × 100 unidades = 2,000 unidades (20% de tu presupuesto diario, desaparecido)
• Detalles de video para esos 1,000 videos: 1,000 IDs ÷ 50 por lote = 20 llamadas × 1 unidad = 20 unidades (barato: videos.list en lote es la gran ventaja)
• Comentarios para esos 1,000 videos (asumiendo 1 página por video): 1,000 llamadas × 1 unidad = 1,000 unidades

Total: unas 3,020 unidades para un scraping modesto. Pero si esos videos tienen hilos profundos de comentarios (50+ páginas cada uno), consumirás las 7,000 unidades restantes muy rápido. Un video con 50,000 comentarios = unas 500 páginas = 500 unidades. Extrae 20 videos así y se acabó el día.

El requiere una auditoría completa de cumplimiento: URL de política de privacidad, URL de términos de servicio, video de demostración de la app y justificación matemática de la cuota. Informes de la comunidad sugieren una respuesta típica de Google en 3–5 días hábiles, con aprobaciones completas que pueden tardar semanas o meses, y muchas solicitudes son rechazadas, especialmente las de “quiero más datos para análisis”.

Cuándo usar la API: a pequeña o mediana escala, cuando necesitas datos estructurados y fiables, cuando los comentarios y las métricas del canal importan, y cuando puedes vivir con el límite de cuota.

Cuándo tiene más sentido hacer scraping: proyectos a gran escala (>10K videos/día), campos que la API no expone (transcripciones completas — captions.download requiere OAuth y permiso del dueño del video) o cuando necesitas más de 500 resultados de búsqueda por consulta (límite duro de la API, independientemente de lo que declare totalResults).

El atajo sin código: extraer YouTube con Thunderbit (sin Python)

Si necesitas Python para una canalización de datos, usa los Métodos 1–4 de arriba. Pero si necesitas datos de YouTube en 2 minutos — quizá eres un marketer que quiere estadísticas de competidores, o un desarrollador que solo busca una extracción rápida sin montar un entorno de proyecto — hay un camino más rápido.

es una extensión de Chrome con AI web scraper que diseñamos específicamente para casos en los que programar es demasiado para lo que necesitas. Funciona directamente sobre páginas de YouTube en tu navegador.

Cómo extraer YouTube con Thunderbit en 3 pasos

Paso 1: instala la y abre una página de canal de YouTube, una página de resultados de búsqueda o una página de video.

Paso 2: haz clic en "AI Suggest Fields" en la barra lateral de Thunderbit. La IA lee la página y sugiere columnas como título del video, visualizaciones, fecha de publicación, duración, nombre del canal y URL de la miniatura. Puedes añadir, quitar o renombrar columnas según lo necesites.

Paso 3: haz clic en "Scrape" y exporta a Google Sheets, Excel, CSV, Airtable o Notion. Los datos llegan en una tabla limpia, lista para usar.

Para quién es

• Marketers que necesitan datos de canales de competidores pero no programan
• Desarrolladores que quieren una extracción rápida sin configurar un entorno virtual ni instalar dependencias
• Cualquiera que choque con barreras anti-bot — Thunderbit extrae datos dentro de tu sesión de navegador iniciada, heredando cookies y PO tokens, lo que evita muchos de los bloqueos que afectan a los scrapers del lado del servidor
• Thunderbit también puede usar para visitar cada página de video y enriquecer la tabla con detalles adicionales (likes, descripción, etiquetas)

Para ver más a fondo cómo Thunderbit maneja YouTube específicamente, consulta la y el .

Consejos para extraer YouTube con Python sin que te bloqueen

Estos consejos aplican a los cuatro métodos en Python. Las medidas anti-bot de YouTube tienen una dificultad de , con tres señales principales: análisis de comportamiento de IP, necesidad de ejecutar JS y estructura HTML que cambia con frecuencia.

Para todos los métodos:

• Rota los User-Agent y el conjunto completo de encabezados: Accept, Accept-Language y los client hints Sec-CH-UA deben coincidir con el UA declarado. La tiene una lista actualizada.
• Añade retrasos aleatorios de 2–8 segundos entre solicitudes. Los intervalos fijos son una señal de detección.
• Usa proxies residenciales para cualquier cosa que vaya más allá de unas pocas páginas. Las IPs de datacenter (AWS, GCP, Hetzner) están .
• Rota sesión e IP juntas: YouTube vincula sesiones a IP, y la misma cookie de sesión apareciendo en dos IPs es una alerta.

Para requests + BS4: usa la cookie CONSENT=YES+cb. Sin ella, las solicitudes desde la UE se redirigen a una página de consentimiento sin datos.

Para Selenium/Playwright: ejecuta en modo visible con xvfb en servidores Linux en lugar de --headless=new: Chrome en headless aún filtra suficientes señales de fingerprint para detectores sofisticados. Considera , que aplica unas 17 evasiones.

Para yt-dlp: usa sleep_interval y max_sleep_interval. Instala el plugin para generar PO Tokens. Usa --cookies-from-browser chrome con una cuenta desechable.

Para la API: supervisa el uso de cuota desde y agrupa las solicitudes de forma eficiente. Una sola llamada a videos.list con 50 IDs separados por coma cuesta 1 unidad: aprovéchala.

Para Thunderbit: las medidas anti-bot se gestionan automáticamente porque el scraping ocurre dentro de tu sesión del navegador. Básicamente estás automatizando lo mismo que harías a mano.

¿Es legal extraer datos de YouTube con Python?

Depende de qué extraigas, cómo lo hagas y para qué uses los datos.

El panorama legal cambió en 2024 con Meta Platforms v. Bright Data (N.D. Cal., enero de 2024), donde . Extraer datos públicamente accesibles pasó a ser “significativamente menos arriesgado” tras esa decisión. Por otro lado, hiQ v. LinkedIn terminó con una por incumplimiento de ToS, violaciones de CFAA (cuentas falsas) y trespass to chattels, además de una orden judicial permanente.

Los son explícitos: “No se le permite acceder al Servicio mediante medios automatizados (como robots, botnets o scrapers)” salvo con permiso previo por escrito o según lo permita la ley aplicable. La YouTube Data API es la vía oficialmente autorizada para acceder a datos.

Algunas reglas prácticas:

• Extraer datos visibles públicamente para investigación personal o análisis no comercial suele implicar menos riesgo
• La API es la ruta más segura: está explícitamente autorizada
• Evita extraer contenido privado o detrás de login, descargar videos con copyright para redistribuirlos o vulnerar el RGPD con datos personales de comentarios
• Los comentarios de YouTube contienen datos personales según el Art. 4(1) del RGPD; maneja con cuidado la información de sujetos de datos de la UE
• Consulta asesoría legal para proyectos comerciales de scraping

Nada de esto es asesoramiento legal. El panorama cambia rápido: una nueva ola de que rasparon YouTube para datos de entrenamiento está reconfigurando el sector en 2025–2026.

¿Qué método deberías usar para extraer YouTube con Python?

Guía rápida de decisión:

• ¿Necesitas metadatos rápidos de unas pocas páginas? → Método 1 (requests + BS4). Rápido, ligero, sin más dependencias que requests y beautifulsoup4.
• ¿Necesitas extraer resultados de búsqueda o interactuar con páginas dinámicas? → Método 2 (Selenium/Playwright). Renderizado completo del navegador, soporte para scroll infinito, pero lento y propenso a detección.
• ¿Necesitas metadatos masivos, comentarios o transcripciones? → Método 3 (yt-dlp). La herramienta más capaz en una sola pieza — y con por una razón.
• ¿Necesitas datos estructurados y fiables a escala moderada? → Método 4 (YouTube Data API). Oficial, limpio, pero limitado por cuota a .
• ¿Necesitas datos en 2 minutos sin programar? → . Basado en navegador, impulsado por IA, exporta a Google Sheets con unos clics.

Ningún método cubre todos los casos de uso. Guarda en favoritos la tabla comparativa y la referencia de campos extraíbles de arriba: te ahorrarán tiempo en tu próximo proyecto. Y si quieres explorar más , en el blog de Thunderbit tenemos muchas guías, desde hasta .

Preguntas frecuentes

¿Puedo extraer YouTube sin una clave API?

Sí. Los métodos 1 (requests + BS4), 2 (Selenium/Playwright) y 3 (yt-dlp) no requieren clave API. Solo el método 4 (YouTube Data API) necesita una. Thunderbit también funciona sin clave API: extrae directamente desde tu navegador.

¿Cuál es la forma más rápida de extraer YouTube con Python?

Para Python, yt-dlp y requests + BS4 son los más rápidos: ambos evitan la sobrecarga del navegador y pueden obtener metadatos en segundos por video. yt-dlp es especialmente rápido para operaciones por lotes porque maneja la paginación internamente. Para usuarios sin Python, Thunderbit es la opción más rápida en general porque no requiere configuración.

¿Cómo extraigo comentarios de YouTube con Python?

yt-dlp tiene extracción de comentarios integrada mediante la opción getcomments: es la ruta más simple. La YouTube Data API también admite comentarios con commentThreads.list (1 unidad de cuota por llamada, hasta 100 comentarios por página). Selenium/Playwright puede hacerlo desplazándose y extrayendo comentarios renderizados, pero es lento y frágil.

¿Puedo extraer YouTube Shorts con Python?

Sí. yt-dlp maneja bien los metadatos de Shorts: los trata como videos normales con campos adicionales específicos de Shorts. La YouTube Data API tiene soporte parcial (el conteo de visualizaciones de Shorts : ahora cuenta cualquier inicio de reproducción o repetición). BS4 y Selenium/Playwright tienen soporte limitado para Shorts porque la sección Shorts usa estructuras DOM distintas.

¿Cuántos videos de YouTube puedo extraer al día?

Con la YouTube Data API estás limitado a unas ~10,000 unidades de cuota al día. Usando llamadas videos.list en lote (50 IDs por llamada por 1 unidad), eso permite hasta 500,000 consultas de estadísticas de video por día; pero search.list, al costar 100 unidades por llamada, agota el presupuesto rápidamente. Con métodos de scraping (BS4, Selenium, yt-dlp), el límite es práctico más que fijo: los bloqueos de IP suelen aparecer tras unas pocas centenas o miles de solicitudes por IP al día, dependiendo de tu configuración de proxies y del patrón de solicitudes. Thunderbit usa un sistema basado en créditos vinculado a tu .

Más información