# 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.

Référence canonique : https://flashdata.dev/fr/docs/guides/yt-dlp-commands
Vérifié le 2026-11-13 par FlashData

- [Vidéo et audio](https://flashdata.dev/fr/docs/guides/yt-dlp-commands/reference.md#video) — Qualité, codecs et MP3
- [Captions et métadonnées](https://flashdata.dev/fr/docs/guides/yt-dlp-commands/reference.md#subtitles) — Les sidecars et la production structurée
- [Collections et récupération](https://flashdata.dev/fr/docs/guides/yt-dlp-commands/reference.md#archives) — Liste, archives et config
- [Diagnostic d’une échec](https://flashdata.dev/fr/docs/guides/yt-dlp-commands/reference.md#diagnostics) — Logs et vérification de sortie

<a id="conventions"></a>

## Configuration et conventions des commandes


**Installer la version nightly et les dépendances nécessaires**

```bash
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.

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

- [Installation des outils](https://flashdata.dev/fr/docs/guides/how-to-use-yt-dlp/reference.md#install)
- [Créer une configuration de collection réutilisable](https://flashdata.dev/fr/docs/guides/how-to-use-yt-dlp/reference.md#repeatable)

<a id="video"></a>

## 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**

```bash
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**

```bash
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**

```bash
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**

```bash
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**

```bash
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.

> **Le conteneur n'est pas un codec**
> --merge-output-format choisit le conteneur mélangé. --remux-video réparfait les courants compatibles. Il n'y a pas de tournée AV1 en H.264. Lorsqu’un décoder nécessite un codec spécifique, sélectionnez ce codec ou planifiez un transcode séparé.

- [Comprendre les sélectionneurs et les fallbacks](https://flashdata.dev/fr/docs/guides/how-to-use-yt-dlp/reference.md#formats)

<a id="dataset"></a>

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


**Meilleur vidéo + audio, MP4, captions et métadonnées**

```bash
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.

- [Politique de sortie de Dataset et captions manquantes](https://flashdata.dev/fr/docs/guides/how-to-use-yt-dlp/reference.md#dataset)
- [Options de données Python équivalentes](https://flashdata.dev/fr/docs/guides/yt-dlp-python-api/reference.md#dataset)

<a id="aria2"></a>

## Téléchargement de la page : aria2c


**Deux connexions, native DASH/HLS**

```bash
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.

- [Contrôles de connexion et diagnostic de passage](https://flashdata.dev/fr/docs/guides/how-to-use-yt-dlp/reference.md#aria2)

<a id="audio"></a>

## Le son et MP3


**Écrivez le streaming audio original**

```bash
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**

```bash
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**

```bash
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**

```bash
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.

<a id="subtitles"></a>

## Captions et sous-titres


**Liste des traces disponibles**

```bash
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**

```bash
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**

```bash
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**

```bash
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**

```bash
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.

<a id="metadata"></a>

## Metadata et routes de sortie


**Imprimer les métadonnées d'un vidéo comme JSON**

```bash
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**

```bash
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**

```bash
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**

```bash
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**

```bash
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é.

- [Projections de Python](https://flashdata.dev/fr/docs/guides/yt-dlp-python-api/reference.md#metadata)

<a id="clips"></a>

## Temps et chapitres


**Téléchargez les secondes 5 par 10**

```bash
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**

```bash
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**

```bash
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.

<a id="playlists"></a>

## Liste des jeux et URL


**Téléchargez une liste d'URL connue**

```bash
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**

```bash
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**

```bash
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**

```bash
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**

```bash
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.

<a id="archives"></a>

## Archives et récupération


**Réduire une collection avec la même politique**

```bash
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**

```bash
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**

```bash
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**

```bash
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.

> **L’archive a un travail particulier**
> Il enregistre extractor/video IDs après les téléchargements réussies. Ce n’est pas un catalogue des paramètres de sortie ou un contrôle que le fichier existe encore. Gardez des archives séparées pour les politiques audio, vidéo et clip, et ne marquez pas le travail échoué complet avec --force-write-archive.

- [Une procédure de config et de récupération réutilisable](https://flashdata.dev/fr/docs/guides/how-to-use-yt-dlp/reference.md#repeatable)

<a id="configuration"></a>

## Configuration et filenames


**Remplissez uniquement votre collection explicite config**

```bash
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**

```bash
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é**

```bash
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.

<a id="session"></a>

## Cookies et itinéraires de runtime


**Utilisez le profil de navigateur qui a accès**

```bash
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**

```bash
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**

```bash
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.

- [Cookies chargement, expiration et vécu bot](https://flashdata.dev/fr/docs/guides/yt-dlp-sign-in-not-a-bot/reference.md)

<a id="diagnostics"></a>

## Diagnostic et vérification


**Vérifier une extraction propre**

```bash
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é**

```bash
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**

```bash
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**

```bash
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**

```bash
python -m pip install -U --pre "yt-dlp[default,curl-cffi]"
python -m yt_dlp --version
```

- [Le diagnostic 403 par étape](https://flashdata.dev/fr/docs/guides/yt-dlp-403-forbidden/reference.md)
- [429 : méta-détails et limites de demande](https://flashdata.dev/fr/docs/guides/yt-dlp-429-too-many-requests/reference.md)
- [Déterminer la réponse de l’enregistrement bot-check](https://flashdata.dev/fr/docs/guides/yt-dlp-sign-in-not-a-bot/reference.md)
- [Résultats de référence opérationnelle complète](https://github.com/yt-dlp/yt-dlp#usage-and-options)
