Récupérer le son d’une vidéo Youtube en mp3 avec un programme Python

IMPORTANT (MàJ du 06/08/2025) : voici un nouveau script Python qui fonctionne pour la conversion d’une vidéo YouTube en mp3 :

import os
import sys
import subprocess
import json
from pathlib import Path

def trouver_ffmpeg():
    """Trouve FFmpeg dans les emplacements communs"""
    emplacements_possibles = [
        'ffmpeg',  # Dans le PATH
        r'C:\ProgramData\chocolatey\bin\ffmpeg.exe',
        r'C:\ffmpeg\bin\ffmpeg.exe',
        r'C:\Program Files\ffmpeg\bin\ffmpeg.exe',
        r'C:\Users\%USERNAME%\AppData\Local\Microsoft\WinGet\Packages\Gyan.FFmpeg_Microsoft.Winget.Source_8wekyb3d8bbwe\ffmpeg-*\bin\ffmpeg.exe'
    ]
    
    # Chercher dans le PATH d'abord
    try:
        subprocess.run(['ffmpeg', '-version'], 
                      stdout=subprocess.DEVNULL, 
                      stderr=subprocess.DEVNULL, 
                      check=True)
        return 'ffmpeg'
    except (subprocess.CalledProcessError, FileNotFoundError):
        pass
    
    # Chercher dans les emplacements Windows spécifiques
    import glob
    for emplacement in emplacements_possibles[1:]:
        if '*' in emplacement:
            # Pour les chemins avec wildcards (WinGet)
            chemins = glob.glob(os.path.expandvars(emplacement))
            for chemin in chemins:
                if os.path.exists(chemin):
                    return chemin
        else:
            chemin_complet = os.path.expandvars(emplacement)
            if os.path.exists(chemin_complet):
                return chemin_complet
    
    return None

def verifier_dependances():
    """Vérifie que yt-dlp et ffmpeg sont installés"""
    dependances = {'yt-dlp': False, 'ffmpeg': False, 'ffmpeg_path': None}
    
    try:
        subprocess.run(['yt-dlp', '--version'], 
                      stdout=subprocess.DEVNULL, 
                      stderr=subprocess.DEVNULL, 
                      check=True)
        dependances['yt-dlp'] = True
    except (subprocess.CalledProcessError, FileNotFoundError):
        pass
    
    # Chercher FFmpeg
    ffmpeg_path = trouver_ffmpeg()
    if ffmpeg_path:
        dependances['ffmpeg'] = True
        dependances['ffmpeg_path'] = ffmpeg_path
    
    return dependances

def obtenir_info_video(url):
    """Obtient les informations de la vidéo sans la télécharger"""
    try:
        cmd = ['yt-dlp', '--dump-json', '--no-playlist', url]
        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
        return json.loads(result.stdout)
    except Exception as e:
        return None

def conversion_audio(url, nom_fichier_sortie):
    """
    Télécharge une vidéo YouTube et convertit l'audio en MP3
    
    Args:
        url (str): URL de la vidéo YouTube
        nom_fichier_sortie (str): Nom du fichier de sortie (avec extension .mp3)
    """
    try:
        print("Connexion à YouTube...")
        
        # Obtenir les informations de la vidéo
        info = obtenir_info_video(url)
        if info:
            print(f"Titre: {info.get('title', 'Inconnu')}")
            duree = info.get('duration', 0)
            if duree:
                print(f"Durée: {duree // 60}:{duree % 60:02d}")
        else:
            print("Impossible d'obtenir les informations de la vidéo, mais on continue...")
        
        print("Téléchargement et conversion en cours...")
        
        # Vérifier si FFmpeg est disponible
        deps = verifier_dependances()
        if deps['ffmpeg']:
            # Commande avec conversion MP3 (nécessite FFmpeg)
            cmd = [
                'yt-dlp',
                '--extract-audio',
                '--audio-format', 'mp3',
                '--audio-quality', '192K',
                '--output', nom_fichier_sortie.replace('.mp3', '.%(ext)s'),
                '--no-playlist',
                '--embed-metadata',
                url
            ]
            
            # Si FFmpeg n'est pas dans le PATH, spécifier son emplacement
            if deps['ffmpeg_path'] != 'ffmpeg':
                ffmpeg_dir = os.path.dirname(deps['ffmpeg_path'])
                cmd.extend(['--ffmpeg-location', ffmpeg_dir])
                print(f"ℹ️  Utilisation de FFmpeg depuis: {ffmpeg_dir}")
            
        else:
            # Commande sans conversion (télécharge le meilleur audio disponible)
            print("⚠️  FFmpeg non trouvé. Téléchargement audio sans conversion MP3...")
            cmd = [
                'yt-dlp',
                '--format', 'bestaudio',
                '--output', nom_fichier_sortie.replace('.mp3', '.%(ext)s'),
                '--no-playlist',
                '--embed-metadata',
                url
            ]
        
        # Exécuter la commande
        result = subprocess.run(cmd, capture_output=True, text=True)
        
        if result.returncode == 0:
            # Chercher le fichier créé (l'extension peut varier sans FFmpeg)
            fichier_cree = None
            base_name = nom_fichier_sortie.replace('.mp3', '')
            
            # Extensions possibles
            extensions = ['.mp3', '.m4a', '.webm', '.opus']
            for ext in extensions:
                fichier_test = base_name + ext
                if os.path.exists(fichier_test):
                    fichier_cree = fichier_test
                    break
            
            if fichier_cree:
                # Si ce n'est pas un MP3, informer l'utilisateur
                if not fichier_cree.endswith('.mp3'):
                    print(f"✅ Téléchargement terminé! Fichier sauvé: {fichier_cree}")
                    print(f"ℹ️  Format: {fichier_cree.split('.')[-1].upper()} (Installez FFmpeg pour conversion MP3)")
                else:
                    print(f"✅ Conversion terminée! Fichier sauvé: {fichier_cree}")
                return True
            else:
                print("❌ Fichier de sortie introuvable après téléchargement")
                return False
        else:
            print(f"❌ Erreur lors du téléchargement:")
            print(result.stderr)
            return False
            
    except Exception as e:
        print(f"Erreur lors du téléchargement: {str(e)}")
        return False

def valider_url(url):
    """Valide que l'URL est bien une URL YouTube ou autre plateforme supportée"""
    plateformes_supportees = [
        'youtube.com', 'youtu.be', 'music.youtube.com',
        'soundcloud.com', 'vimeo.com', 'dailymotion.com'
    ]
    return any(plateforme in url.lower() for plateforme in plateformes_supportees)

def installer_dependances():
    """Guide d'installation des dépendances"""
    print("\n" + "=" * 60)
    print("INSTALLATION DES DÉPENDANCES REQUISES")
    print("=" * 60)
    print("\n1. Installer yt-dlp:")
    print("   pip install yt-dlp")
    print("\n2. Installer FFmpeg:")
    print("   • Windows: Téléchargez depuis https://ffmpeg.org/")
    print("             Ou utilisez: winget install ffmpeg")
    print("   • macOS: brew install ffmpeg")
    print("   • Linux: sudo apt install ffmpeg")
    print("\nAprès installation, relancez ce script.")
    print("=" * 60)

def main():
    print("=" * 60)
    print("        EXTRACTEUR AUDIO YOUTUBE VERS MP3")
    print("        (Jérémy TELLIER - Le blog Parti'Prof)")
    print("=" * 60)
    print()
    
    # Vérification des dépendances
    deps = verifier_dependances()
    
    if not deps['yt-dlp']:
        print("❌ yt-dlp n'est pas installé!")
        installer_dependances()
        return
    
    if not deps['ffmpeg']:
        print("⚠️  FFmpeg n'est pas installé. La conversion MP3 pourrait ne pas fonctionner.")
        print("   yt-dlp tentera d'utiliser ses convertisseurs intégrés.")
        print()
    else:
        print("✅ Toutes les dépendances sont installées!")
        print()
    
    while True:
        try:
            # Demander l'URL
            youtube_url = input("Collez le lien de la vidéo (YouTube, SoundCloud, etc.): ").strip()
            
            if not youtube_url:
                print("URL vide. Veuillez entrer une URL valide.")
                continue
                
            if not valider_url(youtube_url):
                print("⚠️  URL non reconnue. Le script va quand même essayer...")
            
            # Demander le nom du fichier de sortie
            nom_fichier = input("Nom du fichier de sortie (sans extension): ").strip()
            
            if not nom_fichier:
                nom_fichier = "audio_telecharge"
            
            # Nettoyer le nom de fichier (supprimer les caractères interdits)
            caracteres_interdits = '<>:"/\\|?*'
            for char in caracteres_interdits:
                nom_fichier = nom_fichier.replace(char, '_')
            
            nom_fichier_sortie = nom_fichier + ".mp3"
            
            # Vérifier si le fichier existe déjà
            if os.path.exists(nom_fichier_sortie):
                reponse = input(f"Le fichier '{nom_fichier_sortie}' existe déjà. L'écraser? (o/n): ")
                if reponse.lower() not in ['o', 'oui', 'y', 'yes']:
                    continue
            
            print("\n" + "-" * 60)
            
            # Lancer la conversion
            succes = conversion_audio(youtube_url, nom_fichier_sortie)
            
            print("-" * 60)
            
            if succes:
                # Vérifier que le fichier a bien été créé
                if os.path.exists(nom_fichier_sortie):
                    taille = os.path.getsize(nom_fichier_sortie) / (1024 * 1024)  # Taille en MB
                    print(f"📁 Fichier créé: {nom_fichier_sortie} ({taille:.1f} MB)")
                else:
                    print("⚠️  Le téléchargement semble avoir réussi mais le fichier est introuvable.")
            
            # Demander si l'utilisateur veut continuer
            continuer = input("\nVoulez-vous télécharger une autre vidéo? (o/n): ")
            if continuer.lower() not in ['o', 'oui', 'y', 'yes']:
                break
                
        except KeyboardInterrupt:
            print("\n\nArrêt demandé par l'utilisateur.")
            break
        except Exception as e:
            print(f"\nErreur inattendue: {str(e)}")
            continue
    
    print("\nMerci d'avoir utilisé l'extracteur audio!")
    input("Appuyez sur Entrée pour quitter...")

if __name__ == "__main__":
    main()

Il faudra quelques connaissances car des dépendances sont nécessaires (comme ffmepg). À l’occasion, un exécutable sera peut-être ajouté.

=== PARTIE OBSOLÈTE ===

Dans cet article, je vous présente un programme Python permettant de convertir une vidéo Youtube en fichier mp3 pour conserver uniquement l’audio. Le programme directement exécutable sur un PC sans connaissance spécifique est disponible en cliquant ici. Le détail du script est présent dans la suite de l’article.

Ce programme Python permet de récupérer l’audio d’une vidéo Youtube directement en fichier mp3. Voici le code Python à utiliser pour convertir une vidéo Youtube en mp3 :

from pytube import YouTube
import time
import sys

def conversion_audio(url, nom_fichier_sortie):
    print("Téléchargement en cours...")
    yt = YouTube(url)
    audio_stream = yt.streams.filter(only_audio=True).first()
    audio_stream.download(filename=nom_fichier_sortie)
    print("Fini !")
    time.sleep(1)  # Pause d'une seconde
    input("Appuyez sur Entrée pour quitter...")

print("=== Youtube vers mp3 ===")
youtube_url = input("Collez le lien de la vidéo YouTube puis appuyez sur la touche Entrée : ")
nom_fichier_sortie = input("Choisissez le nom du fichier mp3 de sortie puis appuyez sur la touche Entrée : ")
conversion_audio(youtube_url, nom_fichier_sortie + ".mp3")

Le programme Python permet d’extraire le son d’une vidéo en mp3 grâce à la bibliothèque Pytube, en lignes de commandes. Il faut d’abord indiquer l’url de la vidéo Youtube, puis le nom du fichier de sortie et le programme crée alors le fichier mp3 dans le même dossier que celui où se trouve le programme.

Pour les personnes n’ayant pas de connaissance en Python et souhaitant utiliser directement le programme, voici la version exe :

Programme de conversion de vidéos Youtube en mp3 (version Beta Test du 03/05/2024 (en lançant le programme vous aurez probablement un avertissement de votre antivirus ou de Windows Defender, le programme n’ayant pas de certificat de signature).

Youtubeversmp3 © 2024 par Jérémy Tellier est sous licence CC BY-SA 4.0 . Pour plus d’informations sur les licences, vous pouvez consulter ce lien.

Le programme est en phase de test et sera peut-être amélioré par la suite pour d’autres versions, avec par exemple une interface graphique, le choix de l’emplacement du fichier de sortie, …

=== FIN PARTIE OBSOLÈTE ===

Commentez pour toute remarque sur ce programme Python pour convertir des vidéos Youtube en mp3 !

5 commentaires sur « Récupérer le son d’une vidéo Youtube en mp3 avec un programme Python »

  1. Bonjour je n’arrive pas a faire marcher votre scripte, il ne se passe rien lorsque je lance la recherche, en regardant votre profil j’ai eu confiance j’espère que je ne me suis pas trompé.

    Votre logiciel marche il toujours ? J’utilisais le site cobalt avant, mais il a été bloqué récemment par youtube sur les chaines d’artistes musicaux.

    Répondre
  2. Bonjour,

    Merci pour votre message. Effectivement je viens de réessayer le script et cela ne fonctionne plus. Peut-être un blocage au niveau de Youtube. Je vais indiquer que cela ne marche plus pour le moment.

    Bonne journée,

    Jérémy.

    Répondre
  3. Excusez moi je n’avais pas vu votre réponse, j’ai du rechargé la page. C’est dommage, personnellement je cherche le moyen de faire un script similaire sur mon ordinateur, c’est principalement pour de la musique, mais je ne sait pas si c’est encore possible…

    Répondre

Laisser un commentaire

Ce site utilise Akismet pour réduire les indésirables. Découvrez comment les données de vos commentaires sont traitées.