Comment scraper les données YouTubepour la recherche de contenu et le SEO

YouTube est le deuxième site le plus visité sur le web, et les données qu'il affiche publiquement constituent une mine d'or pour toute personne travaillant sur le contenu et le SEO. Les titres qui se positionnent sur une requête de recherche, les chaînes qui dominent un sujet, les compteurs de vues qui signalent la demande, les dates de publication qui indiquent la fraîcheur des résultats gagnants : tout cela est visible sur une page de résultats publique, et tout cela vous dit ce sur quoi le public clique vraiment. Ce guide vous montre comment extraire des données YouTube publiques avec Python et les transformer en recherche de mots-clés et de contenu exploitable.

Pour être clair d'emblée : tout ce qui suit se limite aux données publiques provenant des pages de recherche et de vidéos publiques. Vous collecterez des titres de vidéos, des noms de chaînes, des compteurs de vues, des dates de publication et des liens vers les vidéos. Vous ne toucherez à rien derrière une connexion, aux commentaires d'utilisateurs individuels, aux playlists privées ni aux données personnelles des spectateurs. Si votre projet nécessite un accès structuré et sanctionné à grande échelle, l'API officielle YouTube Data est l'outil approprié, et la section légalité vers la fin explique pourquoi. Cet article complète notre tutoriel approfondi sur le scraper de chaîne YouTube ; ici, l'accent est mis sur la couche recherche-et-vidéo pour la recherche d'optimisation.

Ce que vous allez construire

Un petit script Python qui prend une requête de recherche YouTube publique ou une URL de vidéo, récupère la page entièrement rendue via la Crawling API avec un token JavaScript, et analyse quelques champs publics non personnels pour chaque résultat :

• Titre le titre de la vidéo, qui vous indique comment un sujet est formulé pour se positionner et obtenir des clics.
• Chaîne le nom de la chaîne qui a publié la vidéo, utile pour identifier qui possède un sujet.
• Vues le compteur de vues public, un signal de demande approximatif pour un mot-clé ou un thème.
• Date de publication la date de mise en ligne relative ou absolue, qui indique la fraîcheur des résultats classés.
• Lien l'URL de visionnage canonique pour chaque vidéo, afin que vous puissiez la revisiter ou l'enrichir ultérieurement.

Remarquez ce qui est délibérément absent : aucun identifiant de commentateur, aucun contenu réservé aux abonnés, aucune donnée personnelle des spectateurs. Vous collectez des signaux agrégés sur le contenu, pas des profils de personnes.

Pourquoi une requête ordinaire échoue sur YouTube

Envoyez une requête à une URL de recherche YouTube avec un simple client HTTP et vous obtiendrez une réponse qui est techniquement un succès et pratiquement vide. YouTube rend ses résultats côté client : le HTML initial est une coquille légère, et la vraie liste de vidéos n'apparaît qu'après que le JavaScript de la page s'exécute dans un navigateur et hydrate les résultats. Par-dessus cela, YouTube surveille le trafic automatisé. Les plages d'adresses IP de datacenters, l'absence de comportement de navigateur et les schémas de requêtes répétitifs sont mis en défi ou limités en débit bien avant que le contenu intéressant se charge.

Ainsi, un scraper de données YouTube fonctionnel a besoin de deux choses dans la même requête : un vrai navigateur qui rend la page, et une IP que la plateforme interprète comme un visiteur ordinaire. Vous pouvez assembler cela vous-même avec un navigateur sans tête et un pool de proxies résidentiels rotatifs, mais maintenir cette pile en bonne santé représente l'essentiel du travail. La Crawling API regroupe les deux en un seul appel : vous envoyez une URL avec un token JavaScript, elle rend la page derrière une IP résidentielle de confiance, et elle renvoie du HTML finalisé que vous pouvez analyser. Pour comprendre pourquoi le rendu est important, consultez notre guide sur comment crawler des sites JavaScript.

Prérequis

Quelques éléments à mettre en place au préalable. Aucun ne prend longtemps.

Python de base. Vous devez être à l'aise pour exécuter un script et installer des paquets avec pip. Si vous êtes novice en analyse HTML, notre introduction à l'utilisation de BeautifulSoup en Python couvre le côté extraction.

Python 3.8 ou ultérieur. Vérifiez avec python --version. Si vous ne l'avez pas, installez-le depuis python.org.

Un compte Crawlbase et un token JS. Inscrivez-vous, ouvrez votre tableau de bord et copiez votre token JavaScript (JS). Le niveau gratuit inclut jusqu'à 20 000 requêtes et vous ne payez que pour les réussies, ce qui est largement suffisant pour les sessions de recherche de ce guide. Traitez le token comme un mot de passe et ne le mettez pas dans le contrôle de version.

Configurer le projet

Créez un environnement virtuel isolé, puis installez les bibliothèques dont le scraper a besoin.

python --version

python -m venv youtube_env
source youtube_env/bin/activate

pip install crawlbase beautifulsoup4

Sous Windows, activez avec youtube_env\Scripts\activate au lieu de la ligne source. Deux dépendances font le travail : crawlbase est le client officiel pour la Crawling API, et beautifulsoup4 analyse le HTML renvoyé pour que vous puissiez extraire les champs individuels par sélecteur. Les modules standard json et csv gèrent l'export, donc il n'y a rien de supplémentaire à installer pour cela.

Étape 1 : récupérer une page de recherche rendue

Commencez par obtenir la page finalisée. Importez CrawlingAPI, initialisez-la avec votre token JS et demandez une URL de résultats de recherche publique. Construisez la requête dans le chemin standard results?search_query=, et vérifiez le code de statut avant d'analyser afin que les échecs soient visibles plutôt que silencieux.

from urllib.parse import quote_plus
from crawlbase import CrawlingAPI

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})

def crawl(page_url):
    options = {"ajax_wait": "true", "page_wait": 5000}
    response = api.get(page_url, options)
    if response["status_code"] == 200:
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['status_code']}")
    return None

def search_url(query):
    return f"https://www.youtube.com/results?search_query={quote_plus(query)}"

if __name__ == "__main__":
    query = "data scraping tutorial"
    html = crawl(search_url(query))
    print(html[:500] if html else "No HTML returned")

Les deux options d'attente comptent pour une cible rendue côté client. ajax_wait indique à l'API d'attendre que le contenu asynchrone ait fini de se charger, et page_wait maintient un nombre fixe de millisecondes après le chargement pour que la liste de résultats à rendu tardif apparaisse avant la capture de page. Cinq secondes est un point de départ raisonnable ; augmentez si les résultats reviennent vides. La requête reprend l'exemple historique ("data scraping tutorial") pour que vous puissiez comparer les résultats directement. Exécutez le script et vous devriez voir du vrai balisage YouTube, ce qui confirme que le rendu fonctionne avant d'écrire un seul sélecteur.

Étape 2 : analyser les champs publics

Une fois le HTML rendu en main, le signal le plus stable sur une page YouTube est l'objet JSON ytInitialData intégré que la page fournit avec ses scripts. Il contient les mêmes champs que YouTube utilise pour rendre la liste de résultats : titres, noms de chaînes, texte du compteur de vues, texte de la date de publication et identifiants vidéo. L'analyse de cet objet est bien plus durable que de traquer des classes CSS profondément imbriquées et fréquemment renommées. Chargez le HTML dans BeautifulSoup, extrayez le script qui définit ytInitialData, et parcourez-le pour les rendus de vidéos.

import json
import re
from bs4 import BeautifulSoup

def load_initial_data(html):
    soup = BeautifulSoup(html, "html.parser")
    for script in soup.find_all("script"):
        text = script.string or ""
        if "ytInitialData" in text:
            match = re.search(r"ytInitialData\s*=\s*(\{.*?\});", text, re.DOTALL)
            if match:
                return json.loads(match.group(1))
    return {}

def text_of(node):
    if not node:
        return None
    if "simpleText" in node:
        return node["simpleText"]
    runs = node.get("runs", [])
    return "".join(r["text"] for r in runs) if runs else None

L'assistant load_initial_data isole l'objet JSON avec une expression régulière non gourmande et l'analyse. L'assistant text_of gère les deux formes de texte de YouTube : certains champs sont une simple chaîne simpleText, d'autres sont une liste de runs que vous joignez. Avec ces deux assistants en place, l'extraction de chaque vidéo devient un simple parcours des rendus de recherche.

Étape 3 : extraire un enregistrement par vidéo

YouTube imbrique les résultats de recherche sous un long chemin de rendus de sections et d'éléments. Chaque résultat lisible est un videoRenderer qui contient le titre, le nom de la chaîne (ownerText ou longBylineText), le viewCountText, le publishedTimeText et le videoId. Parcourez la structure, collectez chaque videoRenderer et mappez chacun sur un enregistrement plat.

def find_video_renderers(node, found):
    if isinstance(node, dict):
        if "videoRenderer" in node:
            found.append(node["videoRenderer"])
        for value in node.values():
            find_video_renderers(value, found)
    elif isinstance(node, list):
        for item in node:
            find_video_renderers(item, found)
    return found

def parse_search(html):
    data = load_initial_data(html)
    renderers = find_video_renderers(data, [])
    results = []
    for v in renderers:
        video_id = v.get("videoId")
        if not video_id:
            continue
        channel = text_of(v.get("ownerText")) or text_of(v.get("longBylineText"))
        results.append({
            "title": text_of(v.get("title")),
            "channel": channel,
            "views": text_of(v.get("viewCountText")),
            "published": text_of(v.get("publishedTimeText")),
            "link": f"https://www.youtube.com/watch?v={video_id}",
        })
    return results

Le parcours récursif find_video_renderers évite de coder en dur le chemin d'imbrication exact, que YouTube réordonne de temps en temps ; il collecte simplement chaque videoRenderer où qu'il apparaisse. Chaque enregistrement contient exactement les cinq champs publics que vous souhaitiez recueillir : titre, chaîne, vues, date de publication et lien. Ce sont des signaux de contenu et de demande, pas des données personnelles sur des spectateurs.

Étape 4 : assembler et exporter en JSON et CSV

Reliez maintenant la récupération, l'analyse et l'export en un seul script exécutable. Il lance une liste de requêtes de recherche, collecte les champs publics pour chacune, et écrit à la fois un fichier JSON et un fichier CSV pour que les données tombent directement dans une feuille de calcul ou un notebook.

import csv
import json
import time
from urllib.parse import quote_plus
from crawlbase import CrawlingAPI

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})

def main():
    queries = ["data scraping tutorial", "python web scraping"]
    rows = []
    for query in queries:
        html = crawl(search_url(query))
        if not html:
            continue
        for record in parse_search(html)[:10]:
            record["query"] = query
            rows.append(record)
        time.sleep(3)

    with open("youtube_research.json", "w", encoding="utf-8") as f:
        json.dump(rows, f, indent=2, ensure_ascii=False)

    fields = ["query", "title", "channel", "views", "published", "link"]
    with open("youtube_research.csv", "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=fields)
        writer.writeheader()
        writer.writerows(rows)

    print(f"Saved {len(rows)} videos across {len(queries)} queries")

if __name__ == "__main__":
    main()

Le time.sleep(3) entre les requêtes n'est pas une décoration. Le rythme est le facteur le plus important pour qu'une exécution reste saine, et nous y reviendrons. La tranche [:10] reproduit les 10 premiers résultats que le script historique imprimait et garde la démonstration focalisée. Combinez cela avec les fonctions crawl, search_url et parse_search antérieures dans un seul fichier et le tout s'exécute de bout en bout.

À quoi ressemble la sortie

Exécutez le script complet et vous obtenez un enregistrement propre par vidéo, prêt à être trié par vues, regroupé par chaîne ou parcouru pour les schémas de titres qui gagnent une requête.

[
  {
    "title": "Web Scraping Tutorial | Data Scraping from Websites to Excel",
    "channel": "Data Analytics",
    "views": "1.2M views",
    "published": "2 years ago",
    "link": "https://www.youtube.com/watch?v=aClnnoQK9G0",
    "query": "data scraping tutorial"
  },
  {
    "title": "Beginners Guide To Web Scraping with Python",
    "channel": "Coding Channel",
    "views": "480K views",
    "published": "1 year ago",
    "link": "https://www.youtube.com/watch?v=QhD015WUMxE",
    "query": "data scraping tutorial"
  }
]

Les compteurs de vues et les chaînes de date de publication proviennent directement de YouTube sous forme de texte d'affichage ("1.2M views", "2 years ago"). Pour l'analyse, normalisez-les dans une passe ultérieure : supprimez "views" et développez les suffixes M et K en entiers, et convertissez les dates relatives en dates absolues approximatives. Conserver les chaînes brutes dans l'export signifie que vous ne perdez jamais le signal d'origine.

Transformer les données en recherche de contenu et SEO

L'objectif de ce scrape n'est pas les lignes brutes, c'est ce qu'elles vous disent sur un sujet. Quelques lectures pratiques :

• Les schémas de titres qui se positionnent. Regroupez les meilleurs résultats par requête et regardez comment les titres gagnants sont formulés : les modificateurs, les crochets, les chiffres, la promesse. C'est le langage sur lequel un public clique pour ce mot-clé.
• La demande par compteur de vues. Triez par vues pour voir quels sous-sujets attirent le plus d'attention. Des compteurs de vues élevés sur des vidéos plus anciennes sans concurrent récent signalent souvent une opportunité de nouveau contenu.
• Les lacunes de fraîcheur. La colonne de date de publication montre l'ancienneté des résultats classés. Une requête dominée par des vidéos datant d'il y a plusieurs années est candidate pour une mise à jour.
• La propriété du sujet. Compter la fréquence d'apparition de chaque chaîne dans vos requêtes montre qui possède déjà un thème, ce qui informe l'analyse concurrentielle et les idées de partenariats.

Cela se couple naturellement avec votre travail de mots-clés plus large. Si vous construisez un pipeline de recherche, nos guides sur l'utilisation des données pour améliorer le SEO et sur comment extraire et analyser les données SEO de Google expliquent comment intégrer une telle source dans une vue complète.

Mise à l'échelle et pagination

Une page de recherche renvoie le premier lot de résultats, ce qui est généralement suffisant pour la recherche. Si vous avez besoin de plus de profondeur, lancez un ensemble plus large de requêtes plutôt que d'essayer de paginer une seule : une liste de mots-clés connexes offre une couverture plus large que le défilement d'un seul ensemble de résultats, et elle correspond mieux à la façon dont vous planifiez réellement votre contenu. Pour enrichir une vidéo spécifique, récupérez son URL de visionnage avec la même fonction crawl et analysez sa page pour la description et les métadonnées exactes, en utilisant à nouveau le JSON intégré plutôt que des sélecteurs fragiles.

Gardez le volume proportionnel à la question de recherche. Vous avez rarement besoin de chaque résultat pour une requête ; les meilleurs résultats portent l'essentiel du signal, et un ensemble de requêtes petit mais bien choisi est préférable à un crawl exhaustif, tant pour la qualité que pour une bonne pratique.

Rester non bloqué

Même avec le rendu géré par la Crawling API, YouTube surveille le trafic en forme de scraper. Quelques habitudes maintiennent une exécution saine et s'appliquent à toute cible fortement défendue.

• Cadencez vos requêtes. Bombarder des pages en boucle serrée est le moyen le plus rapide d'être limité en débit. Ajoutez de vrais délais, comme dans le time.sleep ci-dessus, et résistez à l'envie de paralléliser de façon agressive.
• Comptez sur la rotation. Un pool d'IP résidentielles répartit les requêtes sur de nombreuses adresses d'utilisateurs réels pour qu'aucune ne déclenche une limite de débit. La Crawling API gère cela pour vous ; si vous construisez votre propre pile, c'est la partie à bien faire.
• Lisez les codes de statut. Une exécution qui commence à retourner des défis ou des erreurs vous indique que le débit ou le niveau d'IP actuel n'est plus suffisant. Reculez plutôt que de forcer.
• Gardez le volume bas et les requêtes variées. La recherche de contenu ne nécessite pas un crawl exhaustif de YouTube. Échantillonnez les requêtes qui comptent et arrêtez-vous.

Pour le manuel complet, consultez notre guide sur comment scraper des sites web sans être bloqué et l'analyse approfondie sur comment scraper des pages JavaScript avec Python.

Est-il légal de scraper YouTube ?

C'est la section à lire avant d'écrire du code de production. YouTube appartient à Google, et ses Conditions d'utilisation restreignent l'accès automatisé et imposent des limites claires sur la collecte de données depuis la plateforme. Le scraping automatisé peut aller à l'encontre de ces conditions quel que soit le soin apporté à vos outils, et aucun code ci-dessus ne change cela. Il fait seulement fonctionner la partie technique. Lisez les Conditions d'utilisation de YouTube et son robots.txt, respectez les limites de débit, et traitez les deux comme la frontière de ce que vous collectez.

Les règles honnêtes et restrictives à respecter. Collectez uniquement des données publiques que n'importe qui peut voir sans se connecter : les titres de vidéos, les noms de chaînes, les compteurs de vues, les dates de publication et les liens vers les vidéos, exactement les signaux agrégés de niveau contenu que ce guide recueille. Ne scrapez rien derrière une connexion, les vidéos privées ou non répertoriées, le contenu réservé aux membres, ni les commentaires des utilisateurs individuels et les identifiants qui leur sont attachés. Traitez les commentaires, les noms d'utilisateur et tout détail de spectateur comme des données personnelles ; lorsque des données personnelles sont impliquées, les régimes de protection de la vie privée tels que le RGPD et le CCPA s'appliquent, ce qui signifie que vous avez besoin d'une base légale et devez honorer les demandes de suppression. Ne contournez jamais l'authentification ni ne téléchargez des médias protégés par le droit d'auteur pour les redistribuer. Ce sont des lignes rouges, et ce guide reste du côté public et non personnel de toutes celles-ci par conception.

Pour toute utilisation réelle, continue ou commerciale, le bon outil est l'API officielle YouTube Data. C'est la voie sanctionnée que Google fournit, elle vous donne une structure garantie pour les titres, les compteurs de vues, les données de chaînes et la recherche, et elle vous maintient dans les conditions de la plateforme avec un quota clair. Cet article est un tutoriel technique limité aux données publiques non personnelles pour la recherche de contenu et SEO. Ce n'est pas une approbation de la collecte de données en masse, et il ne couvre rien derrière une connexion. Si votre projet nécessite plus qu'un petit échantillon de champs publics, l'API Data ou un accord formel est la voie appropriée, pas un scraper plus ingénieux.

Foire aux questions

Pourquoi une simple requête ne renvoie-t-elle aucune donnée de YouTube ?

Parce que YouTube rend son contenu de recherche et de vidéo côté client avec JavaScript. Le HTML initial est une coquille qui ne se remplit qu'après l'exécution des scripts de la page dans un navigateur, donc une requête HTTP brute renvoie un corps presque vide. Pour obtenir les vrais résultats publics, vous devez d'abord rendre la page, ce que gère le token JS de la Crawling API.

Ai-je besoin du token normal ou du token JS pour YouTube ?

Le token JS. Le token normal récupère du HTML statique, qui sur YouTube est la même coquille vide qu'une simple requête renvoie. Le token JS rend la page dans un vrai navigateur avant de remettre le HTML, de sorte que l'objet ytInitialData intégré et les résultats qu'il décrit sont présents lors de leur analyse.

Quelles données YouTube est-il sûr de scraper pour la recherche SEO ?

Les champs publics, non personnels et de niveau contenu : les titres de vidéos, les noms de chaînes, les compteurs de vues publics, les dates de publication et les liens vidéo des pages de recherche et de vidéos publiques. Ce sont les signaux qui vous indiquent comment un sujet se positionne et ce sur quoi un public clique. Les commentaires des utilisateurs individuels, les identifiants qui leur sont attachés, le contenu privé ou réservé aux membres, et tout ce qui se trouve derrière une connexion sont hors limites, car ils constituent des données personnelles ou sont restreints par les conditions de la plateforme.

Comment transformer les données scrapées en recherche de mots-clés ?

Regroupez les résultats par requête et étudiez les schémas. La formulation des titres dans les meilleurs résultats montre le langage qui se positionne pour un mot-clé ; les compteurs de vues classent les sous-sujets par demande ; les dates de publication révèlent les lacunes de fraîcheur que vous pouvez combler ; et la fréquence des chaînes montre qui possède déjà un thème. Exportez en CSV et l'analyse est à quelques tris de feuille de calcul.

Faut-il utiliser l'API officielle YouTube Data ou scraper le site ?

Pour toute utilisation réelle, continue ou commerciale, utilisez l'API officielle YouTube Data. C'est la voie sanctionnée, elle offre une structure garantie, inclut un quota clair et vous maintient dans les conditions de Google. Scraper un petit échantillon de champs publics avec l'approche ici convient à la recherche de contenu légère et ponctuelle sans accès à l'API, tant que vous respectez les conditions, robots.txt et les limites de débit.

Comment éviter d'être bloqué lors du scraping de YouTube ?

Maintenez un taux de requêtes par IP bas, ajoutez de vrais délais entre les requêtes, variez vos requêtes plutôt que d'crawler une seule exhaustivement, et routez via des IP résidentielles rotatives pour qu'aucune adresse ne déclenche une limite de débit. La Crawling API gère la rotation et un pool d'IP de confiance pour vous. Surveillez les codes de statut et reculez dès que vous commencez à voir des défis.

HR

Hassan Rehan

Ingénieur logiciel · Crawlbase

Ingénieur logiciel chez Crawlbase, il rédige des guides pratiques sur les proxys rotatifs, le scraping et les détails concrets de l'intégration de proxys dans du vrai code.