Scraper les données publiques YouTube avec des proxies résidentiels

Pourquoi scraper YouTube quand l'API officielle existe ?

Si vous travaillez dans l'analyse média ou la recherche sur la créateur-économie, vous connaissez le problème : la YouTube Data API v3 fonctionne bien… jusqu'à ce que vous atteigniez ses limites. Les quotas se consument vite, les endpoints sont restrictifs, et certains types de données — threads de commentaires massifs, détection précoce de tendances, surveillance publicitaire — restent inaccessibles via l'API officielle.

C'est là que l'extraction de données YouTube complémentaire entre en jeu. En combinant l'API officielle pour les besoins couverts et le scraping des endpoints internes pour le reste, vous construisez un pipeline de données complet. Mais Google surveille activement les requêtes automatisées, et les IP datacenter sont les premières bloquées. D'où la nécessité de proxies résidentiels fiables.

⚠️ Avertissement légal : Cet article concerne uniquement l'accès aux données publiques. Respectez les Conditions d'Utilisation de YouTube, le CFAA (États-Unis), le RGPD (UE), et toute loi applicable. Ne redistribuez jamais de transcriptions ou contenus vidéo scrappés sans autorisation du créateur. Quand une API officielle suffit, utilisez-la.

YouTube Data API v3 : quand elle suffit et quand elle ne suffit pas

L'API Data v3 est robuste pour les cas d'usage standards : recherche de vidéos, récupération de métadonnées, gestion de playlists. Mais elle a des contraintes sévères.

Coûts de quota par opération

En pratique, 100 requêtes de recherche épuisent votre quota quotidien. Pour de l'analyse de tendances nécessitant des milliers de recherches par heure, c'est rédhibitoire.

Ce que l'API ne couvre pas

• Threads de commentaires à grande échelle : L'API pagine lentement et ne retourne pas les réponses imbriquées de manière efficace au-delà de quelques niveaux.
• Détection précoce de tendances : Les vues en temps réel, les compteurs de likes minute par minute — l'API est trop lente et trop coûteuse en quota pour du polling haute fréquence.
• Surveillance publicitaire : L'API ne retourne aucune information sur les publicités diffusées avant ou pendant les vidéos.
• Transcriptions automatiques : Pas d'endpoint officiel pour les sous-titres générés automatiquement.
• Données de page de chaîne riches : Les bannières, liens externes, sections de playlists organisées ne sont pas exposées.

Pour ces cas d'usage, le scraping des endpoints internes de YouTube devient la seule option viable.

Données accessibles sans authentification

YouTube charge la majorité de ses données publiques via des appels XHR vers des endpoints internes — aucun login requis. Voici ce qui est accessible :

• Métadonnées vidéo : titre, description, vues, likes, date de publication, durée, tags (dans le player response).
• Pages de chaîne : nom, abonnés, nombre de vidéos, bannière, liens externes, sections de playlists.
• Threads de commentaires : commentaires de premier niveau et réponses, via les endpoints InnerTube.
• Transcriptions : sous-titres générés automatiquement et manuels, récupérables via l'API de timedtext ou des bibliothèques comme youtube-transcript-api.
• Related videos / suggestions : la sidebar de recommandations, accessible via les endpoints de continuation.

Ce qui nécessite un login : historique de visionnage, playlists privées, vidéos non listées (sans lien direct), commentaires sur des vidéos restreintes. Ne tentez pas de scraper ces données — c'est une violation claire des conditions d'utilisation.

L'API InnerTube de YouTube : anatomy d'un endpoint interne

YouTube utilise en interne une API appelée InnerTube, accessible via des endpoints REST sur /youtubei/v1/. Ces endpoints retournent du JSON structuré et sont utilisés par le frontend YouTube lui-même.

Endpoints clés

Structure d'une requête InnerTube

Chaque requête nécessite un corps JSON avec un context et un clientName. Voici un exemple minimal pour /youtubei/v1/next :

{
  "context": {
    "client": {
      "clientName": "WEB",
      "clientVersion": "2.20240101.00.00",
      "hl": "fr",
      "gl": "FR"
    }
  },
  "videoId": "dQw4w9WgXcQ"
}

Les continuation tokens sont la clé de la pagination. Chaque réponse contient des tokens de continuation pour charger la page suivante de commentaires ou de résultats. Vous les passez dans le champ continuation de la requête suivante.

Pourquoi les proxies résidentiels sont indispensables

Google est l'un des acteurs les plus agressifs en matière de détection d'automatisation. Voici pourquoi les proxies datacenter ne fonctionnent pas pour YouTube :

• Plages IP datacenter flaggées : Google maintient une base de données d'ASN datacenter. Les requêtes depuis ces plages sont immédiatement soumises à des CAPTCHAs ou bloquées (erreur 429).
• Empreinte de navigateur : Même avec des headers parfaits, une IP datacenter + un user-agent inhabituel = flag instantané.
• Rate limiting géographique : Google applique des limites différentes selon la région. Les IP résidentielles locales sont traitées plus favorablement.
• Rotation d'IP : Pour les scrapes à grande échelle, vous devez varier les IP toutes les quelques requêtes. Seuls les proxies résidentiels avec un pool massif le permettent.

Les proxies mobiles sont encore plus efficaces pour YouTube, car Google traite le trafic mobile avec moins de suspicion. Mais les proxies résidentiels offrent le meilleur rapport qualité-prix pour la plupart des cas d'usage.

Comparaison des types de proxies pour YouTube

Implémentation Python : scraping YouTube avec proxies résidentiels

Voici un pipeline complet qui combine l'API officielle, InnerTube et youtube-transcript-api, le tout routé via des proxies résidentiels ProxyHat.

1. Configuration du proxy

import requests

# Configuration ProxyHat - proxies résidentiels
PROXY_USER = "user-country-US"
PROXY_PASS = "votre_mot_de_passe"
PROXY_URL = f"http://{PROXY_USER}:{PROXY_PASS}@gate.proxyhat.com:8080"

PROXIES = {
    "http": PROXY_URL,
    "https": PROXY_URL,
}

# Headers imitant un navigateur réel
HEADERS = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
    "Accept-Language": "en-US,en;q=0.9",
    "Content-Type": "application/json",
}

# Context InnerTube par défaut
INNER_TUBE_CONTEXT = {
    "client": {
        "clientName": "WEB",
        "clientVersion": "2.20240610.00.00",
        "hl": "en",
        "gl": "US",
    }
}

2. Récupérer les métadonnées vidéo via InnerTube

def get_video_metadata(video_id: str) -> dict:
    """Récupère les métadonnées détaillées d'une vidéo via /youtubei/v1/player."""
    url = "https://www.youtube.com/youtubei/v1/player"
    payload = {
        "context": INNER_TUBE_CONTEXT,
        "videoId": video_id,
    }
    # Rotation : changer le pays dans le username pour varier l'IP
    resp = requests.post(url, json=payload, headers=HEADERS, proxies=PROXIES, timeout=15)
    resp.raise_for_status()
    data = resp.json()

    video_details = data.get("videoDetails", {})
    return {
        "video_id": video_id,
        "title": video_details.get("title"),
        "channel": video_details.get("author"),
        "views": video_details.get("viewCount"),
        "length_seconds": video_details.get("lengthSeconds"),
        "description": video_details.get("shortDescription"),
        "keywords": video_details.get("keywords", []),
        "is_live": video_details.get("isLiveContent", False),
    }

# Exemple d'utilisation
meta = get_video_metadata("dQw4w9WgXcQ")
print(f"{meta['title']} — {meta['views']} vues")

3. Scraper les commentaires avec continuation tokens

import time

def get_comments(video_id: str, max_pages: int = 10) -> list[dict]:
    """Scrape les commentaires d'une vidéo via /youtubei/v1/next et continuation tokens."""
    url = "https://www.youtube.com/youtubei/v1/next"
    payload = {
        "context": INNER_TUBE_CONTEXT,
        "videoId": video_id,
    }

    all_comments = []
    continuation_token = None

    for page in range(max_pages):
        if continuation_token:
            payload = {
                "context": INNER_TUBE_CONTEXT,
                "continuation": continuation_token,
            }

        resp = requests.post(url, json=payload, headers=HEADERS, proxies=PROXIES, timeout=20)
        resp.raise_for_status()
        data = resp.json()

        # Extraction des commentaires du JSON imbriqué
        # La structure varie — adaptez selon la réponse réelle
        contents = (
            data.get("onResponseReceivedEndpoints", [{}])
        )
        for endpoint in contents:
            comments = (
                endpoint.get("reloadContinuationItemsCommand", {})
                .get("continuationItems", [])
                or endpoint.get("appendContinuationItemsAction", {})
                .get("continuationItems", [])
            )
            for item in comments:
                comment_renderer = item.get("commentThreadRenderer", {})
                if not comment_renderer:
                    continue
                comment = comment_renderer.get("comment", {}).get("commentRenderer", {})
                all_comments.append({
                    "author": comment.get("authorText", {}).get("simpleText", ""),
                    "text": comment.get("contentText", {}).get("runs", [{}])[0].get("text", ""),
                    "likes": comment.get("voteCount", {}).get("simpleText", "0"),
                    "time": comment.get("publishedTimeText", {}).get("runs", [{}])[0].get("text", ""),
                })

        # Chercher le prochain continuation token
        next_token = None
        for endpoint in contents:
            items = (
                endpoint.get("reloadContinuationItemsCommand", {})
                .get("continuationItems", [])
                or endpoint.get("appendContinuationItemsAction", {})
                .get("continuationItems", [])
            )
            for item in items:
                token = item.get("continuationItemRenderer", {}).get("continuationEndpoint", {}).get("continuationCommand", {}).get("token")
                if token:
                    next_token = token
                    break

        if not next_token:
            break
        continuation_token = next_token

        # Pacing : 2-4 secondes entre les pages de commentaires
        time.sleep(2 + (page % 3))

    return all_comments

comments = get_comments("dQw4w9WgXcQ", max_pages=5)
print(f"Récupéré {len(comments)} commentaires")

4. Transcriptions avec youtube-transcript-api via proxy

from youtube_transcript_api import YouTubeTranscriptApi

# youtube-transcript-api ne supporte pas de proxy nativement,
# mais on peut utiliser les variables d'environnement ou monkey-patcher
import os
os.environ["HTTP_PROXY"] = PROXY_URL
os.environ["HTTPS_PROXY"] = PROXY_URL

def get_transcript(video_id: str, languages: list[str] = None) -> list[dict]:
    """Récupère la transcription d'une vidéo."""
    if languages is None:
        languages = ["en", "fr"]
    try:
        transcript = YouTubeTranscriptApi.get_transcript(video_id, languages=languages)
        return transcript  # Liste de dicts {text, start, duration}
    except Exception as e:
        print(f"Transcription non disponible pour {video_id}: {e}")
        return []

transcript = get_transcript("dQw4w9WgXcQ")
for entry in transcript[:5]:
    print(f"[{entry['start']:.1f}s] {entry['text']}")

Exemple Node.js : scraping avec rotation de proxy

const axios = require('axios');
const { HttpsProxyAgent } = require('https-proxy-agent');

const proxyUrl = 'http://user-country-US:votre_mot_de_passe@gate.proxyhat.com:8080';
const agent = new HttpsProxyAgent(proxyUrl);

const INNER_TUBE_CONTEXT = {
  client: {
    clientName: 'WEB',
    clientVersion: '2.20240610.00.00',
    hl: 'en',
    gl: 'US',
  }
};

async function getVideoMetadata(videoId) {
  const resp = await axios.post(
    'https://www.youtube.com/youtubei/v1/player',
    { context: INNER_TUBE_CONTEXT, videoId },
    {
      headers: {
        'Content-Type': 'application/json',
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
      },
      httpsAgent: agent,
      timeout: 15000,
    }
  );
  const details = resp.data.videoDetails || {};
  return {
    title: details.title,
    channel: details.author,
    views: details.viewCount,
    keywords: details.keywords || [],
  };
}

getVideoMetadata('dQw4w9WgXcQ')
  .then(d => console.log(d))
  .catch(e => console.error(e.message));

Stratégies de rotation et gestion du rate limiting

YouTube n'a pas de rate limit publié pour les endpoints InnerTube. En pratique, les blocages dépendent du comportement agrégé par IP et par session.

Bonnes pratiques

• Rotation par requête : Changez d'IP à chaque requête en utilisant le flag de rotation de ProxyHat (par défaut avec les proxies résidentiels sans session fixe).
• Sessions sticky pour les threads : Pour les commentaires avec continuation tokens, utilisez une session persistante le temps de paginer, puis changez d'IP : http://user-session-abc123:pass@gate.proxyhat.com:8080
• Pacing aléatoire : Ajoutez un délai aléatoire entre 1.5 et 5 secondes entre les requêtes. Jamais de rafale.
• Geo-ciblage cohérent : Si vous scrapez des vidéos françaises, utilisez des IP françaises : user-country-FR:pass@gate.proxyhat.com:8080
• Rotation des User-Agents : Maintenez une liste de 10-15 user-agents Chrome/Firefox récents et faites tourner.
• Limitez la concurrence : Maximum 3-5 requêtes simultanées par IP. Au-delà, le risque de CAPTCHA augmente drastiquement.

Gestion des CAPTCHAs

Si vous recevez un CAPTCHA (réponse avec action de type CAPTCHA), ne réessayez pas immédiatement :

• Changez d'IP via le proxy.
• Attendez 30-60 secondes.
• Réduisez votre fréquence de requêtes.
• Si le problème persiste sur une plage d'IP, changez de géolocalisation.

Risques d'empreinte digitale (fingerprinting)

Google ne se base pas uniquement sur l'IP. Les signaux de fingerprint incluent :

• TLS fingerprint (JA3/JA4) : Les bibliothèques HTTP comme requests ou axios ont des empreintes TLS différentes d'un vrai navigateur. Utilisez curl_cffi (Python) ou got-scraping (Node.js) pour imiter Chrome.
• Ordre des headers : Les vrais navigateurs envoient les headers dans un ordre spécifique. La plupart des bibliothèques HTTP les trient alphabétiquement.
• Comportement de navigation : Accéder directement à /youtubei/v1/next sans jamais charger la page associée est suspect. Envisagez de charger d'abord la page HTML.

Pour les scrapes de volume modéré (< 10 000 requêtes/jour), les headers et la rotation d'IP résidentielle suffisent généralement. Au-delà, investissez dans l'imitation TLS.

Quand utiliser l'API officielle plutôt que le scraping

Le scraping n'est pas toujours la bonne approche. Voici un cadre de décision :

Règle générale : Si l'API officielle couvre votre besoin dans les limites de quota, utilisez-la. C'est plus stable, mieux documenté, et légalement sans ambiguïté. Le scraping est un complément, pas un remplacement.

Éthique et légalité : le cadre à respecter

Le scraping de données publiques YouTube soulève des questions éthiques et légales réelles. Voici les principes à suivre :

Respect de la propriété des créateurs

• Les transcriptions, descriptions et commentaires appartiennent à leurs auteurs. Vous pouvez les analyser, pas les redistribuer.
• Ne republiez pas de transcriptions complètes, même modifiées, sans consentement du créateur.
• Les statistiques agrégées (tendances, volumes de commentaires) sont généralement acceptables.

Respect des Conditions d'Utilisation de YouTube

Les ToS de YouTube interdisent l'accès automatisé en dehors de l'API officielle. C'est un risque que vous assumez. Pour le minimiser :

• Limitez l'impact sur les serveurs (pacing, heures creuses).
• Ne scrapez jamais de données privées ou nécessitant un login.
• Ne contournez jamais les restrictions d'âge ou les blocages géographiques.

Cadre légal

• CFAA (US) : L'accès à des données publiques sans authentification est généralement considéré comme non-violateur, mais la jurisprudence évolue. Restez prudent.
• RGPD (UE) : Les commentaires contiennent des données personnelles (noms, opinions). Si vous traitez des données de résidents européens, vous avez des obligations (base légale, droit à l'oubli).
• Directive Copyright EU : Le scraping de contenu protégé pour créer des bases de données peut violer le droit voisin des éditeurs.

Quand arrêter et utiliser l'API

• Si votre scrape est petit (< 100 vidéos/jour), l'API suffit — utilisez-la.
• Si YouTube propose un endpoint API pour votre donnée, préférez-le toujours.
• Si vous devez vous connecter pour accéder à la donnée, c'est que ce n'est pas public — n'insistez pas.

Points clés à retenir

Key Takeaways

• L'API YouTube Data v3 est suffisante pour les petits volumes mais ses quotas rendent le scraping nécessaire pour l'analyse à grande échelle.
• Les endpoints InnerTube (/youtubei/v1/next, /youtubei/v1/player) donnent accès aux métadonnées, commentaires et suggestions sans authentification.
• Les proxies résidentiels sont indispensables : Google flagge les IP datacenter quasi immédiatement.
• La rotation d'IP, le pacing aléatoire et la cohérence géographique sont les piliers d'un scrape fiable.
• Les transcriptions sont accessibles via youtube-transcript-api mais ne doivent jamais être redistribuées sans autorisation.
• Toujours privilégier l'API officielle quand elle couvre le besoin — le scraping est un complément, pas un substitut.

Prochaines étapes

Si vous construisez un pipeline d'analyse média YouTube, commencez par :

1. Évaluer vos besoins réels par rapport aux quotas API.
2. Configurer des proxies résidentiels avec rotation via ProxyHat.
3. Implémenter d'abord le scraping des métadonnées vidéo (endpoint /player), le plus simple et le plus stable.
4. Ajouter progressivement les commentaires et transcriptions.
5. Mettre en place un monitoring du taux de succès pour ajuster le pacing.

Pour approfondir les stratégies de scraping web avec proxies, consultez notre guide sur le web scraping avec proxies résidentiels et notre page sur les cas d'usage de scraping.