Aller au contenu
FR
Obtenir une clé API
Parcourir la documentation

Guides

Commandes yt-dlp pour les tâches courantes

Commandes prêtes à copier pour la vidéo, l’audio, les sous-titres, les jeux de données et la reprise de collectes.

Sur cette page

Configuration et conventions des commandes

Installer la version nightly et les dépendances nécessaires
python -m pip install -U --pre "yt-dlp[default,curl-cffi]"
deno --version
ffmpeg -version
python -m yt_dlp --list-impersonate-targets

Les recettes de téléchargement utilisent Deno et --impersonate="" comme base. Ce dernier nécessite curl-cffi et lui permet de choisir une empreinte d'empreinte disponible dans le navigateur. Linux/macOS commande l'utilisation de la syntaxe de Bash; pour un processus prévu, faites également ces dépendances disponibles dans cet environnement de service.

Ces exemples terminaux utilisent l'installation Python de yt-dlp. Utilisez votre environnement virtuel Python, ou remplacez Python -m yt_dlp par le commandement indépendant yt-dlp. Utilisez Linux d'abord, avec des alternatives macOS et Windows dans le guide de configuration. Installation FFmpeg/ffprobe pour fusionner et Deno pour résoudre le défi YouTube. Remplacer l’URL par votre source.

ConventionPourquoi cela compte
URL et modèlesLe shell interprète autrement des personnages tels que &, espaces et parenthèses.
Réserver %(ext)s dans des noms de filLes médias sélectionnés et le post-traitement déterminent l'extension.
Utiliser --no-playlist pour un URL d'horlogeUn vidéo lié à une liste de lecture ne devrait pas étendre votre travail inattendu.
Vérifiez votre configuration sauvéeLes exemples peuvent hériter d'un config global. Utilisez --ignore-config pour un test isolé.
Windows .bat : double modèle pourcentage des signesUtilisez %%(id)s dans un fichier de batch, mais %(id)s dans les fichiers PowerShell interactifs et les fichiers de configuration normales.

La qualité de la vidéo et MP4

Base Line: la dernière nuit, Deno et FFmpeg, avec --impersonate="". Les recettes utilisent Bash; remplacez l'URL de l'échantillon par votre source.

Télécharger un vidéo avec sélection par défaut
python -m yt_dlp --js-runtimes deno --impersonate="" --no-playlist -P downloads \
  -o "%(id)s.%(ext)s" "https://www.youtube.com/watch?v=jNQXAC9IVRw"
Sélectionnez les courants disponibles en utilisant les défauts de yt-dlp. Le conteneur n'est pas nécessairement MP4.
Liste des formats disponibles
python -m yt_dlp --js-runtimes deno --impersonate="" --no-playlist \
  -F "https://www.youtube.com/watch?v=jNQXAC9IVRw"
Inspectez les codecs et les lignes audio-only/video-only. Les identifiants de format numérique ne sont pas des politiques de sortie portables.
Je préfère 1080p
python -m yt_dlp --js-runtimes deno --impersonate="" --no-playlist -S "res:1080" \
  "https://www.youtube.com/watch?v=jNQXAC9IVRw"
Une préférence: si aucun format à ou en dessous de l'objectif n'est disponible, la sortie peut choisir un au-dessus de celui-ci.
Pour un maximum de 1080p
python -m yt_dlp --js-runtimes deno --impersonate="" --no-playlist \
  -f "bv*[height<=1080]+ba/b[height<=1080]" "https://www.youtube.com/watch?v=jNQXAC9IVRw"
Un filtre : échoue lorsque aucun format ne correspond.Retue le choix du codec source.
H.264 vidéo et AAC audio dans MP4
python -m yt_dlp --js-runtimes deno --impersonate="" --no-playlist \
  -f "bv[vcodec^=avc1][height<=1080]+ba[acodec^=mp4a]/b[vcodec^=avc1][acodec^=mp4a][height<=1080]" \
  --merge-output-format mp4 "https://www.youtube.com/watch?v=jNQXAC9IVRw"
Sélection stricte de codec. nécessite des formats correspondants et FFmpeg pour une fusion séparée.

Sites de données AI: MP4 + captions + métadonnées

Meilleur vidéo + audio, MP4, captions et métadonnées
python -m yt_dlp --js-runtimes deno --impersonate="" --no-playlist \
  -f "bestvideo+bestaudio/best" --merge-output-format mp4 --remux-video mp4 \
  --write-info-json --write-subs --write-auto-subs --sub-langs "en" --sub-format "vtt/best" \
  --sleep-subtitles 5 --concurrent-fragments 1 -P dataset -o "%(id)s/%(id)s.%(ext)s" \
  "https://www.youtube.com/watch?v=jNQXAC9IVRw"
FFmpeg fusionne les flux source. MP4 conserve les codecs source; vérifier la compatibilité des décodateurs et la couverture de la note séparément.

Téléchargement de la page : aria2c

Deux connexions, native DASH/HLS
python -m yt_dlp --js-runtimes deno --impersonate="" --no-playlist --downloader aria2c \
  --downloader "dash,m3u8:native" --downloader-args "aria2c:-x 2 -s 2 -j 1" \
  --concurrent-fragments 1 -P downloads "https://www.youtube.com/watch?v=jNQXAC9IVRw"
Installez l’exécutable aria2c. Vérifiez d’abord le téléchargement d’une seule vidéo avant d’augmenter le nombre de connexions. Réduisez-le dès qu’une erreur 403 apparaît.

aria2 a sa propre mise en œuvre réseau. yt-dlp l'impression curl-cffi ne configure pas l'empreinte d'empreinte aria2. Si seulement le téléchargateur extérieur échoue, utilisez --downloader natif et comparez la même source et la même route de proxy.

Le son et MP3

Écrivez le streaming audio original
python -m yt_dlp --js-runtimes deno --impersonate="" --no-playlist -f ba -P audio \
  -o "%(id)s.%(ext)s" "https://www.youtube.com/watch?v=jNQXAC9IVRw"
Pas de conversion MP3. Utile lorsque votre pipeline de transcription ou de récupération accepte le codec original.
Convertir à MP3 à un bitrate cible
python -m yt_dlp --js-runtimes deno --impersonate="" --no-playlist -f ba -x \
  --audio-format mp3 --audio-quality 192K -P audio \
  "https://www.youtube.com/watch?v=jNQXAC9IVRw"
Utilisez FFmpeg. 192K contrôle le codage de sortie; il ne restaurera pas la qualité de source.
Préférez M4A sans transcodage
python -m yt_dlp --js-runtimes deno --impersonate="" --no-playlist -f "ba[ext=m4a]" -P audio \
  "https://www.youtube.com/watch?v=jNQXAC9IVRw"
Faille si aucun format audio-uniquement M4A n'est disponible. Ajouter /ba seulement si votre application accepte d'autres conteneurs source.
MP3 avec des métadonnées intégrées et une couverture
python -m yt_dlp --js-runtimes deno --impersonate="" --no-playlist -f ba -x \
  --audio-format mp3 --embed-metadata --embed-thumbnail -P audio \
  "https://www.youtube.com/watch?v=jNQXAC9IVRw"
Les étapes metadata/thumbnail sont des étapes supplémentaires après le traitement. Vérifiez le fichier final, pas seulement le transfert de la boîte.

Captions et sous-titres

Liste des traces disponibles
python -m yt_dlp --js-runtimes deno --impersonate="" --no-playlist \
  --list-subs "https://www.youtube.com/watch?v=jNQXAC9IVRw"
Lisez les tags de langue proposés par cette source avant de choisir --sub-langs.
Téléchargez les sous-titres anglais fournis uniquement
python -m yt_dlp --js-runtimes deno --impersonate="" --skip-download --write-subs \
  --sub-langs "en.*" --sub-format "vtt/best" -P captions -o "%(id)s.%(ext)s" \
  "https://www.youtube.com/watch?v=jNQXAC9IVRw"
Il ne revient pas aux captions automatiques et ne téléchargera pas les médias.
Il permet également des captions anglaises automatiques
python -m yt_dlp --js-runtimes deno --impersonate="" --skip-download --write-subs \
  --write-auto-subs --sub-langs "en.*" --sub-format "vtt/best" -P captions \
  -o "%(id)s.%(ext)s" "https://www.youtube.com/watch?v=jNQXAC9IVRw"
en.* peut correspondre plusieurs variantes anglaise.Cela récupère les traces disponibles; il ne fonctionne pas la reconnaissance de la parole.
Convertir les traces sélectionnées en SRT
python -m yt_dlp --js-runtimes deno --impersonate="" --skip-download --write-subs \
  --write-auto-subs --sub-langs "en" --convert-subs srt -P captions \
  "https://www.youtube.com/watch?v=jNQXAC9IVRw"
Require FFmpeg. Sélectionnez un autre code de langue de --list-subs si nécessaire.
Insérer les sous-titres fournis dans MKV
python -m yt_dlp --js-runtimes deno --impersonate="" --write-subs --sub-langs "en" \
  --embed-subs --remux-video mkv -P downloads "https://www.youtube.com/watch?v=jNQXAC9IVRw"
Téléchargez les médias, demandes fournies sous-titres en anglais et insère la piste disponible. Vérifiez si cette piste existe d'abord.

La demande de toutes les langues d'affichage peut considérablement augmenter le nombre de demandes et de fichiers. Gardez les langues demandées explicites pour le travail de routine. Conserver l’ID source et le langage dans votre enregistrement de données afin que les transcripts ne soient pas détachés des médias qu’ils décrivent.

Metadata et routes de sortie

Imprimer les métadonnées d'un vidéo comme JSON
python -m yt_dlp --js-runtimes deno --impersonate="" --no-playlist \
  --dump-json "https://www.youtube.com/watch?v=jNQXAC9IVRw" > video.json
Simule le téléchargement par défaut, mais effectue l'extraction. Le redirect remplace video.json.
Écrire un boîtier de pages metadata complet sans médias
python -m yt_dlp --js-runtimes deno --impersonate="" --skip-download --write-info-json \
  -P metadata -o "%(id)s.%(ext)s" "https://www.youtube.com/watch?v=jNQXAC9IVRw"
Créez un .info.json boîtier.C'est les données d'extracteur opérationnels; champs de projet avant de l'exposer publiquement.
Télécharger le mini-enregistrement uniquement
python -m yt_dlp --js-runtimes deno --impersonate="" --skip-download --write-thumbnail \
  -P thumbnails -o "%(id)s.%(ext)s" "https://www.youtube.com/watch?v=jNQXAC9IVRw"
Il économe le mini-nail disponible dans son format source. --convert-thumbnails jpg ajoute un pas de conversion lorsque JPEG est nécessaire.
Imprimer la voie médiatique finale après le traitement
python -m yt_dlp --js-runtimes deno --impersonate="" --no-playlist \
  --print after_move:filepath -P downloads -o "%(id)s.%(ext)s" \
  "https://www.youtube.com/watch?v=jNQXAC9IVRw"
Contrairement à une étape par défaut --print, une after_move imprimée attend un réel téléchargement et son mouvement final.
Approche des chemins complets à un manifeste
python -m yt_dlp --js-runtimes deno --impersonate="" --no-playlist \
  --print-to-file after_move:filepath completed-paths.txt -P downloads \
  "https://www.youtube.com/watch?v=jNQXAC9IVRw"
Append, donc les retours peuvent produire des entrées répétées. Traitez-le comme un journal de complément, pas un inventory dédoublé.

Temps et chapitres

Téléchargez les secondes 5 par 10
python -m yt_dlp --js-runtimes deno --impersonate="" --no-playlist \
  --download-sections "*00:00:05-00:00:10" -o "clips/%(id)s-%(section_start)s.%(ext)s" \
  "https://www.youtube.com/watch?v=jNQXAC9IVRw"
Require FFmpeg. Une limite de clip peut s'aligner avec les clés disponibles; vérifier la sortie lorsque l'heure exacte est importante.
Re-encode autour des coupures demandées
python -m yt_dlp --js-runtimes deno --impersonate="" --no-playlist \
  --download-sections "*00:00:05-00:00:10" --force-keyframes-at-cuts \
  -o "clips/%(id)s-%(section_start)s.%(ext)s" "https://www.youtube.com/watch?v=jNQXAC9IVRw"
Ajouter le travail de réencodage pour améliorer la coupe aux limites demandées. Inspecter la durée résultante et audio/video alignement.
Diviser un vidéo chapitre dans des fichiers
python -m yt_dlp --split-chapters -o "chapter:%(id)s-%(section_number)03d.%(ext)s" \
  "https://www.youtube.com/watch?v=YOUR_VIDEO_ID"
Utilisez un vidéo avec des métadonnées de chapitre. Les sorties de chapitre sont séparées du téléchargement complet original; espace de disque budgétaire pour les deux.

Utilisez une politique de sortie ou un archive différent pour les clips et les vidéos complètes. Une entrée d'archive à niveau source ne codera pas les fois start/end sélectionnés, de sorte qu'un archive partagé peut supprimer un clip ultérieur que vous avez l'intention de créer.

Liste des jeux et URL

Téléchargez une liste d'URL connue
python -m yt_dlp --no-playlist --batch-file urls.txt -P collection -o "%(id)s.%(ext)s"
Créez un fichier UTF-8 avec un URL d'attente par ligne. --no-playlist s'applique à l'attente des URL qui contiennent le contexte de la liste de lecture.
Inspecter une liste de lecture YouTube sans extraire vidéo complète
python -m yt_dlp --flat-playlist \
  --dump-json "https://www.youtube.com/playlist?list=YOUR_PLAYLIST_ID" > playlist.jsonl
Un JSON objet par entrée. les entrées plates peuvent omettre les détails de durée et de format.
Téléchargez les cinq premières entrées de la playlist
python -m yt_dlp --playlist-items 1:5 -P collection -o "%(playlist_index)03d-%(id)s.%(ext)s" \
  "https://www.youtube.com/playlist?list=YOUR_PLAYLIST_ID"
Les indices de la liste de jeu sont l'ordre, pas l'identité. Gardez l'ID vidéo dans le nom de fichier.
Limitez les vidéos éligibles par date et durée
python -m yt_dlp --dateafter 20260101 --match-filters "!is_live & duration <= 1800" \
  --batch-file urls.txt
Il nécessite des articles non en direct avec une durée connue jusqu'à 30 minutes, datées ou après janvier 1, 2026.
Arrêtez après 10 nouveaux téléchargements
python -m yt_dlp --download-archive archive.txt --max-downloads 10 --batch-file urls.txt
Le limit contrôle les fichiers récemment téléchargés, pas le nombre de requêtes listing/extraction qui se produisent.

Archives et récupération

Réduire une collection avec la même politique
python -m yt_dlp --download-archive archive.txt --continue --no-abort-on-error -P collection \
  -o "%(id)s.%(ext)s" --batch-file urls.txt
Les identifiants complets sont éteints. les téléchargements partiels se rétablissent là où ils sont soutenus. Utilisez les mêmes voies d'archive et de sortie que le travail d'origine.
Un processus, un processus, et une retraite
python -m yt_dlp --sleep-requests 1 --sleep-interval 5 --max-sleep-interval 10 --retries 3 \
  --fragment-retries 3 --socket-timeout 30 --batch-file urls.txt
Ajouter un limite de processus à niveau de couverture lorsque plusieurs processus partagent une route ou une session.
Cap Transfert Bandwidth
python -m yt_dlp --js-runtimes deno --impersonate="" --limit-rate 2M \
  "https://www.youtube.com/watch?v=jNQXAC9IVRw"
Contrôle le taux de transfert des médias. Il ne régule pas le nombre de demandes d'extraction.
Réduire la concurrence des fragments autochtones
python -m yt_dlp --js-runtimes deno --impersonate="" --concurrent-fragments 1 \
  "https://www.youtube.com/watch?v=jNQXAC9IVRw"
Commencez par un fragment à la fois lors de l'enquête 403s. Autres processus processus ajoutent toujours leurs propres demandes concurrentes.

Configuration et filenames

Remplissez uniquement votre collection explicite config
python -m yt_dlp --ignore-config --config-locations yt-dlp-work.conf --batch-file urls.txt
Le configuration explicitement nommé est chargé même avec --ignore-config. Utilisez des pistes complètes pour les emplois planifiés.
Les noms qui sont lisibles avec une identité stable
python -m yt_dlp --js-runtimes deno --impersonate="" -P downloads \
  -o "%(channel_id)s/%(upload_date)s-%(title).150B [%(id)s].%(ext)s" \
  "https://www.youtube.com/watch?v=jNQXAC9IVRw"
Le titre est troncé en 150 bytes dans ce modèle. les ID distinguer les titres dupliqués ou changant.
Utiliser un catalogue temporaire séparé
python -m yt_dlp --js-runtimes deno --impersonate="" -P "home:downloads" -P "temp:work" \
  -o "%(id)s.%(ext)s" "https://www.youtube.com/watch?v=jNQXAC9IVRw"
Assurez-vous que les deux directories ont suffisamment d'espace ; différents systèmes de fichiers peuvent nécessiter une copie.

Pour les collections longues, décidez si les noms de fil devraient être des clés d'application humaines ou stables. Les noms et titres de la chaîne peuvent changer. Channel/video Les ID sont meilleurs clés pour la déduplication, avec des champs décrits conservés dans les métadonnées.

Cookies et itinéraires de runtime

Utilisez le profil de navigateur qui a accès
python -m yt_dlp --js-runtimes deno --impersonate="" \
  --cookies-from-browser "chrome:Profile 1" \
  --no-playlist "https://www.youtube.com/watch?v=jNQXAC9IVRw"
Remplacer le profil 1 par votre profil de navigateur réel.Utilisez les cookies de session uniquement lorsque cela est nécessaire, et les garder privés.
Lire un fichier cookie privé existant
python -m yt_dlp --js-runtimes deno --impersonate="" --cookies private/youtube-cookies.txt \
  --no-playlist "https://www.youtube.com/watch?v=jNQXAC9IVRw"
Il requiert le format de fichier cookie Netscape. Un JSON exportation n'est pas équivalent.
Utilisez un Deno exécutable en dehors du PATH du processus
python -m yt_dlp --js-runtimes "deno:/opt/deno/bin/deno" --impersonate="" \
  --no-playlist "https://www.youtube.com/watch?v=jNQXAC9IVRw"
Remplacer la route avec le Deno binaire installé pour votre processus.

Diagnostic et vérification

Vérifier une extraction propre
python -m yt_dlp --js-runtimes deno --impersonate="" --ignore-config --verbose --simulate \
  --no-playlist "https://www.youtube.com/watch?v=jNQXAC9IVRw"
Il supprime implicitement la configuration et ne sauvage aucun média. il fait toujours des demandes d'extraction et ne prouve pas que le transfert réussira.
Capture d'un log de diagnostic privé
python -m yt_dlp --js-runtimes deno --impersonate="" --ignore-config --verbose --simulate \
  --no-playlist "https://www.youtube.com/watch?v=jNQXAC9IVRw" > diagnostic.log 2>&1
Redacter les valeurs cookie/header, les crédits proxy et les URL signés avant de partager.
Inspecter les flux et la durée
ffprobe -v error -show_entries format=duration,size:stream=codec_type,codec_name,width,height -of json "YOUR_OUTPUT_FILE"
Utilisez la voie finale, après le traitement. ffprobe lit les titres; il ne décode pas chaque cadre.
Découvrir le fichier sauvé sans créer de la sortie
ffmpeg -v error -i "YOUR_OUTPUT_FILE" -f null -
Un contrôle plus profond qui lit tout le fichier. Vérifier l'état de sortie et les messages.
Mettre à jour le pack de Python et vérifier sa version
python -m pip install -U --pre "yt-dlp[default,curl-cffi]"
python -m yt_dlp --version