Résume automatiquement les vidéos YouTube avec Python, Whisper et GPT

Résume automatiquement les vidéos YouTube avec Python, Whisper et GPT

Tu passes des heures à regarder des vidéos YouTube pour en extraire l’essentiel : une conférence de 45 minutes, un tutoriel de 20 minutes, une interview technique… Et si tu pouvais obtenir un résumé structuré en moins de 30 secondes ? C’est exactement ce que tu vas construire dans ce tutoriel : un script Python qui récupère la transcription d’une vidéo, la résume avec un modèle de langage, et te sort un compte-rendu clair avec les points clés et les actions à retenir.

C’est un projet parfait pour progresser : tu manipules des API, tu découvres la transcription audio, tu utilises un vrai LLM et tu obtiens un outil que tu réutiliseras tous les jours. Et bonne nouvelle, tout est faisable avec les fondamentaux de Python que tu connais déjà : fonctions, listes, dictionnaires, gestion d’erreurs.

Comment ça marche ?

Le pipeline tient en trois étapes :

• Récupérer la transcription : la plupart des vidéos YouTube ont des sous-titres générés automatiquement. On les récupère avec la bibliothèque youtube-transcript-api.
• Replier sur Whisper : si la vidéo n’a pas de sous-titres, on télécharge l’audio et on le transcrit avec Whisper, le modèle de reconnaissance vocale d’OpenAI.
• Résumer avec un LLM : on envoie la transcription à un modèle de langage (GPT, Claude, ou un modèle local) avec un prompt bien construit pour obtenir un résumé structuré.

L’idée clé du résumé : ne jamais envoyer la transcription entière d’un coup. On la découpe en morceaux (chunks), on résume chaque morceau, puis on résume les résumés. C’est la technique du map-reduce appliquée aux LLM — exactement ce que font les frameworks comme LangChain en interne.

Étape 1 — Récupérer la transcription

Commençons par installer les dépendances :

pip install youtube-transcript-api openai-whisper pytube

La récupération des sous-titres est étonnamment simple :

from youtube_transcript_api import YouTubeTranscriptApi

def get_transcript(video_id: str) -> str:
    """Récupère la transcription d'une vidéo YouTube."""
    api = YouTubeTranscriptApi()
    transcript = api.fetch(video_id)
    return " ".join(segment.text for segment in transcript)

# Exemple : la vidéo "Python for Beginners" (ID factice)
video_id = "VIDEO_ID_ICI"
print(get_transcript(video_id)[:200])

Chaque segment de la transcription contient aussi un timestamp. Tu peux l’utiliser pour créer un sommaire cliquable qui pointe vers les moments importants de la vidéo — un vrai plus pour un article de blog ou des notes de cours.

Étape 2 — Le plan B : Whisper pour les vidéos sans sous-titres

Certaines vidéos n’ont pas de sous-titres (musique, vidéos très anciennes, contenu non sous-titré). Dans ce cas, on télécharge la piste audio et on la transcrit avec Whisper, qui fonctionne 100% en local et gratuitement :

import whisper
from pytube import YouTube

def transcribe_with_whisper(video_url: str) -> str:
    """Télécharge l'audio et le transcrit avec Whisper."""
    yt = YouTube(video_url)
    audio = yt.streams.filter(only_audio=True).first()
    audio.download(filename="audio.mp3")

    model = whisper.load_model("base")  # "small" ou "medium" pour plus de précision
    result = model.transcribe("audio.mp3")
    return result["text"]

Le modèle base est un bon compromis : rapide et correct en français. Si la vidéo est en anglais, base est très bon. Pour un usage ponctuel, c’est largement suffisant — et tu gardes le contrôle de tes données puisque tout tourne sur ta machine.

Étape 3 — Résumer avec un LLM (map-reduce)

Maintenant, la partie intéressante. On découpe la transcription en chunks de ~4000 caractères, on résume chaque chunk, puis on combine :

from openai import OpenAI

client = OpenAI()  # lit la clé API dans la variable d'env OPENAI_API_KEY

def chunk_text(text: str, size: int = 4000) -> list[str]:
    """Découpe un texte long en morceaux de taille fixe."""
    return [text[i:i + size] for i in range(0, len(text), size)]

def summarize_chunk(chunk: str) -> str:
    """Résume un morceau de transcription."""
    prompt = f"""Résume le texte suivant en français, en 3 à 5 phrases.
    Garde les idées techniques importantes et les chiffres clés.

    TEXTE :
    {chunk}"""
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.3,
    )
    return response.choices[0].message.content

def summarize_video(transcript: str) -> str:
    """Pipeline map-reduce : résume chaque chunk puis le tout."""
    chunks = chunk_text(transcript)
    partials = [summarize_chunk(c) for c in chunks]

    final_prompt = f"""À partir des résumés partiels suivants, rédige un compte-rendu
    structuré en français avec :
    - Un titre
    - Les points clés (liste à puces)
    - Les actions concrètes à retenir

    RÉSUMÉS PARTIELS :
    {" ".join(partials)}"""
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": final_prompt}],
        temperature=0.3,
    )
    return response.choices[0].message.content

Pourquoi cette approche ? Parce que les LLM ont une fenêtre de contexte limitée. Une conférence d’une heure représente facilement 30 000 caractères de transcription — bien trop pour un seul appel. Le découpage permet de traiter n’importe quelle durée de vidéo, et la phase finale de synthèse garantit un résumé cohérent.

Étape 4 — Tout assembler

Il ne reste plus qu’à brancher les pièces entre elles, avec une gestion d’erreur propre :

import sys
from youtube_transcript_api import TranscriptsDisabled

def summarize_youtube_video(video_url: str) -> str:
    """Point d'entrée : URL → résumé structuré."""
    video_id = video_url.split("v=")[-1].split("&")[0]

    try:
        transcript = get_transcript(video_id)
        source = "sous-titres YouTube"
    except TranscriptsDisabled:
        print("Pas de sous-titres → transcription Whisper...")
        transcript = transcribe_with_whisper(video_url)
        source = "Whisper"

    print(f"Transcription récupérée ({source}) : {len(transcript)} caractères")
    summary = summarize_video(transcript)
    return summary

if __name__ == "__main__":
    url = sys.argv[1] if len(sys.argv) > 1 else input("URL de la vidéo : ")
    print(summarize_youtube_video(url))

Et voilà. Lance python resume_youtube.py "https://www.youtube.com/watch?v=..." et en moins d’une minute tu obtiens un compte-rendu structuré de n’importe quelle vidéo.

Aller plus loin

Ce projet est une excellente base pour des idées plus ambitieuses :

• Générer des flashcards Anki à partir du résumé pour mémoriser le contenu.
• Extraire les questions/réponses d’une conférence pour préparer un examen.
• Créer une playlist intelligente : résume plusieurs vidéos et regroupe-les par thème.
• Automatiser le tout avec un cron qui traite tes vidéos « À regarder plus tard » chaque semaine.

Tu peux aussi remplacer l’API OpenAI par un modèle local (via Ollama ou llama.cpp) pour un coût nul — le code change à peine, c’est toute la puissance des API compatibles OpenAI.

Conclusion

Tu viens de construire un outil concret qui combine transcription automatique et résumé par IA : deux compétences très demandées en 2026. Le plus important, ce n’est pas le script en lui-même, c’est la méthode — découper un problème, appeler des API proprement, gérer les erreurs, assembler un pipeline. Exactement ce que font les développeurs IA au quotidien.

Si certaines parties du code te semblent encore floues (les fonctions, les dictionnaires, la gestion des chaînes de caractères), c’est le moment de consolider tes bases : le cours Python — Les fondamentaux t’apprend tout ce qu’il faut pour écrire ce genre de script en toute confiance, pas à pas et avec des exercices pratiques.