Extrair dados do YouTube com Python: 4 métodos que realmente funcionam

Se você já tentou requests.get("https://www.youtube.com/...") e depois usou BeautifulSoup para procurar títulos de vídeos, já sabe como termina: volta um monte de <div> vazia e, no fim das contas, nenhum dado útil.

Essa é a frustração mais comum que vejo entre desenvolvedores que tentam fazer scraping no YouTube pela primeira vez. O YouTube é uma aplicação de página única — quase tudo é renderizado no lado do cliente via JavaScript. O HTML que o teu script em Python recebe é só uma casca. Os títulos reais dos vídeos, a contagem de visualizações e os metadados? Eles ficam escondidos dentro de um enorme bloco JSON chamado ytInitialData, que é injetado pelo JS depois que a página carrega.

Ou seja, aquele soup.find("div", class_="ytd-video-renderer") que parece tão razoável retorna None porque esse elemento literalmente não existe na resposta HTTP bruta. Quando entendi isso, tudo fez sentido — e os quatro métodos abaixo são fruto de muito teste, código quebrado e uma quantidade exagerada de issues no GitHub. Vou te mostrar cada abordagem, explicar exatamente quando usar uma ou outra e, no final, deixar um atalho sem código para quem só quer os dados sem montar um projeto inteiro.

Por que extrair dados do YouTube com Python?

O YouTube não é só uma plataforma de vídeo — é uma fonte de dados com 2,58 bilhões de usuários ativos mensais. Com mais de 5,1 bilhões de vídeos hospedados e mais de 500 horas de conteúdo enviadas por minuto, existe uma quantidade gigantesca de informação pública que empresas, pesquisadores e criadores querem analisar programaticamente.

O problema é que a análise nativa do YouTube só mostra dados do seu próprio canal. Se você quer entender a frequência de postagem de um concorrente, acompanhar temas em alta no seu nicho ou analisar o sentimento do público nos comentários de vídeos de terceiros, precisa fazer scraping.

Aqui estão os casos de uso mais comuns que vejo no dia a dia:

Caso de uso	Quem precisa disso	Dados envolvidos
Análise da concorrência	Equipes de marketing, estrategistas de conteúdo	Visualizações, frequência de publicação, taxas de engajamento
Geração de leads	Equipes comerciais, prospecção B2B	Informações de contato do canal, e-mails comerciais nas descrições
Pesquisa de mercado	Product managers, analistas	Tópicos em alta, sentimento do público nos comentários
Estratégia de conteúdo	YouTubers, agências	Formatos com melhor desempenho, padrões ideais de títulos e tags
SEO / pesquisa de palavras-chave	Especialistas em SEO	Títulos, tags, descrições e sinais de ranqueamento
Monitoramento de marca	Times de PR, gestores de marca	Menções em títulos, comentários e descrições
Pesquisa acadêmica	Pesquisadores, cientistas de dados	Conjuntos de comentários para análise de sentimento (um estudo de 2025 atingiu 93,1% de precisão ao ajustar o BERT com 45 mil comentários do YouTube)

Uma análise competitiva entre DJI, GoPro e Insta360, por exemplo, descobriu que o alcance da DJI no YouTube (390 milhões de visualizações) superou os dois concorrentes juntos — um tipo de insight impossível de enxergar só dentro do YouTube Studio.

Por que requests + BeautifulSoup sozinho não consegue extrair dados do YouTube

Antes de chegar aos métodos que funcionam, você precisa entender por que a abordagem óbvia falha. Isso não é teoria acadêmica — vai te poupar horas de debug.

A abordagem “óbvia” seria algo assim, em termos conceituais:

import requests
from bs4 import BeautifulSoup

response = requests.get("https://www.youtube.com/@somechannel/videos")
soup = BeautifulSoup(response.text, "html.parser")
videos = soup.find_all("a", id="video-title-link")
print(len(videos))  # 0 — sempre

O resultado é sempre zero. Como diz o guia de debug da ScrapeOps: “A página foi carregada dinamicamente, o que não é suportado pela biblioteca requests.” O guia para iniciantes da Teclado é ainda mais direto: “Usando apenas requests e BeautifulSoup, você não consegue executar JavaScript.”

O raio-x do YouTube feito pela Scrapfly em 2026 explica o mecanismo: o YouTube foi construído como uma Single Page Application (SPA). Quando você faz requisições HTTP básicas, recebe apenas o HTML inicial — o conteúdo real ainda não foi renderizado. Os dados dos vídeos ficam escondidos em objetos JavaScript que o navegador normalmente executaria e injetaria no DOM.

A boa notícia: o YouTube de fato embute todos os dados de que você precisa no HTML bruto. Só que eles não estão em elementos do DOM — estão em dois blocos JSON dentro de tags <script>:

• ytInitialData — estrutura da página, listagem de vídeos, métricas de engajamento, tokens de continuação de comentários
• ytInitialPlayerResponse — metadados centrais do vídeo (título, descrição, duração, formatos, legendas)

Ambos podem ser acessados com um único requests.get() — sem navegador — desde que você saiba como extrair e interpretar esses dados. Esse é o Método 1 abaixo.

4 formas de extrair dados do YouTube com Python: comparação lado a lado

Antes de entrar em cada método, aqui vai a matriz de decisão. Testei as quatro abordagens e comparei com base nos critérios que realmente importam quando você está escolhendo uma ferramenta para um projeto real.

Critério	requests + BS4 (ytInitialData)	Selenium / Playwright	yt-dlp	YouTube Data API	Sem código (Thunderbit)
Complexidade de configuração	Baixa	Média	Baixa	Média (chave de API)	Nenhuma
Lida com renderização JS	Parcial (parse de JSON)	Sim	Sim	N/A (API estruturada)	Sim
Velocidade	Rápida	Lenta	Rápida	Rápida	Rápida (na nuvem)
Risco de anti-bot	Médio	Alto	Baixo	Nenhum	Tratado
Cotas / limites de taxa	Nenhum (mas há bloqueios de IP)	Nenhum (mas há detecção)	Nenhum	10.000 unidades/dia	Baseado em créditos
Extração de comentários	Difícil	Possível, mas complexa	Nativo	Nativo	Depende da página
Transcrições	Não	Complexo	Sim	Não	Não
Melhor para	Metadados rápidos	Resultados de busca, páginas dinâmicas	Metadados em lote + comentários	Dados estruturados em escala	Não programadores, exportações rápidas

Resumo rápido:

Quais dados do YouTube você realmente consegue extrair — e com qual método?

Esta é a tabela de referência que eu queria ter quando comecei. Nenhum método cobre todos os campos — por isso este artigo traz quatro.

Campo de dados	BS4 (ytInitialData)	Selenium/Playwright	yt-dlp	YouTube API	Thunderbit
Título do vídeo	✅	✅	✅	✅	✅
Número de visualizações	✅	✅	✅	✅	✅
Curtidas	⚠️ Inconsistente	✅	✅	✅	✅
Comentários (texto)	❌	⚠️ Complexo	✅	✅	⚠️
Transcrição/legendas	❌	⚠️	✅	❌	❌
Tags	✅	✅	✅	✅	⚠️
URLs das miniaturas	✅	✅	✅	✅	✅
Número de inscritos do canal	⚠️	✅	✅	✅	✅
Data de envio	✅	✅	✅	✅	✅
Duração do vídeo	✅	✅	✅	✅	✅
Dados específicos de Shorts	❌	⚠️	✅	⚠️	⚠️

Escolha o método com base nas linhas que realmente importam para o teu projeto. Se você precisa de comentários e transcrições, o yt-dlp é o vencedor claro. Se precisa de estatísticas estruturadas em escala moderada, a API é a melhor opção. Se quer dados em dois minutos, continue lendo a seção do Thunderbit.

Método 1: extrair dados do YouTube com Python usando requests + BeautifulSoup (parse de ytInitialData)

Esse método aproveita o fato de que o YouTube embute todos os dados da página como JSON dentro do HTML bruto. Você não precisa de navegador — só precisa saber onde procurar.

• Dificuldade: Iniciante
• Tempo necessário: ~15 minutos
• O que você vai precisar: Python 3.10+, requests, beautifulsoup4

Passo 1: enviar uma requisição GET para a página do YouTube

Envie a requisição com um cabeçalho User-Agent realista. O cabeçalho padrão python-requests/2.x é bloqueado na hora — o guia de headers da ScrapeOps confirma que esse é o erro mais comum entre iniciantes.

import requests

HEADERS = {
    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
                  "AppleWebKit/537.36 (KHTML, like Gecko) "
                  "Chrome/114.0.0.0 Safari/537.36",
    "Accept-Language": "en-US,en;q=0.9",
    "Cookie": "CONSENT=YES+cb",  # contorna a barreira de consentimento da UE
}

url = "https://www.youtube.com/@mkbhd/videos"
response = requests.get(url, headers=HEADERS)
print(response.status_code)  # Deve ser 200

O cookie CONSENT é essencial — sem ele, requisições vindas da região da UE são redirecionadas para consent.youtube.com, que entrega HTML sem nenhum ytInitialData.

Passo 2: analisar o HTML e localizar o script ytInitialData

Use BeautifulSoup ou regex para encontrar a tag <script> que contém var ytInitialData =:

import re
import json

# Extrair o JSON de ytInitialData
match = re.search(
    r"var ytInitialData\s*=\s*({.*?});</script>",
    response.text,
    re.DOTALL
)
if match:
    data = json.loads(match.group(1))
    print("ytInitialData extraído com sucesso")
else:
    print("ytInitialData não encontrado — verifique headers/cookies")

Um erro comum é usar um .*? não guloso com apenas }; como sentinela de fim. Terminadores de objetos aninhados aparecem o tempo todo dentro do JSON e vão cortar a captura antes da hora. Use };</script> como faz o scraper da Scrapfly em 2026 — essa é a última atribuição do bloco de script.

Passo 3: navegar pela estrutura do JSON para extrair os vídeos

O JSON é profundamente aninhado. Em vez de fixar caminhos que quebram sempre que o YouTube reorganiza a estrutura (o que acontece com frequência — o tracker de issues do yt-dlp documenta várias mudanças de formato desde 2023), use uma busca recursiva por chave:

def search_dict(partial, search_key):
    stack = [partial]
    while stack:
        cur = stack.pop()
        if isinstance(cur, dict):
            for k, v in cur.items():
                if k == search_key:
                    yield v
                else:
                    stack.append(v)
        elif isinstance(cur, list):
            stack.extend(cur)

# Extrair informações dos vídeos da página do canal
videos = []
for vr in search_dict(data, "videoRenderer"):
    videos.append({
        "video_id": vr.get("videoId"),
        "title": vr["title"]["runs"][0]["text"],
        "views": vr.get("viewCountText", {}).get("simpleText", "N/A"),
        "published": vr.get("publishedTimeText", {}).get("simpleText", "N/A"),
    })

print(f"Encontrados {len(videos)} vídeos")
for v in videos[:5]:
    print(f"  {v['title']} — {v['views']}")

Essa abordagem recursiva é a mesma que scrapetube, yt-dlp e Scrapfly acabaram adotando — ela sobrevive às reestruturações frequentes do JSON do YouTube.

Passo 4: exportar os dados extraídos para CSV ou Excel

import csv

with open("youtube_videos.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["video_id", "title", "views", "published"])
    writer.writeheader()
    writer.writerows(videos)

print("Dados exportados para youtube_videos.csv")

Quando usar este método — e quando não usar

Melhor para: extração rápida de metadados em poucas páginas de canal ou vídeo. Ferramentas leves de SEO. Análises pontuais em que você precisa de título, visualizações e data de envio.

Limitações: a estrutura do JSON muda — quebras já documentadas incluem a reformulação do botão de curtida (2023: toggleButtonRenderer → segmentedLikeDislikeButtonViewModel), a reformulação da descrição (2023: description.runs[] → attributedDescription.content) e o redesenho da aba Vídeos do canal (2022–2023: gridRenderer → richGridRenderer). IPs de datacenter normalmente são bloqueados de forma suave após 50–200 requisições. Sem comentários, sem transcrições.

Método 2: extrair dados do YouTube com Python usando Selenium ou Playwright

Quando você precisa interagir com a página — rolar resultados de busca, clicar em abas, expandir descrições — automação de navegador é o caminho.

• Dificuldade: Intermediária
• Tempo necessário: ~30 minutos
• O que você vai precisar: Python 3.10+, Playwright (pip install playwright && playwright install) ou Selenium + ChromeDriver

Eu recomendo Playwright em vez de Selenium para projetos novos. Os benchmarks da TestDino de 2026 mostram o Playwright como cerca de 1,85x mais rápido por ação, usando ~2,1x menos memória e com ~4x mais capacidade paralela em comparação com o Selenium. O Playwright usa um WebSocket persistente via Chrome DevTools Protocol, enquanto o Selenium usa WebDriver sobre HTTP, adicionando uma camada de tradução para cada comando.

Passo 1: configurar o Playwright

pip install playwright
playwright install chromium

from playwright.sync_api import sync_playwright

pw = sync_playwright().start()
browser = pw.chromium.launch(headless=False)  # com interface reduz parte da detecção
context = browser.new_context()

# Pré-carregar cookie de consentimento para contornar a barreira da UE
context.add_cookies([{
    "name": "SOCS",
    "value": "CAISNQgDEitib3FfaWRlbnRpdHlmcm9udGVuZHVpc2VydmVyXzIwMjMwODI5LjA3X3AxGgJlbiACGgYIgJnPpwY",
    "domain": ".youtube.com",
    "path": "/",
}])

page = context.new_page()

Passo 2: abrir uma página do YouTube e aguardar o carregamento do conteúdo

page.goto("https://www.youtube.com/@mkbhd/videos")
page.wait_for_selector("a#video-title-link", timeout=15000)
print("Página carregada — elementos de vídeo visíveis")

Se estiver extraindo resultados de busca, vá para https://www.youtube.com/results?search_query=sua+busca.

Passo 3: lidar com infinite scroll para carregar mais vídeos

O YouTube usa rolagem infinita nas páginas de canal e nos resultados de busca. Aqui está o loop clássico de scrollHeight, adaptado do guia da Scrapfly sobre rolagem:

prev_height = -1
max_scrolls = 20  # limite isso — um canal com 10 mil vídeos vai rolar para sempre
scroll_count = 0

while scroll_count < max_scrolls:
    page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
    page.wait_for_timeout(1500)  # aguarda o novo conteúdo carregar
    new_height = page.evaluate("document.body.scrollHeight")
    if new_height == prev_height:
        break  # nenhum novo conteúdo foi carregado
    prev_height = new_height
    scroll_count += 1

print(f"Rolou {scroll_count} vezes")

Passo 4: extrair os dados do vídeo a partir da página renderizada

video_elements = page.query_selector_all("a#video-title-link")
videos = []

for el in video_elements:
    title = el.inner_text()
    href = el.get_attribute("href")
    video_id = href.split("v=")[-1] if href else None
    videos.append({"title": title, "video_id": video_id, "url": f"https://www.youtube.com{href}"})

print(f"Extraídos {len(videos)} vídeos")

Para contagem de visualizações e data de envio, você vai precisar capturar elementos irmãos. O guia da Crawlee de 2025 alerta que id="video-title-link" não é universal — o YouTube publica várias variações de página. O fallback mais robusto é a[href*="watch"].

Passo 5: exportar para CSV ou Google Sheets

import csv

with open("youtube_playwright.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["title", "video_id", "url"])
    writer.writeheader()
    writer.writerows(videos)

browser.close()
pw.stop()

Quando usar este método — e quando não usar

Melhor para: extrair resultados de busca, interagir com elementos dinâmicos da página (clicar em abas, expandir descrições) e qualquer coisa que exija um DOM totalmente renderizado.

Limitações: lento (~1,5–3 segundos por vídeo em um fluxo de rolagem + extração). Alto risco de detecção anti-bot — o Selenium padrão define navigator.webdriver === true, que qualquer detecção no lado do JS identifica imediatamente. Consome muitos recursos (cada instância do navegador usa de 200 a 500 MB de RAM). Para 100 vídeos, espere algo entre 3 e 8 minutos, em vez de segundos com yt-dlp.

Método 3: extrair dados do YouTube com Python usando yt-dlp

yt-dlp é o canivete suíço do scraping no YouTube. É um fork comunitário do youtube-dl com mais de 157 mil estrelas no GitHub, releases noturnos ativos e suporte embutido para metadados, comentários, transcrições e scraping em lote — tudo sem precisar de navegador ou chave de API.

• Dificuldade: De iniciante a intermediário
• Tempo necessário: ~10 minutos
• O que você vai precisar: Python 3.10+, pip install yt-dlp

Passo 1: instalar o yt-dlp

pip install yt-dlp

Sem drivers de navegador, sem chaves de API, sem arquivos de configuração.

Passo 2: extrair metadados do vídeo sem baixar o arquivo

import yt_dlp

opts = {
    "quiet": True,
    "skip_download": True,      # sem bytes do vídeo — só metadados
    "no_warnings": True,
}

with yt_dlp.YoutubeDL(opts) as ydl:
    info = ydl.extract_info(
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
        download=False
    )

print(f"Título: {info['title']}")
print(f"Visualizações: {info['view_count']:,}")
print(f"Curtidas: {info.get('like_count', 'N/A')}")
print(f"Duração: {info['duration']}s")
print(f"Data de envio: {info['upload_date']}")
print(f"Canal: {info['channel']} ({info.get('channel_follower_count', 'N/A')} inscritos)")
print(f"Tags: {info.get('tags', [])[:5]}")

Uma chamada típica de extract_info retorna de 80 a 120 campos, dependendo do estado do vídeo: 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 muito mais.

Passo 3: extrair comentários de um vídeo do YouTube

opts = {
    "quiet": True,
    "skip_download": True,
    "getcomments": True,
    "extractor_args": {
        "youtube": {
            "max_comments": ["200", "50", "50", "10"],  # total, principais, respostas por comentário, respostas no total
            "comment_sort": ["top"],
        }
    },
}

with yt_dlp.YoutubeDL(opts) as ydl:
    info = ydl.extract_info(
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
        download=False
    )

comments = info.get("comments", [])
print(f"{len(comments)} comentários obtidos")
for c in comments[:3]:
    print(f"  [{c.get('like_count', 0)} curtidas] {c['author']}: {c['text'][:80]}...")

A extração de comentários é lenta. A Issue #3532 do yt-dlp relata a coleta de comentários a cerca de 30 KB/s — um vídeo com 100 mil comentários pode levar horas. A Issue #11849 documenta vídeos em que as URLs dos formatos expiram (~6 horas) antes de a paginação dos comentários terminar. Defina max_comments de forma agressiva para vídeos grandes.

Passo 4: extrair transcrições e legendas

Nem a YouTube Data API nem o parse com BS4 conseguem te dar transcrições completas. Esse é o grande diferencial do yt-dlp.

opts = {
    "quiet": True,
    "skip_download": True,
    "writesubtitles": True,
    "writeautomaticsub": True,
    "subtitleslangs": ["en", "en-orig"],
    "subtitlesformat": "json3",   # adequado para parsing por máquina: start/dur em ms + texto
    "outtmpl": "%(id)s.%(ext)s",
}

with yt_dlp.YoutubeDL(opts) as ydl:
    info = ydl.extract_info(
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
        download=False
    )

# Acessar os dados de legenda diretamente do dicionário info
auto_captions = info.get("automatic_captions", {})
manua_lsubs = info.get("subtitles", {})
print(f"Idiomas de legendas automáticas: {list(auto_captions.keys())[:10]}")
print(f"Idiomas de legendas manuais: {list(manua_lsubs.keys())}")

O formato json3 é o preferido para parsing por máquina — cada segmento traz start/dur em milissegundos e trechos de texto. Os códigos de idioma seguem BCP-47 (en, en-US, zh-Hans, ja, es).

Passo 5: fazer scraping em lote de vários vídeos ou de um canal inteiro

opts = {
    "quiet": True,
    "skip_download": True,
    "extract_flat": "in_playlist",  # rápido — só IDs e títulos dos vídeos
    "sleep_interval": 2,
    "max_sleep_interval": 6,
}

with yt_dlp.YoutubeDL(opts) as ydl:
    info = ydl.extract_info(
        "https://www.youtube.com/@mkbhd/videos",
        download=False
    )

entries = info.get("entries", [])
print(f"Encontrados {len(entries)} vídeos no canal")
for e in entries[:5]:
    print(f"  {e.get('title', 'N/A')} — {e.get('id')}")

Passe uma URL de canal, uma URL de playlist ou até uma busca (ytsearch10:python scraping) e o yt-dlp cuida da paginação internamente.

Quando usar este método — e quando não usar

Melhor para: extração em massa de metadados, comentários, transcrições, download de vídeos e varreduras de canal quando você precisa do conjunto completo de campos.

Limitações: não é o ideal para páginas de resultados de busca (Selenium/Playwright é melhor nisso). A corrida anti-bot de 2024–2026 tornou o yt-dlp mais complexo para operar em escala — o YouTube agora aplica BotGuard attestation e PO Tokens em alguns clientes. Em produção, instale o plugin bgutil-ytdlp-pot-provider e use --cookies-from-browser chrome (com uma conta descartável — a equipe do yt-dlp avisa que cookies de uma conta Google real podem levar a banimento dessa conta).

Método 4: extrair dados do YouTube com Python usando a YouTube Data API

A API oficial YouTube Data API v3 é a forma mais confiável e estruturada de obter dados do YouTube. As respostas vêm em JSON limpo, os campos são documentados e não existe a guerra de gato e rato do anti-bot. Mas há um detalhe que muitos tutoriais ignoram: o sistema de cota.

• Dificuldade: Intermediária
• Tempo necessário: ~20 minutos (incluindo a configuração da chave de API)
• O que você vai precisar: Python 3.10+, um projeto no Google Cloud, pip install google-api-python-client

Passo 1: obter uma chave da YouTube Data API

1. Acesse o Google Cloud Console
2. Crie um novo projeto (ou selecione um existente)
3. Vá em APIs & Services → Library → pesquise por "YouTube Data API v3" → Enable
4. Vá em APIs & Services → Credentials → Create Credentials → API Key
5. Copie a chave — você vai usá-la no código abaixo

Passo 2: fazer sua primeira chamada à API

from googleapiclient.discovery import build

API_KEY = "SUA_CHAVE_DE_API_AQUI"
youtube = build("youtube", "v3", developerKey=API_KEY)

# Buscar detalhes de um vídeo específico
response = youtube.videos().list(
    part="snippet,statistics,contentDetails",
    id="dQw4w9WgXcQ"
).execute()

video = response["items"][0]
print(f"Título: {video['snippet']['title']}")
print(f"Visualizações: {video['statistics']['viewCount']}")
print(f"Curtidas: {video['statistics'].get('likeCount', 'oculto')}")
print(f"Comentários: {video['statistics'].get('commentCount', 'desativado')}")
print(f"Duração: {video['contentDetails']['duration']}")
print(f"Tags: {video['snippet'].get('tags', [])[:5]}")

A resposta é limpa, tipada e documentada. Sem arqueologia em JSON.

Passo 3: extrair detalhes de vídeos, informações do canal e comentários

# Buscar vídeos
search_response = youtube.search().list(
    part="snippet",
    q="tutorial de web scraping em Python",
    type="video",
    maxResults=10,
    order="viewCount"
).execute()

for item in search_response["items"]:
    print(f"  {item['snippet']['title']} — {item['id']['videoId']}")

# Buscar comentários
comments_response = youtube.commentThreads().list(
    part="snippet",
    videoId="dQw4w9WgXcQ",
    maxResults=20,
    order="relevance"
).execute()

for item in comments_response["items"]:
    comment = item["snippet"]["topLevelComment"]["snippet"]
    print(f"  [{comment['likeCount']} curtidas] {comment['authorDisplayName']}: {comment['textDisplay'][:80]}")

A realidade das cotas da YouTube API (o que ninguém conta)

Esta é a parte que separa um guia útil de um tutorial de copiar e colar. A alocação padrão é de 10.000 unidades de cota por dia, com redefinição à meia-noite no horário do Pacífico. Veja quanto cada chamada custa:

Endpoint da API	Custo por chamada	Máximo por chamada
search.list	100 unidades	50 resultados
videos.list	1 unidade	50 IDs de vídeo (em lote)
channels.list	1 unidade	50 IDs de canal
commentThreads.list	1 unidade	100 comentários
captions.list	50 unidades	N/A

Agora a conta. Suponha que você queira extrair 1.000 resultados de busca:

• Chamadas de busca: 1.000 resultados ÷ 50 por página = 20 chamadas × 100 unidades = 2.000 unidades (20% do teu orçamento diário — já foi)
• Detalhes dos vídeos para esses 1.000 vídeos: 1.000 IDs ÷ 50 por lote = 20 chamadas × 1 unidade = 20 unidades (barato — o videos.list em lote é o grande alívio)
• Comentários desses 1.000 vídeos (assumindo 1 página por vídeo): 1.000 chamadas × 1 unidade = 1.000 unidades

Total: cerca de 3.020 unidades para uma extração modesta. Mas se esses vídeos tiverem threads longas de comentários (50+ páginas cada), você vai queimar as 7.000 unidades restantes bem rápido. Um vídeo com 50.000 comentários = ~500 páginas = 500 unidades. Faça isso com 20 vídeos e a cota do dia acaba.

O processo para aumento de cota exige uma auditoria de conformidade completa: URL da política de privacidade, URL dos termos de uso, vídeo mostrando o app e justificativa matemática da cota. Relatos da comunidade sugerem resposta típica do Google em 3–5 dias úteis, aprovação completa pode levar semanas ou meses, e muitos pedidos são negados — especialmente casos do tipo “quero mais dados para análise”.

Quando usar a API: escala pequena a média, quando você precisa de dados estruturados e confiáveis, quando comentários e estatísticas do canal importam, e quando você consegue conviver com o limite de cota.

Quando fazer scraping faz mais sentido: projetos em grande escala (>10 mil vídeos/dia), campos que a API não expõe (transcrições completas — captions.download exige OAuth + permissão do proprietário do vídeo), ou quando você precisa de mais de 500 resultados de busca por consulta (limite rígido da API, independentemente do totalResults).

O atalho sem código: extrair dados do YouTube com Thunderbit (sem Python)

Se você precisa de Python para uma pipeline de dados, use os Métodos 1–4 acima. Mas se precisa de dados do YouTube em 2 minutos — talvez você seja um profissional de marketing querendo comparar concorrentes, ou um desenvolvedor que só quer uma extração rápida sem configurar projeto nenhum — existe um caminho mais curto.

Thunderbit é uma extensão de AI web scraper para Chrome que criamos justamente para os casos em que escrever código é exagero. Ela funciona diretamente nas páginas do YouTube no teu navegador.

Como extrair dados do YouTube com Thunderbit em 3 passos

Passo 1: instale a extensão Thunderbit para Chrome e abra uma página de canal, uma página de resultados de busca ou uma página de vídeo no YouTube.

Passo 2: clique em "AI Suggest Fields" na barra lateral do Thunderbit. A IA lê a página e sugere colunas como título do vídeo, visualizações, data de envio, duração, nome do canal e URL da miniatura. Você pode adicionar, remover ou renomear colunas como quiser.

Passo 3: clique em "Scrape" e exporte para Google Sheets, Excel, CSV, Airtable ou Notion. Os dados caem numa tabela limpa, pronta para uso.

Experimente o Thunderbit para extrair dados do YouTube

Para quem isso é indicado

• Profissionais de marketing que precisam de dados de canais concorrentes, mas não programam
• Desenvolvedores que querem uma extração rápida sem criar ambiente virtual e instalar dependências
• Qualquer pessoa esbarrando em barreiras anti-bot — o Thunderbit faz o scraping na própria sessão autenticada do teu navegador, herdando cookies e tokens PO. Isso contorna vários bloqueios que atrapalham scrapers no lado do servidor
• O Thunderbit também pode usar subpage scraping para visitar cada página de vídeo e enriquecer a tabela com detalhes adicionais (curtidas, descrição, tags)

Para uma análise mais profunda de como o Thunderbit lida especificamente com o YouTube, confira o template Thunderbit YouTube Channel Scraper e o canal do Thunderbit no YouTube.

Dicas para extrair dados do YouTube com Python sem ser bloqueado

Essas dicas valem para todos os quatro métodos em Python. As medidas anti-bot do YouTube têm dificuldade 6/10 segundo a ScrapeOps, com três sinais principais: análise comportamental do IP, necessidade de execução de JS e estrutura HTML que muda com frequência.

Para todos os métodos:

• Alterne os User-Agents e o conjunto completo de headers — Accept, Accept-Language e os client hints Sec-CH-UA precisam bater com o UA declarado. O guia da ScraperAPI de 2026 tem uma lista atualizada.
• Adicione atrasos aleatórios de 2 a 8 segundos entre requisições. Intervalos fixos são um sinal de detecção.
• Use proxies residenciais para qualquer coisa além de poucas páginas. IPs de datacenter (AWS, GCP, Hetzner) estão praticamente mortos para scraping no YouTube em 2025–2026.
• Alterne sessão + IP juntos — o YouTube vincula sessões ao IP, e o mesmo cookie de sessão aparecendo em dois IPs é um sinal vermelho.

Para requests + BS4: defina o cookie CONSENT=YES+cb. Sem isso, requisições da UE são redirecionadas para uma página de consentimento sem dados.

Para Selenium/Playwright: rode com interface, usando xvfb em servidores Linux, em vez de --headless=new — o Chrome headless ainda entrega sinais de fingerprint suficientes para detectores mais sofisticados. Considere o playwright-stealth, que aplica cerca de 17 evasões.

Para yt-dlp: use as opções sleep_interval e max_sleep_interval. Instale o plugin bgutil-ytdlp-pot-provider para geração de PO Token. Use --cookies-from-browser chrome com uma conta descartável.

Para a API: monitore o uso de cota no Google Cloud Console e faça requisições em lote de forma eficiente. Uma única chamada videos.list com 50 IDs separados por vírgula custa 1 unidade — use isso a teu favor.

Para o Thunderbit: as medidas anti-bot são tratadas automaticamente, já que o scraping acontece na tua sessão do navegador. É basicamente como automatizar o que você faria manualmente.

É legal extrair dados do YouTube com Python?

Depende do que você extrai, de como você extrai e do que faz com os dados.

O cenário jurídico mudou em 2024 com Meta Platforms v. Bright Data (N.D. Cal., janeiro de 2024), quando o juiz Chen decidiu que os Termos de Serviço da Meta proíbem apenas scraping com login, não o scraping público sem login. Depois dessa decisão, extrair dados públicos ficou “significativamente menos arriscado”. Por outro lado, hiQ v. LinkedIn terminou com uma indenização de US$ 500 mil contra a hiQ por violação dos termos, violações da CFAA (contas falsas) e invasão de bens móveis — além de uma liminar permanente.

Os próprios Termos de Serviço do YouTube são explícitos: “Você não está autorizado a acessar o Serviço usando meios automatizados (como robôs, botnets ou scrapers)”, exceto com permissão prévia por escrito ou conforme permitido pela legislação aplicável. A YouTube Data API é a forma oficialmente autorizada de acessar os dados.

Algumas regras práticas:

• Extrair dados públicos visíveis para pesquisa pessoal ou análise não comercial geralmente traz menos risco
• A API é o caminho mais seguro — ela é explicitamente autorizada
• Evite extrair conteúdo privado ou protegido por login, baixar vídeos com copyright para redistribuição ou violar GDPR com dados pessoais de comentários
• Comentários do YouTube contêm dados pessoais sob o Art. 4(1) do GDPR — trate com cuidado as informações de titulares de dados da UE
• Consulte um advogado para projetos de scraping comercial

Nada disso é aconselhamento jurídico. O cenário muda rápido — uma nova onda de processos sob a DMCA §1201 movidos por criadores contra empresas de IA que fizeram scraping no YouTube para treinamento está redesenhando esse campo em 2025–2026.

Qual método você deve usar para extrair dados do YouTube com Python?

Guia de decisão:

• Precisa de metadados rápidos de poucas páginas? → Método 1 (requests + BS4). Rápido, leve, sem dependências além de requests e beautifulsoup4.
• Precisa extrair resultados de busca ou interagir com páginas dinâmicas? → Método 2 (Selenium/Playwright). Renderização completa no navegador, suporte a infinite scroll, mas lento e sujeito à detecção.
• Precisa de metadados em massa, comentários ou transcrições? → Método 3 (yt-dlp). A ferramenta única mais completa — mais de 157 mil estrelas por um motivo.
• Precisa de dados estruturados e confiáveis em escala moderada? → Método 4 (YouTube Data API). Oficial, limpa, mas limitada a 10.000 unidades/dia.
• Precisa dos dados em 2 minutos sem escrever código? → Thunderbit. Baseado no navegador, com IA, exporta para Google Sheets em poucos cliques.

Nenhum método cobre todos os casos de uso. Salve a tabela comparativa e a tabela de campos extraíveis acima — elas vão te poupar tempo no teu próximo projeto. E, se quiser explorar mais abordagens de web scraping, temos vários guias no blog da Thunderbit cobrindo desde tutoriais de scraping em Python até extração de dados para Google Sheets.

Experimente o Thunderbit para extrair dados do YouTube Get Started Free

Perguntas frequentes

Posso extrair dados do YouTube sem uma chave de API?

Sim. Os Métodos 1 (requests + BS4), 2 (Selenium/Playwright) e 3 (yt-dlp) não exigem chave de API. Só o Método 4 (YouTube Data API) precisa de uma. O Thunderbit também funciona sem chave de API — ele faz a extração diretamente no teu navegador.

Qual é a maneira mais rápida de extrair dados do YouTube com Python?

Em Python, yt-dlp e requests + BS4 são os mais rápidos — ambos evitam a sobrecarga de navegador e conseguem puxar metadados em segundos por vídeo. O yt-dlp é especialmente rápido em operações em lote porque cuida da paginação internamente. Para quem não usa Python, o Thunderbit é o mais rápido no geral porque não há tempo de configuração.

Como extrair comentários do YouTube com Python?

yt-dlp tem extração de comentários embutida via opção getcomments — é o caminho mais simples. A YouTube Data API também suporta comentários por meio de commentThreads.list (1 unidade de cota por chamada, até 100 comentários por página). Selenium/Playwright até consegue fazer isso rolando a página e extraindo os elementos renderizados, mas é lento e frágil.

Posso extrair Shorts do YouTube com Python?

Sim. O yt-dlp lida bem com metadados de Shorts — ele os trata como vídeos normais, com campos extras específicos de Shorts. A YouTube Data API tem suporte parcial (a contagem de visualizações de Shorts mudou em 30 de abril de 2025 — agora a métrica conta qualquer início de reprodução/replay). BS4 e Selenium/Playwright têm suporte limitado a Shorts, porque a vitrine de Shorts usa estruturas de DOM diferentes.

Quantos vídeos do YouTube posso extrair por dia?

Com a YouTube Data API, você fica limitado a cerca de 10.000 unidades de cota por dia. Usando chamadas em lote de videos.list (50 IDs por chamada por 1 unidade), isso dá até 500 mil consultas de estatísticas de vídeo por dia — mas search.list, com 100 unidades por chamada, consome o orçamento rapidamente. Com métodos de scraping (BS4, Selenium, yt-dlp), o limite é prático, não fixo: bloqueios de IP costumam começar após algumas centenas ou alguns milhares de requisições por IP por dia, dependendo da configuração de proxy e do padrão de requisições. O Thunderbit usa um sistema de créditos vinculado ao seu plano.

Saiba mais

• Como fazer web scraping com Python
• Playwright vs Puppeteer
• Melhores ferramentas automatizadas de web scraping
• Tutorial de Scrapy em Python
• Extrair dados do LinkedIn com Python