Como coletar dados do YouTube para sistemas RAG: extração de legendas e metadados com Python

Sistemas RAG (Retrieval-Augmented Generation) requerem dados de qualidade para treinamento. O YouTube é uma enorme fonte de conteúdo estruturado: vídeos com legendas, metadados e comentários. Neste artigo, vamos explorar como coletar dados do YouTube de forma eficaz para RAG, evitando bloqueios e respeitando os limites da API.

O que é RAG e por que os dados do YouTube são necessários

RAG (Retrieval-Augmented Generation) é uma abordagem para construir sistemas de IA, onde um modelo de linguagem é complementado por uma base de conhecimento. Em vez de depender apenas dos dados nos quais o modelo foi treinado, o RAG extrai informações relevantes de uma fonte externa e as utiliza para gerar respostas.

O YouTube contém milhões de horas de conteúdo com legendas em diferentes idiomas. Isso torna a plataforma uma fonte valiosa de dados para sistemas RAG em várias áreas:

• Sistemas educacionais — palestras, tutoriais, cursos com timestamps
• Documentação técnica — guias em vídeo sobre programação, DevOps, configuração de software
• Bases de conhecimento médica — palestras de médicos, análises de casos clínicos
• Analytics de negócios — entrevistas com especialistas, estudos de caso, análises de mercado
• Suporte a produtos — análises de produtos, FAQs em formato de vídeo

A vantagem dos dados do YouTube é a presença de estrutura: legendas com timestamps, metadados (categorias, tags), contexto social (comentários, likes). Tudo isso ajuda o sistema RAG a entender não apenas o conteúdo, mas também o contexto da informação.

Quais dados do YouTube são úteis para sistemas RAG

Para o funcionamento eficaz de um sistema RAG, é necessário coletar vários tipos de dados. Cada tipo atende a suas próprias necessidades no processo de extração e geração de informações.

Legendas (Transcripts)

A principal fonte de dados textuais. O YouTube fornece dois tipos de legendas:

• Automáticas — geradas por algoritmos de reconhecimento de fala do Google. Disponíveis para a maioria dos vídeos em inglês e outros idiomas populares. Precisão de 85-95%, dependendo da qualidade do áudio.
• Manuais — carregadas pelos autores ou pela comunidade. Mais precisas, frequentemente contêm formatação e contexto adicional.

As legendas incluem timestamps, o que permite vincular o texto a momentos específicos do vídeo. Isso é crítico para criar referências precisas às fontes nas respostas do RAG.

Metadados do vídeo

Os metadados ajudam o sistema RAG a entender o contexto e a relevância da informação:

Comentários

Os comentários contêm contexto adicional: perguntas dos espectadores, esclarecimentos dos autores, discussões. Para sistemas RAG, isso é valioso, pois:

• Os comentários frequentemente contêm FAQs sobre o tema do vídeo
• Os autores podem publicar correções e adições
• As discussões revelam diferentes pontos de vista sobre o problema

Trabalhando com a YouTube Data API v3: configuração e limites

A YouTube Data API v3 é a maneira oficial de obter dados. Ela fornece acesso a metadados, estatísticas e comentários. As legendas são obtidas através de métodos separados.

Obtendo a chave da API

Para trabalhar com a API, você precisa de uma chave do Google Cloud Console:

1. Acesse console.cloud.google.com
2. Crie um novo projeto ou selecione um existente
3. Ative a YouTube Data API v3 na seção "APIs & Services"
4. Crie credenciais (Credentials) → chave da API
5. Copie a chave — ela será necessária para todas as solicitações

Limites e cotas

A API do YouTube utiliza um sistema de cotas. Cada solicitação "custa" uma certa quantidade de unidades:

O limite diário padrão é de 10.000 unidades. Isso equivale a aproximadamente 100 solicitações de busca ou 10.000 solicitações de metadados. Para aumentar a cota, é necessário solicitar ao Google.

Exemplo básico de uso da API

import requests

API_KEY = 'sua_chave_api'
BASE_URL = 'https://www.googleapis.com/youtube/v3'

# Busca de vídeos por consulta
def search_videos(query, max_results=10):
    url = f'{BASE_URL}/search'
    params = {
        'part': 'snippet',
        'q': query,
        'type': 'video',
        'maxResults': max_results,
        'key': API_KEY
    }
    
    response = requests.get(url, params=params)
    return response.json()

# Obtenção de metadados do vídeo
def get_video_details(video_id):
    url = f'{BASE_URL}/videos'
    params = {
        'part': 'snippet,contentDetails,statistics',
        'id': video_id,
        'key': API_KEY
    }
    
    response = requests.get(url, params=params)
    return response.json()

# Exemplo de uso
results = search_videos('tutorial de machine learning', max_results=5)
for item in results.get('items', []):
    video_id = item['id']['videoId']
    title = item['snippet']['title']
    print(f'ID: {video_id}, Título: {title}')
    
    # Obtemos informações detalhadas
    details = get_video_details(video_id)
    stats = details['items'][0]['statistics']
    print(f"Visualizações: {stats.get('viewCount')}, Likes: {stats.get('likeCount')}")

Parsing de legendas de vídeo: automáticas e manuais

A YouTube Data API v3 não fornece acesso direto às legendas. Para obtê-las, são utilizados métodos alternativos.

Uso da biblioteca youtube-transcript-api

A maneira mais simples é usar a biblioteca youtube-transcript-api para Python. Ela extrai legendas diretamente, sem chave de API:

from youtube_transcript_api import YouTubeTranscriptApi

# Obtenção de legendas
video_id = 'dQw4w9WgXcQ'

try:
    # Tentativa de obter legendas em russo, se não houver, em inglês
    transcript = YouTubeTranscriptApi.get_transcript(video_id, languages=['ru', 'en'])
    
    # Exibição das legendas com timestamps
    for entry in transcript:
        start_time = entry['start']
        duration = entry['duration']
        text = entry['text']
        print(f"[{start_time:.2f}s] {text}")
        
except Exception as e:
    print(f"Erro ao obter legendas: {e}")

# Obtenção da lista de idiomas disponíveis
transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
for transcript in transcript_list:
    print(f"Idioma: {transcript.language}, Automáticas: {transcript.is_generated}")

A biblioteca determina automaticamente as legendas disponíveis e pode traduzi-las para outros idiomas (se o YouTube fornecer essa possibilidade).

Processamento de timestamps para RAG

Para sistemas RAG, é importante manter a conexão entre o texto e os timestamps. Isso permite criar referências precisas às fontes:

def format_timestamp(seconds):
    """Conversão de segundos para o formato MM:SS"""
    minutes = int(seconds // 60)
    secs = int(seconds % 60)
    return f"{minutes:02d}:{secs:02d}"

def create_chunks_with_timestamps(transcript, chunk_size=500):
    """Divisão de legendas em chunks mantendo os timestamps"""
    chunks = []
    current_chunk = ""
    chunk_start_time = 0
    
    for i, entry in enumerate(transcript):
        if len(current_chunk) == 0:
            chunk_start_time = entry['start']
        
        current_chunk += entry['text'] + " "
        
        # Se atingirmos o tamanho desejado ou o fim das legendas
        if len(current_chunk) >= chunk_size or i == len(transcript) - 1:
            chunks.append({
                'text': current_chunk.strip(),
                'start_time': chunk_start_time,
                'timestamp': format_timestamp(chunk_start_time),
                'video_id': video_id
            })
            current_chunk = ""
    
    return chunks

# Uso
transcript = YouTubeTranscriptApi.get_transcript(video_id)
chunks = create_chunks_with_timestamps(transcript)

for chunk in chunks[:3]:  # Primeiros 3 chunks
    print(f"[{chunk['timestamp']}] {chunk['text'][:100]}...")

Coleta de metadados: títulos, descrições, tags

Os metadados enriquecem o contexto para o sistema RAG. Aqui está um exemplo completo de coleta de todos os dados necessários:

import requests
from datetime import datetime

def collect_video_metadata(video_id, api_key):
    """Coleta de metadados completos do vídeo"""
    url = f'https://www.googleapis.com/youtube/v3/videos'
    params = {
        'part': 'snippet,contentDetails,statistics,topicDetails',
        'id': video_id,
        'key': api_key
    }
    
    response = requests.get(url, params=params)
    data = response.json()
    
    if 'items' not in data or len(data['items']) == 0:
        return None
    
    item = data['items'][0]
    snippet = item['snippet']
    stats = item.get('statistics', {})
    content = item.get('contentDetails', {})
    
    metadata = {
        'video_id': video_id,
        'title': snippet['title'],
        'description': snippet['description'],
        'channel_title': snippet['channelTitle'],
        'channel_id': snippet['channelId'],
        'published_at': snippet['publishedAt'],
        'tags': snippet.get('tags', []),
        'category_id': snippet.get('categoryId'),
        'duration': content.get('duration'),
        'view_count': int(stats.get('viewCount', 0)),
        'like_count': int(stats.get('likeCount', 0)),
        'comment_count': int(stats.get('commentCount', 0)),
        'topics': item.get('topicDetails', {}).get('topicCategories', [])
    }
    
    return metadata

# Exemplo de uso
metadata = collect_video_metadata('dQw4w9WgXcQ', API_KEY)
print(f"Título: {metadata['title']}")
print(f"Canal: {metadata['channel_title']}")
print(f"Visualizações: {metadata['view_count']:,}")
print(f"Tags: {', '.join(metadata['tags'][:5])}")

Determinação da relevância do conteúdo

Para temas técnicos, a atualidade da informação é importante. Vamos adicionar uma função para avaliar a relevância:

from datetime import datetime, timedelta

def calculate_content_freshness(published_date_str):
    """Avaliação da relevância do conteúdo"""
    published_date = datetime.fromisoformat(published_date_str.replace('Z', '+00:00'))
    age_days = (datetime.now(published_date.tzinfo) - published_date).days
    
    if age_days < 30:
        return 'very_fresh'
    elif age_days < 180:
        return 'fresh'
    elif age_days < 365:
        return 'moderate'
    else:
        return 'old'

def calculate_quality_score(metadata):
    """Cálculo da pontuação de qualidade da fonte"""
    score = 0
    
    # Popularidade
    views = metadata['view_count']
    if views > 100000:
        score += 3
    elif views > 10000:
        score += 2
    elif views > 1000:
        score += 1
    
    # Engajamento (likes em relação às visualizações)
    if views > 0:
        like_ratio = metadata['like_count'] / views
        if like_ratio > 0.05:
            score += 2
        elif like_ratio > 0.02:
            score += 1
    
    # Relevância
    freshness = calculate_content_freshness(metadata['published_at'])
    if freshness == 'very_fresh':
        score += 2
    elif freshness == 'fresh':
        score += 1
    
    return score

# Uso
metadata = collect_video_metadata('dQw4w9WgXcQ', API_KEY)
quality = calculate_quality_score(metadata)
freshness = calculate_content_freshness(metadata['published_at'])
print(f"Pontuação de qualidade: {quality}/7")
print(f"Relevância: {freshness}")

Parsing de comentários para análise contextual

Os comentários podem conter informações valiosas: correções de erros no vídeo, recursos adicionais, perguntas frequentes. Para sistemas RAG, isso é um contexto adicional.

def get_video_comments(video_id, api_key, max_results=100):
    """Obtenção de comentários do vídeo"""
    url = 'https://www.googleapis.com/youtube/v3/commentThreads'
    comments = []
    next_page_token = None
    
    while len(comments) < max_results:
        params = {
            'part': 'snippet',
            'videoId': video_id,
            'maxResults': min(100, max_results - len(comments)),
            'order': 'relevance',  # Ordenação por relevância
            'key': api_key
        }
        
        if next_page_token:
            params['pageToken'] = next_page_token
        
        response = requests.get(url, params=params)
        data = response.json()
        
        if 'items' not in data:
            break
        
        for item in data['items']:
            top_comment = item['snippet']['topLevelComment']['snippet']
            comments.append({
                'author': top_comment['authorDisplayName'],
                'text': top_comment['textDisplay'],
                'like_count': top_comment['likeCount'],
                'published_at': top_comment['publishedAt'],
                'reply_count': item['snippet']['totalReplyCount']
            })
        
        next_page_token = data.get('nextPageToken')
        if not next_page_token:
            break
    
    return comments

def filter_valuable_comments(comments, min_likes=5):
    """Filtragem de comentários valiosos"""
    valuable = []
    
    for comment in comments:
        # Critérios de valor:
        # 1. Muitos likes (popularidade)
        # 2. Existem respostas (gerou discussão)
        # 3. Texto longo (comentário detalhado)
        
        if (comment['like_count'] >= min_likes or 
            comment['reply_count'] > 0 or 
            len(comment['text']) > 200):
            valuable.append(comment)
    
    return valuable

# Uso
comments = get_video_comments('dQw4w9WgXcQ', API_KEY, max_results=50)
valuable_comments = filter_valuable_comments(comments)

print(f"Total de comentários: {len(comments)}")
print(f"Comentários valiosos: {len(valuable_comments)}")

for comment in valuable_comments[:3]:
    print(f"\n[{comment['like_count']} likes] {comment['author']}:")
    print(comment['text'][:200])

Uso de proxies para escalabilidade na coleta de dados

Ao coletar dados em grande escala, surgem dois problemas: limites da API do YouTube (10.000 cotas por dia) e bloqueios ao fazer parsing de legendas. Os proxies ajudam a resolver ambos os problemas.

Quando são necessários proxies para parsing do YouTube

• Excesso de cotas da API — usando várias chaves de API através de diferentes IPs, é possível aumentar o limite diário
• Parsing de legendas contornando a API — a biblioteca youtube-transcript-api faz solicitações diretas, que podem ser bloqueadas em alta frequência
• Coleta de dados de diferentes regiões — alguns vídeos estão disponíveis apenas em determinados países
• Coleta paralela — distribuição da carga em vários IPs para acelerar o processo

Escolha do tipo de proxy

Para a maioria das tarefas, os proxies residenciais são adequados para sistemas RAG — eles oferecem um equilíbrio entre custo e confiabilidade ao fazer parsing em grande escala.

Configuração de proxies no código

import requests
from youtube_transcript_api import YouTubeTranscriptApi
from youtube_transcript_api._api import TranscriptListFetcher

# Configuração de proxy
PROXY = {
    'http': 'http://username:password@proxy-server:port',
    'https': 'http://username:password@proxy-server:port'
}

# Para trabalhar com a API através de proxy
def get_video_details_with_proxy(video_id, api_key, proxy):
    url = f'https://www.googleapis.com/youtube/v3/videos'
    params = {
        'part': 'snippet,statistics',
        'id': video_id,
        'key': api_key
    }
    
    response = requests.get(url, params=params, proxies=proxy, timeout=10)
    return response.json()

# Para parsing de legendas através de proxy
class ProxiedTranscriptApi:
    def __init__(self, proxy):
        self.proxy = proxy
    
    def get_transcript(self, video_id, languages=['en']):
        # Criamos uma sessão customizada com proxy
        session = requests.Session()
        session.proxies = self.proxy
        
        # Usamos a sessão para as solicitações
        fetcher = TranscriptListFetcher(session)
        transcript_list = fetcher.fetch(video_id)
        
        # Obtemos o idioma desejado
        for lang in languages:
            try:
                transcript = transcript_list.find_transcript([lang])
                return transcript.fetch()
            except:
                continue
        
        raise Exception(f"Legendas não encontradas para os idiomas: {languages}")

# Uso
api = ProxiedTranscriptApi(PROXY)
transcript = api.get_transcript('dQw4w9WgXcQ', languages=['ru', 'en'])
print(f"Obtido {len(transcript)} segmentos de legendas")

Rotação de proxies para escalabilidade

Ao coletar dados de milhares de vídeos, é importante distribuir a carga entre vários proxies:

import random
import time

class ProxyRotator:
    def __init__(self, proxy_list):
        self.proxies = proxy_list
        self.current_index = 0
    
    def get_next_proxy(self):
        """Rotação sequencial"""
        proxy = self.proxies[self.current_index]
        self.current_index = (self.current_index + 1) % len(self.proxies)
        return proxy
    
    def get_random_proxy(self):
        """Rotação aleatória"""
        return random.choice(self.proxies)

# Lista de proxies
PROXY_LIST = [
    {'http': 'http://user:pass@proxy1:port', 'https': 'http://user:pass@proxy1:port'},
    {'http': 'http://user:pass@proxy2:port', 'https': 'http://user:pass@proxy2:port'},
    {'http': 'http://user:pass@proxy3:port', 'https': 'http://user:pass@proxy3:port'},
]

rotator = ProxyRotator(PROXY_LIST)

def collect_data_with_rotation(video_ids):
    results = []
    
    for video_id in video_ids:
        proxy = rotator.get_next_proxy()
        
        try:
            # Obtemos metadados
            metadata = get_video_details_with_proxy(video_id, API_KEY, proxy)
            
            # Obtemos legendas
            api = ProxiedTranscriptApi(proxy)
            transcript = api.get_transcript(video_id)
            
            results.append({
                'video_id': video_id,
                'metadata': metadata,
                'transcript': transcript
            })
            
            # Atraso entre solicitações
            time.sleep(1)
            
        except Exception as e:
            print(f"Erro para {video_id}: {e}")
            continue
    
    return results

# Uso
video_ids = ['video1', 'video2', 'video3', 'video4', 'video5']
data = collect_data_with_rotation(video_ids)
print(f"Dados coletados para {len(data)} vídeos")

Processamento e preparação de dados para RAG

Após a coleta de dados, é necessário processá-los e estruturá-los para o funcionamento eficaz dos sistemas RAG.

Criação de embeddings vetoriais

Sistemas RAG utilizam busca vetorial para encontrar fragmentos relevantes. É necessário transformar o texto em embeddings:

from sentence_transformers import SentenceTransformer
import numpy as np

# Carregamento do modelo para criação de embeddings
model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')

def create_embeddings_from_transcript(transcript_chunks):
    """Criação de embeddings para chunks de legendas"""
    embeddings = []
    
    for chunk in transcript_chunks:
        # Combinamos o texto com metadados para melhor contexto
        text_with_context = f"{chunk['title']} | {chunk['text']}"
        
        # Criamos o embedding
        embedding = model.encode(text_with_context)
        
        embeddings.append({
            'video_id': chunk['video_id'],
            'timestamp': chunk['timestamp'],
            'text': chunk['text'],
            'embedding': embedding.tolist(),
            'metadata': {
                'title': chunk['title'],
                'channel': chunk['channel'],
                'views': chunk['views']
            }
        })
    
    return embeddings

# Preparação dos dados
def prepare_rag_data(video_data):
    """Preparação de todos os dados para RAG"""
    all_chunks = []
    
    for video in video_data:
        metadata = video['metadata']
        transcript = video['transcript']
        
        # Dividimos as legendas em chunks
        chunks = create_chunks_with_timestamps(transcript)
        
        # Adicionamos metadados a cada chunk
        for chunk in chunks:
            chunk['title'] = metadata['title']
            chunk['channel'] = metadata['channel_title']
            chunk['views'] = metadata['view_count']
            all_chunks.append(chunk)
    
    # Criamos embeddings
    embeddings = create_embeddings_from_transcript(all_chunks)
    
    return embeddings

# Uso
rag_data = prepare_rag_data(collected_videos)
print(f"Preparados {len(rag_data)} fragmentos para RAG")

Armazenamento em banco de dados vetorial

Para busca eficaz, os embeddings são armazenados em bancos de dados especializados. Opções populares: Pinecone, Weaviate, Qdrant, ChromaDB.

import chromadb
from chromadb.config import Settings

# Inicialização do ChromaDB (banco de dados vetorial local)
client = chromadb.Client(Settings(
    chroma_db_impl="duckdb+parquet",
    persist_directory="./youtube_rag_db"
))

# Criação da coleção
collection = client.create_collection(
    name="youtube_transcripts",
    metadata={"description": "Transcrições de vídeos do YouTube para RAG"}
)

def store_in_vector_db(embeddings_data, collection):
    """Armazenamento de embeddings em banco de dados vetorial"""
    
    ids = []
    embeddings = []
    documents = []
    metadatas = []
    
    for i, item in enumerate(embeddings_data):
        ids.append(f"{item['video_id']}_{i}")
        embeddings.append(item['embedding'])
        documents.append(item['text'])
        metadatas.append({
            'video_id': item['video_id'],
            'timestamp': item['timestamp'],
            'title': item['metadata']['title'],
            'channel': item['metadata']['channel'],
            'views': str(item['metadata']['views']),
            'youtube_url': f"https://youtube.com/watch?v={item['video_id']}&t={int(float(item['timestamp'].split(':')[0])*60 + float(item['timestamp'].split(':')[1]))}s"
        })
    
    # Adição à coleção
    collection.add(
        ids=ids,
        embeddings=embeddings,
        documents=documents,
        metadatas=metadatas
    )
    
    print(f"Armazenados {len(ids)} embeddings no banco de dados vetorial")

# Uso
store_in_vector_db(rag_data, collection)

Busca e geração de respostas

O passo final é implementar a busca RAG e a geração de respostas:

def search_youtube_knowledge(query, collection, model, top_k=3):
    """Busca de fragmentos relevantes do YouTube"""
    
    # Criamos o embedding da consulta
    query_embedding = model.encode(query).tolist()
    
    # Busca no banco de dados vetorial
    results = collection.query(
        query_embeddings=[query_embedding],
        n_results=top_k
    )
    
    # Formatação dos resultados
    sources = []
    for i in range(len(results['ids'][0])):
        sources.append({
            'text': results['documents'][0][i],
            'metadata': results['metadatas'][0][i],
            'distance': results['distances'][0][i] if 'distances' in results else None
        })
    
    return sources

def generate_rag_answer(query, sources, llm_api_key):
    """Geração de resposta com base nas fontes encontradas"""
    
    # Formamos o contexto a partir das fontes encontradas
    context = "\n\n".join([
        f"Fonte: {s['metadata']['title']} ({s['metadata']['timestamp']})\n{s['text']}"
        for s in sources
    ])
    
    # Prompt para LLM
    prompt = f"""Com base nos seguintes fragmentos de vídeos do YouTube, responda à pergunta do usuário.
Certifique-se de indicar as fontes com timestamps.

Contexto:
{context}

Pergunta: {query}

Resposta:"""
    
    # Aqui você chamaria sua LLM (OpenAI, Claude, modelo local)
    # Exemplo com OpenAI:
    # response = openai.ChatCompletion.create(
    #     model="gpt-4",
    #     messages=[{"role": "user", "content": prompt}]
    # )
    # answer = response.choices[0].message.content
    
    # Para exemplo, retornamos o prompt
    return {
        'answer': 'Aqui estará a resposta da LLM',
        'sources': sources
    }

# Uso
query = "Como configurar proxies em Python?"
sources = search_youtube_knowledge(query, collection, model, top_k=3)

print("Fontes encontradas:")
for source in sources:
    print(f"\n{source['metadata']['title']}")
    print(f"Tempo: {source['metadata']['timestamp']}")
    print(f"Link: {source['metadata']['youtube_url']}")
    print(f"Texto: {source['text'][:200]}...")

Otimização da qualidade do RAG

Algumas dicas para melhorar a qualidade do sistema RAG com dados do YouTube:

• Filtre conteúdo de baixa qualidade — use métricas de visualizações, likes, data de publicação
• Mantenha o contexto — adicione o título do vídeo e do canal a cada chunk de texto
• Otimize o tamanho dos chunks — para conteúdo técnico, 300-500 palavras é ideal
• Use metadados para ranqueamento — conteúdo mais recente e popular pode ter prioridade
• Adicione comentários — eles frequentemente contêm esclarecimentos importantes e FAQs
• Verifique a disponibilidade dos vídeos — alguns vídeos podem ser removidos ou se tornarem privados

Conclusão

A coleta de dados do YouTube para sistemas RAG é um processo em várias etapas, que inclui trabalho com a API, parsing de legendas, processamento de metadados e criação de embeddings vetoriais. Pontos-chave:

• A YouTube Data API v3 fornece metadados, estatísticas e comentários com um limite de 10.000 cotas por dia
• As legendas são extraídas através da biblioteca youtube-transcript-api ou solicitações diretas
• Os timestamps são críticos para criar referências precisas às fontes
• Os metadados (visualizações, likes, data) ajudam a avaliar a qualidade e a relevância do conteúdo
• Os comentários adicionam contexto e frequentemente contêm FAQs
• Os proxies são necessários para escalabilidade e contorno de limites
• Os embeddings vetoriais e bancos de dados especializados garantem busca semântica rápida

Com a configuração correta do processo, é possível coletar dezenas de milhares de fragmentos de conteúdo de qualidade por dia, criando uma poderosa base de conhecimento para sistemas RAG em qualquer área temática.

Se você planeja uma coleta em larga escala de dados do YouTube contornando limites e bloqueios, recomendamos o uso de proxies residenciais — eles garantem estabilidade ao fazer parsing de milhares de vídeos e minimizam o risco de bloqueios por parte do YouTube.