Comment récupérer des données sur YouTube avec Python en 2026

Si vous avez déjà atteint la limite de quota de l’API de données YouTube v3 au milieu d’une session de recherche, vous savez déjà pourquoi les développeurs apprennent à scraper YouTube directement. L’API officielle est claire et bien documentée, mais son budget quotidien de 10 000 unités s’épuise rapidement dès que vous commencez à search.list ou d'extraire des fils de commentaires en profondeur. Le scraping web de YouTube comble cette lacune, et les données sont bien plus riches que celles exposées par l'API : arbres de commentaires complets, transcriptions, balises, nombre de « J'aime », Shorts et catalogues de vidéos des chaînes.

Ce guide s’adresse aux développeurs Python, aux ingénieurs de données, aux analystes de croissance et de référencement, ainsi qu’aux professionnels de l’IA/ML qui ont besoin de données YouTube en masse pour l’analyse, les pipelines RAG ou l’étude de la concurrence. Nous passerons d’un démarrage rapide sans clé API à des extractions de niveau production à l’aide de yt-dlp, de points de terminaison cachés /youtubei/v1/ et une API de scraping gérée. Chaque section fournit du code Python exécutable, et les exemples supposent l'utilisation de Python 3.11 ou une version plus récente.

À la fin, vous disposerez d’une matrice claire de sélection des méthodes, d’un code fonctionnel pour les sept tâches de scraping YouTube les plus courantes, d’une couche anti-blocage capable de résister au trafic réel, et d’une liste de contrôle juridique qui vous évitera de voir votre projet fermé. C’est parti.

YouTube est le deuxième moteur de recherche au monde et la plus grande archive de commentaires vidéo de longue durée, toutes langues confondues. Cela en fait une mine d'or pour trois tâches que l'API Data officielle n'a jamais été conçue pour gérer à grande échelle.

L'analyse des créateurs et des concurrents. Extraire l'historique complet des publications d'un concurrent, avec le nombre de vues, la durée, les balises et la fréquence de publication, permet de révéler quels formats fonctionnent réellement, et pas seulement ceux que l'algorithme de YouTube met en avant aujourd'hui.

Sentiment de l'audience et recherche sur les produits. Les fils de commentaires sous les avis sur les produits, les tutoriels et les déballages comptent parmi les textes générés par les utilisateurs les plus honnêtes du web ouvert. Les modèles de sentiment entraînés sur les commentaires YouTube ont tendance à bien généraliser, car le style d'écriture est conversationnel et subjectif.

SEO, tendances et données RAG. Les transcriptions, les titres et les commentaires les plus populaires vous fournissent un contenu textuel propre qu’un pipeline de génération augmentée par la recherche peut segmenter et intégrer sans avoir à extraire le fichier vidéo lui-même. C’est ce cas d’utilisation qui a poussé la plupart des équipes à abandonner l’API Data pour apprendre à extraire YouTube de manière programmatique.

Quel que soit votre objectif, considérez cet article comme un guide pratique méthode par méthode plutôt que comme un tutoriel sur un outil unique. À chaque tâche ses outils.

Il existe aujourd’hui quatre méthodes réalistes pour apprendre à extraire des données de YouTube en Python, et un mauvais choix peut épuiser votre quota, vous faire bloquer ou tout simplement ne pas vous fournir les champs dont vous avez besoin. Choisissez d’abord, codez ensuite.

Deux schémas se retrouvent dans les trois dernières lignes : l'extraction de JSON intégré dans des balises script (ytInitialPlayerResponse, ytInitialData) et la réplication des appels XHR internes déclenchés par l'application SPA de YouTube. Les deux renvoient des données structurées sans lancer de navigateur sans interface, ce qui permet de garder des requêtes rapides et peu coûteuses. N'utilisez un vrai navigateur que lorsque vous devez vous connecter ou déclencher un événement piloté par l'interface utilisateur.

Si vous vous demandez encore lequel choisir avant d'écrire du code, les deux sous-sections suivantes vous aideront à trancher.

L'API Data v3 est le choix le plus sûr pour obtenir des données propres et structurées en faible volume. Elle renvoie des identifiants canoniques, des statistiques officielles et des schémas stables, et vous restez en conformité avec les Conditions d'utilisation de YouTube par nature.

Le hic, c'est le calcul des unités. Selon la documentation de l'API YouTube Data, chaque projet commence avec un quota quotidien par défaut (actuellement d'environ 10 000 unités, mais vérifiez dans la Google Cloud Console car Google ajuste ce chiffre). Un videos.list appel coûte environ 1 unité, tandis qu’un search.list appel coûte environ 100 unités ; une seule session de recherche approfondie peut donc épuiser le budget d'une journée entière en quelques minutes. Vérifiez les coûts unitaires exacts dans la documentation officielle avant de vous engager à utiliser uniquement l'API.

Utilisez l'API lorsque vous avez besoin de quelques milliers d'enregistrements vidéo par jour avec des champs stables et aucune exposition aux bots. Au-delà de cela, optez pour le scraping.

Passez au web scraping dès que l'une des conditions suivantes est remplie :

• Vous avez besoin de métadonnées en masse pour des milliers de vidéos par jour.
• Vous avez besoin de fils de commentaires complets avec les réponses, l'ordre de tri ou le pseudonyme de l'auteur du commentaire.
• Vous avez besoin de transcriptions ou de sous-titres générés automatiquement par programmation.
• Vous avez besoin que les YouTube Shorts soient clairement filtrés des résultats de recherche.
• Vous avez besoin de catalogues de vidéos de chaînes plus complets que ce que vous offre la réponse paginée de l'API.
• Vous avez besoin de n'importe quel champ qui n'est tout simplement pas exposé par l'API (les balises sur la plupart des vidéos, par exemple).

La matrice de décision présentée sur cette page constitue délibérément la première ressource pour toute personne souhaitant apprendre à extraire des données de YouTube en 2026, car choisir le mauvais outil est l'erreur la plus coûteuse que vous puissiez commettre sur cette plateforme.

Avant d'exécuter le code de scraping YouTube ci-dessous, configurez un projet Python 3.11+ vierge afin que les dépendances n'entrent pas en conflit avec vos autres outils.

mkdir youtube-scraper && cd youtube-scraper
python -m venv .venv
source .venv/bin/activate   # Windows: .venv\Scripts\activate
pip install --upgrade yt-dlp requests beautifulsoup4 parsel \
            jsonpath-ng youtube-transcript-api

Cette installation unique couvre tout ce qui est présenté dans ce guide :

• yt-dlp pour les métadonnées vidéo, les commentaires et les sous-titres.
• requests + BeautifulSoup4 pour les pages HTML et l' <script> astuce de balise.
• parsel pour le CSS/XPath lorsque BeautifulSoup semble trop verbeux.
• jsonpath-ng pour parcourir les réponses profondément imbriquées /youtubei/v1/ .
• youtube-transcript-api comme raccourci pour obtenir une transcription en un seul appel.

Deux termes que vous verrez partout. Le scraping de données cachées extrait un blob JSON d’une <script> balise dans le code HTML de la page ; sur YouTube, l'exemple canonique est ytInitialPlayerResponse. Le scraping d’API cachées reproduit les appels XHR/fetch internes effectués par l’application monopage de YouTube, en interrogeant /youtubei/v1/ directement les points de terminaison pour recevoir du JSON structuré. Ces deux méthodes évitent le DOM rendu, ce qui rend les scrapers plus rapides et moins fragiles que l'analyse de la mise en page visuelle. Une fois ces concepts en main, le guide de démarrage rapide sans clé API n'est plus qu'à quelques lignes.

La méthode la plus rapide pour scraper YouTube sans clé consiste à récupérer une page de visionnage, à extraire le ytInitialPlayerResponse et d'y lire tout ce dont vous avez besoin. Pas de projet API, pas d'OAuth, pas de navigateur headless.

import json, re, requests

VIDEO_URL = 'https://www.youtube.com/watch?v=dQw4w9WgXcQ'
HEADERS = {
    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) '
                  'AppleWebKit/537.36 (KHTML, like Gecko) '
                  'Chrome/124.0 Safari/537.36',
    'Accept-Language': 'en-US,en;q=0.9',
}

html = requests.get(VIDEO_URL, headers=HEADERS, timeout=15).text
match = re.search(r'ytInitialPlayerResponse\s*=\s*(\{.+?\})\s*;', html)
data = json.loads(match.group(1))

details = data['videoDetails']
print(details['title'])
print(details['author'])
print(details['viewCount'])
print(details['lengthSeconds'])

Cet extrait de code représente environ 90 % de ce pour quoi la plupart des lecteurs sont venus ici : une réponse concrète à la question de savoir comment extraire les métadonnées d'une vidéo YouTube sans clé API. L'expression régulière cible la ligne d'affectation que YouTube utilise depuis des années, mais considérez-la comme une cible mouvante. Si une requête renvoie une page vide ou si l'expression régulière échoue, YouTube vous a probablement redirigé vers un cookie de consentement (nous y reviendrons plus tard), ou a modifié le balisage entourant la balise script. Nous renforçons cela dans la section anti-blocage.

ytInitialPlayerResponse est idéal pour quelques champs. Pour les champs plus spécifiques (formats, nombre de vues, date de mise en ligne, toutes les balises, sous-titres automatiques, liste des chapitres), optez pour yt-dlp. Il s'agit d'un fork maintenu par la communauté de youtube-dl offrant un ensemble de fonctionnalités plus large et des mises à jour régulières ; consultez le dépôt GitHub de yt-dlp pour connaître les indicateurs d'options et les champs disponibles avant de vous fier à un nom de champ spécifique.

yt-dlp extract_info(download=False) renvoie un dictionnaire Python plat contenant un grand nombre de champs couvrant le titre, le nombre de vues et de « J'aime », la date de mise en ligne, les balises, les vignettes et tous les formats multimédias disponibles. Le nombre exact de champs varie d'une version à l'autre, il ne faut donc pas coder en dur vos attentes.

import json
import yt_dlp

VIDEO_URL = 'https://www.youtube.com/watch?v=dQw4w9WgXcQ'

ydl_opts = {
    'quiet': True,
    'skip_download': True,
    # 'cookiesfrombrowser': ('chrome',),  # for age-gated content
}

with yt_dlp.YoutubeDL(ydl_opts) as ydl:
    info = ydl.extract_info(VIDEO_URL, download=False)

keys_we_care_about = (
    'id', 'title', 'channel', 'channel_id', 'upload_date',
    'duration', 'view_count', 'like_count', 'tags',
    'categories', 'description',
)
flat = {k: info.get(k) for k in keys_we_care_about}
print(json.dumps(flat, indent=2, ensure_ascii=False))

Deux indicateurs que vous utiliserez souvent :

• 'cookiesfrombrowser': ('chrome',) permet à yt-dlp de réutiliser la session de votre navigateur pour les vidéos soumises à une restriction d'âge, verrouillées par région ou réservées aux membres.
• 'extract_flat': 'in_playlist' ignore les appels de métadonnées par vidéo lorsque vous n'avez besoin que des identifiants vidéo de la playlist.

Pour conserver le résultat, exportez le dictionnaire au format JSON Lines (un enregistrement par ligne) afin de pouvoir ajouter de nouvelles vidéos sans réécrire le fichier :

with open('videos.jsonl', 'a', encoding='utf-8') as f:
    f.write(json.dumps(flat, ensure_ascii=False) + '\n')

yt-dlp s'autorégule et gère de nombreux cas particuliers (diffusions en direct, avant-premières, contenu réservé aux membres) sans code supplémentaire, ce qui en fait l'outil par défaut lorsque les équipes cherchent à extraire des données vidéo YouTube par programmation sans mettre en place une pile anti-bot complète.

Les commentaires sont la raison la plus courante pour laquelle les équipes dépassent les limites de l'API Data. L' commentThreads point de terminaison impose un quota élevé et ne fournit qu'un nombre limité de réponses, tandis que yt-dlp récupère un nombre configurable de réponses en un seul appel. C'est là que scrape YouTube comments Python les choses deviennent sérieuses.

import yt_dlp

VIDEO_URL = 'https://www.youtube.com/watch?v=dQw4w9WgXcQ'

ydl_opts = {
    'quiet': True,
    'skip_download': True,
    'getcomments': True,
    'extractor_args': {
        'youtube': {
            'comment_sort': ['top'],   # or 'new'
            'max_comments': ['200', '50', '10', '0'],  # total, per-thread, replies-per-thread, child-replies
        }
    },
}

with yt_dlp.YoutubeDL(ydl_opts) as ydl:
    info = ydl.extract_info(VIDEO_URL, download=False)

for c in info.get('comments', [])[:5]:
    print(c['author'], '|', c['text'][:120])

Trois choses à savoir sur cette réponse :

• La liste est plate. Les réponses apparaissent avec un parent champ pointant vers l'ID de leur commentaire racine ; il faut donc reconstruire les fils de discussion lors du post-traitement.
• L'ordre de tri est approximatif. comment_sort ne fait que la demander ; YouTube fournit ce qu'il a mis en cache.
• Pour une pagination en profondeur allant au-delà de ce que max_comments renvoie de manière fiable, passez à l' /youtubei/v1/next point de terminaison avec le commentContinuationToken extrait de la page de visionnage. Vous envoyez le jeton, obtenez une nouvelle continuation, et répétez l'opération jusqu'à ce que la réponse cesse d'en renvoyer une.

Cette approche via l'API cachée est plus lourde à maintenir car YouTube modifie périodiquement la structure de la réponse, mais c'est le seul moyen d'atteindre le nombre de commentaires à long terme sur les vidéos virales. Prévoyez de l'intégrer dans une couche de réessai prenant en charge le statut 429 (abordée plus loin) avant de la laisser tourner en arrière-plan.

Deux tâches relèvent du « scraping de chaîne » : extraire les champs du profil de la chaîne (nom, description, liens, pays, nombre d'abonnés s'il est public) et parcourir l'onglet des vidéos de bout en bout.

Méthode 1 : analyser la section « À propos » de la chaîne. Il s'agit de HTML, donc un requests passage avec BeautifulSoup /@channelhandle/about vous donne les informations de base. Les quelques champs que YouTube cache derrière une boîte de dialogue pilotée par JS (liens, e-mail professionnel) sont toujours intégrés dans le même ytInitialData blob de script que vous avez utilisé pour le démarrage rapide.

import json, re, requests
from bs4 import BeautifulSoup

URL = 'https://www.youtube.com/@GoogleDevelopers/about'
html = requests.get(URL, headers={'Accept-Language': 'en-US,en;q=0.9'}).text

soup = BeautifulSoup(html, 'html.parser')
title_tag = soup.find('meta', attrs={'name': 'title'})
channel_title = title_tag['content'] if title_tag else None

init = re.search(r'var ytInitialData\s*=\s*(\{.+?\});', html).group(1)
data = json.loads(init)
# data now contains description, links, subscriberCountText, etc., nested under 'header' / 'metadata'

Méthode 2 : parcourir l'onglet « Vidéos » /youtubei/v1/browse. Le premier lot de vidéos arrive dans ytInitialData, mais tout ce qui suit est transmis via des jetons de continuation. Extrayez le premier jeton du bloc initial, puis renvoyez-le à l'API cachée pour la page suivante.

import requests

YT_API = 'https://www.youtube.com/youtubei/v1/browse'
CLIENT = {'clientName': 'WEB', 'clientVersion': '2.20240101.00.00'}

def fetch_videos_page(continuation_token: str) -> dict:
    payload = {
        'context': {'client': CLIENT},
        'continuation': continuation_token,
    }
    r = requests.post(YT_API, params={'prettyPrint': 'false'}, json=payload, timeout=20)
    r.raise_for_status()
    return r.json()

def walk(continuation_token: str, max_pages: int = 5):
    for _ in range(max_pages):
        data = fetch_videos_page(continuation_token)
        # videos under: onResponseReceivedActions[*].appendContinuationItemsAction.continuationItems[*]
        yield data
        next_tokens = [
            item['continuationItemRenderer']['continuationEndpoint']['continuationCommand']['token']
            for action in data.get('onResponseReceivedActions', [])
            for item in action.get('appendContinuationItemsAction', {}).get('continuationItems', [])
            if 'continuationItemRenderer' in item
        ]
        if not next_tokens:
            return
        continuation_token = next_tokens[0]

Ce modèle de continuation est le même que celui utilisé par les résultats de recherche et les commentaires ; il vaut donc la peine de s’y familiariser une bonne fois pour toutes. Utilisez jsonpath-ng ou jmespath pour que les expressions de chemin restent lisibles au lieu d’enchaîner les .get() . Pour les récupérations d'historique en profondeur, exécutez la boucle derrière un pool de proxys, car effectuer /youtubei/v1/browse rapidement depuis une seule adresse IP est le moyen le plus rapide de déclencher le limiteur de débit de YouTube.

La recherche YouTube est la surface la plus difficile à maintenir opérationnelle à long terme, car la mise en page des SERP change et l'API nécessite un clientVersion . Reproduisez la requête XHR privée que vous pouvez observer dans DevTools (onglet Réseau, filtrez sur youtubei) et vous disposerez d'un scraper stable.

import requests
from jsonpath_ng.ext import parse

YT_SEARCH = 'https://www.youtube.com/youtubei/v1/search'
CONTEXT = {'client': {'clientName': 'WEB', 'clientVersion': '2.20240101.00.00'}}

def search_youtube(query: str) -> list[dict]:
    payload = {'context': CONTEXT, 'query': query}
    r = requests.post(YT_SEARCH, json=payload, timeout=20)
    r.raise_for_status()
    data = r.json()

    expr = parse('$..videoRenderer')
    results = []
    for m in expr.find(data):
        v = m.value
        results.append({
            'id': v.get('videoId'),
            'title': v['title']['runs'][0]['text'],
            'channel': v.get('ownerText', {}).get('runs', [{}])[0].get('text'),
            'views_text': v.get('viewCountText', {}).get('simpleText'),
        })
    return results

for hit in search_youtube('python web scraping')[:5]:
    print(hit)

Quelques remarques de production qui vous feront gagner du temps lors du débogage :

• La clientVersion valeur varie. Récupérez-en une nouvelle de temps en temps sur https://www.youtube.com/sw.js_data ou en inspectant n'importe quelle page de surveillance ; s'en tenir à une version obsolète finit par renvoyer des charges utiles vides.
• La pagination utilise le même modèle de jeton de continuation que les vidéos de la chaîne, mais provenant directement de la réponse de recherche elle-même.
• videoRenderer est le type de résultat le plus courant, mais la recherche renvoie également channelRenderer, playlistRendereret reelItemRenderer (Shorts) ; filtrez donc explicitement en fonction de la surface souhaitée.

Si vous gérez un outil à long terme qui apprend à extraire les résultats de recherche YouTube en production, attendez-vous à actualiser la logique de parcours JSON tous les quelques mois. La structure du point de terminaison est suffisamment stable pour s'y fier, mais les noms de champs à l'intérieur des moteurs de rendu changent.

Les Shorts YouTube utilisent une interface de lecture différente de celle des vidéos classiques, mais le pipeline de métadonnées est identique. Chaque Short dispose toujours d’une URL de lecture de la forme https://www.youtube.com/shorts/<videoId> qui redirige vers une page de visionnage classique côté serveur, et la page intègre toujours ytInitialPlayerResponse. Cela signifie que tout ce qui est décrit dans la section « Démarrage rapide » fonctionne pour les Shorts sans modification du code.

import json, re, requests
URL = 'https://www.youtube.com/shorts/<videoId>'
html = requests.get(URL, headers={'Accept-Language': 'en-US'}).text
data = json.loads(re.search(r'ytInitialPlayerResponse\s*=\s*(\{.+?\})\s*;', html).group(1))
print(data['videoDetails']['title'], data['videoDetails']['viewCount'])

Pour isoler les Shorts dans les résultats de recherche, filtrez sur le reelItemRenderer (ou shortsLockupViewModel sur les réponses plus récentes) au lieu de videoRenderer lorsque vous parcourez le JSON. Pour lister les Shorts d'un créateur, appuyez sur la touche /shorts via la même /youtubei/v1/browse boucle de continuation que vous avez utilisée pour l'onglet des vidéos classiques, mais en utilisant simplement le browseId des Shorts de la chaîne. Cela couvre l'essentiel de ce que les gens entendent lorsqu'ils demandent comment extraire des Shorts YouTube à grande échelle sans émulateur d'application mobile personnalisé.

Les transcriptions constituent la charge utile textuelle la plus précieuse de la plateforme et la plus délicate à extraire. Il existe deux méthodes pratiques.

Méthode A : yt-dlp avec writesubtitles et writeautomaticsub. C'est la méthode la plus fiable, car yt-dlp génère l'URL signée json3 URL pour vous. YouTube ne fournit plus de manière fiable les transcriptions à partir d'une simple api/timedtext?lang=en&v=ID URL sans paramètres signés ; il est donc recommandé de générer l'URL via un extracteur. Vérifiez la source actuelle de yt-dlp si le comportement venait à changer.

import yt_dlp, requests

VIDEO_URL = 'https://www.youtube.com/watch?v=dQw4w9WgXcQ'
ydl_opts = {
    'quiet': True,
    'skip_download': True,
    'writesubtitles': True,
    'writeautomaticsub': True,
    'subtitleslangs': ['en', 'en-US'],
}
with yt_dlp.YoutubeDL(ydl_opts) as ydl:
    info = ydl.extract_info(VIDEO_URL, download=False)

subs = info.get('subtitles') or info.get('automatic_captions') or {}
for lang, tracks in subs.items():
    json3 = next((t['url'] for t in tracks if t.get('ext') == 'json3'), None)
    if json3:
        captions = requests.get(json3, timeout=20).json()
        text = ' '.join(seg['utf8'] for ev in captions['events']
                        for seg in ev.get('segs', []) if 'utf8' in seg)
        print(lang, text[:200])
        break

Méthode B : raccourci youtube-transcript-api. Lorsque vous n'avez besoin que du texte et des horodatages, cette bibliothèque se résume à une seule ligne :

from youtube_transcript_api import YouTubeTranscriptApi

api = YouTubeTranscriptApi()
fetched = api.fetch('dQw4w9WgXcQ', languages=['en', 'en-US', 'en-GB'])
for snippet in fetched:
    print(f"{snippet.start:7.2f}  {snippet.text}")

Elle renvoie une FetchedTranscriptséquence itérable de fragments horodatés avec le code de langue et un is_generated indicateur vous indiquant si les sous-titres sont générés automatiquement. Passez une liste ordonnée de codes de langue pour le repli. Si vous récupérez des transcriptions en volume significatif, acheminez le trafic HTTP sous-jacent via un pool de proxys, car l'hôte timedtext applique des limites de débit strictes aux adresses IP cloud.

Toutes les méthodes ci-dessus sont évolutives jusqu’à ce que YouTube commence à s’en apercevoir. Au-delà de quelques centaines de requêtes par minute provenant d’une même adresse IP, vous verrez des /youtubei/v1/ , des redirections vers consent.youtube.comou des erreurs HTTP 429. Cinq pratiques permettent de maintenir un pipeline de web scraping YouTube opérationnel en production.

1. Alternez les adresses IP résidentielles pour des exécutions prolongées. Les proxys de centre de données fonctionnent toujours pour les appels à faible volume requests , mais sont rapidement signalés /youtubei/v1/. Un pool résidentiel de plus de 150 millions d’adresses IP réparties dans 195 pays fait passer le trafic pour celui de navigateurs domestiques ordinaires, ce qui fait la différence entre un scraper qui fonctionne pendant une semaine et un autre qui est bloqué en une heure. Le ciblage géographique vous permet également de scraper des métadonnées verrouillées par région sans VPN. (Consultez notre guide interne sur l’utilisation des proxys avec le module requests pour les détails de configuration.)

2. Aléatoirez les en-têtes. Un seul User-Agent sur des milliers de requêtes constitue une empreinte digitale. Faites tourner l'User-Agent et Accept-Language, et définissez une valeur raisonnable Referer (https://www.youtube.com/) afin que l'appel semble provenir d'une page.

3. Limitez le débit et reculez en cas de 429. Détectez la limitation de débit et mettez en pause de manière exponentielle :

import time, random, requests

def fetch(url, attempts=5, **kwargs):
    for i in range(attempts):
        r = requests.get(url, timeout=20, **kwargs)
        if r.status_code == 429 or r.status_code >= 500:
            sleep_for = (2 ** i) + random.random()
            time.sleep(sleep_for)
            continue
        r.raise_for_status()
        return r
    raise RuntimeError(f'Gave up after {attempts} attempts')

4. Gérer la redirection du cookie de consentement. Les requêtes provenant de la région UE sont souvent redirigées vers consent.youtube.com. La solution la plus simple consiste à envoyer un CONSENT=YES+cb cookie à chaque appel, ce qui indique à YouTube que la bannière de consentement a déjà été ignorée.

requests.get(url, cookies={'CONSENT': 'YES+cb'}, headers=HEADERS)

5. Utilisez une API de scraping gérée pour la production. Gérer soi-même la couche de proxy et de réessais convient pour un projet parallèle. Pour tout ce qui concerne les clients, notre API Scraper gère la rotation des proxys, la randomisation des en-têtes, le rendu JavaScript et la résolution des CAPTCHA derrière un seul point de terminaison, ce qui permet à votre code de rester concentré sur l'analyse de la réponse YouTube. Vous ne payez que pour les requêtes réussies, ce qui facilite la prévision des coûts. Associez les techniques ci-dessus à un guide anti-blocage éprouvé et le taux d'échec passera de « lutte quotidienne contre les urgences » à « vérification du tableau de bord une fois par semaine ».

La raison pour laquelle la plupart des équipes assemblent des métadonnées, des commentaires et des transcriptions est d'alimenter un modèle linguistique. Les dictionnaires plats ci-dessus sont faciles à convertir en une seule charge utile Markdown qu'un pipeline d'intégration ou un résumeur de type Gemini peut ingérer directement.

def to_markdown(meta: dict, transcript: str, top_comments: list[dict]) -> str:
    parts = [
        f"# {meta['title']}",
        f"**Channel:** {meta['channel']}  ",
        f"**Published:** {meta.get('upload_date')}  ",
        f"**Views:** {meta.get('view_count')}  ",
        '',
        '## Description',
        meta.get('description', '').strip(),
        '',
        '## Transcript',
        transcript.strip(),
        '',
        '## Top comments',
    ]
    for c in top_comments[:25]:
        parts.append(f"- **{c['author']}**: {c['text']}")
    return '\n'.join(parts)

Une fois que vous disposez d'une charge utile Markdown par vidéo, deux petites modifications la rendent compatible avec la production pour le RAG :

• Segmentez pour les fenêtres de contexte. Même avec des modèles à long contexte, envoyez des segments de 2 000 à 4 000 tokens avec un chevauchement de 200 tokens afin que la récupération puisse extraire la bonne partie sans perdre le contexte environnant.
• Intégrez des métadonnées structurées à côté du texte. Stockez videoId, channelId, publishedAtet la langue dans des colonnes distinctes de votre magasin de vecteurs. Le filtrage sur ces éléments au moment de la requête est moins coûteux et plus précis que de se fier uniquement à la similarité sémantique.

C'est pour cette raison que les équipes qui savent déjà comment extraire des données de YouTube ont tendance à intégrer ce processus dans le même pipeline que l'ingestion de leurs podcasts et webinaires : le schéma de sortie est aligné, et le même outil de segmentation/d'intégration se réutilise facilement d'une source à l'autre.

Rien dans ce guide ne constitue un conseil juridique ; considérez-le comme une liste de contrôle pour les développeurs et consultez un avocat avant tout déploiement commercial. Cela étant dit, quatre limites sont importantes lorsque vous effectuez un scraping de YouTube.

Conditions d'utilisation. Les conditions d'utilisation de YouTube restreignent l'accès automatisé selon des modalités qui changent périodiquement ; consultez directement les conditions d'utilisation actuelles de YouTube plutôt que de vous fier à un résumé fourni par un tiers. Leur violation peut entraîner le blocage de l'adresse IP, la suspension du compte ou des poursuites judiciaires à l'encontre de l'opérateur.

Droit d'auteur. Les fichiers vidéo, les vignettes et les métadonnées des créateurs originaux sont protégés par le droit d'auteur dans la plupart des juridictions. Le stockage ou la redistribution de ce contenu au-delà des cas d'utilisation équitable, de recherche ou d'utilisation transformative sans autorisation peut constituer une violation. La création de liens et l'utilisation analytique des métadonnées publiques sont beaucoup plus sûres.

Législation sur la protection de la vie privée. Les commentaires et les identifiants de chaîne sont souvent considérés comme des données à caractère personnel. Le texte du RGPD de l'UE définit les exigences en matière de base légale, de minimisation et de conservation ; la CCPA californienne impose des obligations parallèles à un ensemble différent d'acteurs. Si vous collectez des commentaires d'utilisateurs de l'UE ou de Californie, documentez une base légale, réduisez au minimum ce que vous conservez et proposez une procédure de suppression.

Étiquette. Respectez robots.txt même lorsqu’elle n’est pas strictement contraignante, limitez agressivement le trafic lorsque vous détectez des erreurs 429, identifiez votre scraper dans un User-Agent clairement attribuable pour les contacts de première partie, et arrêtez dès que vous recevez une objection écrite d’un créateur ou de YouTube lui-même.

• Choisissez d'abord la méthode. L'API Data v3 convient pour les extractions structurées de faible volume ; tout le reste (commentaires, transcriptions, Shorts, recherche approfondie) doit passer par un pipeline de scraping.
• L' ytInitialPlayerResponse astuce regex est la méthode la plus rapide sans clé API pour obtenir le titre, le nombre de vues, la chaîne et la durée, et elle fonctionne aussi bien sur les vidéos classiques que sur les Shorts.
• yt-dlp est l'outil par défaut pour les métadonnées vidéo, les commentaires et les transcriptions, car il s'autorégule et intègre la gestion des URL signées pour les sous-titres.
• Les /youtubei/v1/ débloquent les résultats de recherche, la pagination des vidéos de la chaîne via des jetons de continuation et les fils de commentaires profonds, mais ils nécessitent un pool de proxys et une couche de réessai prenant en charge le statut 429 pour fonctionner correctement.
• Considérez la protection anti-bot, la conformité aux conditions d'utilisation et le respect du RGPD/CCPA comme des exigences de production, et non comme des considérations secondaires.

Les métadonnées publiques de YouTube peuvent généralement être collectées à des fins d'analyse et de recherche, mais cela peut tout de même enfreindre les Conditions d'utilisation de YouTube, qui restreignent l'accès automatisé selon des modalités qui changent périodiquement. Les droits d'auteur s'appliquent toujours aux vidéos et aux vignettes, et les données personnelles contenues dans les commentaires déclenchent des obligations au titre du RGPD ou du CCPA. Consultez les Conditions d'utilisation en vigueur, documentez une base légale et consultez un avocat avant toute utilisation commerciale.

Évitez complètement l'API Data. L'option getcomments=True extrait le texte des fils de discussion, les auteurs, le nombre de « J'aime » et les identifiants parents en un seul appel, sans quota ni clé API. Pour les fils de discussion plus longs sur les vidéos virales, reproduisez l' /youtubei/v1/next XHR avec l' commentContinuationToken de la page de visionnage et paginez jusqu'à ce que la réponse cesse de renvoyer une nouvelle suite.

Installez youtube-transcript-api et appelez YouTubeTranscriptApi().fetch(video_id, languages=['en','en-US','en-GB']). Il renvoie des extraits horodatés, le code de la langue et un is_generated indicateur signalant la présence de sous-titres automatiques. Passez une liste ordonnée de langues pour une solution de secours élégante. Pour les cas limites d'URL signées (sous-titres en direct, contenu réservé aux membres), basculez vers yt-dlp avec writesubtitles=True et lisez l' json3 URL qu'il génère.

Trois causes habituelles. Vous accédez trop souvent à la même adresse IP ; passez donc à des proxys résidentiels et ajoutez un délai d'attente exponentiel en cas d'erreurs 429. Vous êtes redirigé vers consent.youtube.com, alors configurez un CONSENT=YES+cb cookie. Ou bien votre clientVersion en-tête est obsolète lors des /youtubei/v1/ appels, alors actualisez-le à partir d'une page de visionnage actuelle ou sw.js_data une fois par exécution.

Les chemins d'accès aux points de terminaison et les wrappers de premier niveau restent stables pendant des mois, mais les noms des champs du rendu à l'intérieur (videoRenderer, reelItemRendererou les chemins de continuation des commentaires) changent toutes les quelques semaines. Protégez-vous contre ces changements en analysant jsonpath-ng ou jmespath faciles à mettre à jour, en surveillant la structure des réponses à l’aide de snapshots de schéma et en écrivant des tests d’intégration qui signalent clairement toute défaillance lorsqu’un champ critique disparaît.

Si vous ne devez retenir qu’une seule chose de ce guide, que ce soit la matrice de décision : savoir comment extraire des données de YouTube commence par choisir le bon outil, et non par écrire du code. L’API Data pour les appels structurés à faible volume, yt-dlp pour la profondeur par vidéo, les /youtubei/v1/ pour la recherche et la pagination, et une API gérée lorsque la production est en jeu.

Avant de déployer un scraper YouTube, effectuez trois vérifications de production. Premièrement, assurez-vous que votre pool de proxys tourne suffisamment souvent pour maintenir les taux de requêtes par IP dans une fourchette prudente. Deuxièmement, vérifiez que votre politique de réessai traite les codes 429, les erreurs 5xx et les redirections de consentement comme des modes d'échec distincts avec des courbes de backoff différentes. Troisièmement, mettez en place une surveillance qui alerte en cas de changements de format de réponse, et pas seulement en cas d'échecs HTTP, afin qu'une dérive silencieuse du schéma /youtubei/v1/ ne corrompe pas une semaine de données.

Associez le scraping de chaînes à l'analyse des sentiments dans les commentaires, au découpage des transcriptions ou à des tableaux de bord sur la cadence des concurrents, et vous disposerez d'un véritable pipeline de veille. Si vous préférez éviter complètement la gestion des proxys et des tentatives de reconnexion, notre équipe chez WebScrapingAPI propose une API de scraping qui renvoie du code HTML ou JSON propre à partir de n'importe quelle interface YouTube, avec une protection anti-bot intégrée. Vous pouvez ainsi conserver votre code d'analyse et remplacer la couche de récupération par un simple appel HTTP.