# Comandi yt-dlp per il lavoro quotidiano

Copia i comandi per video, audio, sottotitoli, dataset e ripresa di una raccolta.

Riferimento canonico: https://flashdata.dev/it/docs/guides/yt-dlp-commands
Recensito: 2026-11-13 da FlashData

- [Video e audio](https://flashdata.dev/it/docs/guides/yt-dlp-commands/reference.md#video) — Qualità, codec e MP3
- [Capture e metadati](https://flashdata.dev/it/docs/guides/yt-dlp-commands/reference.md#subtitles) — Sede e produzione strutturata
- [Collezioni e recupero](https://flashdata.dev/it/docs/guides/yt-dlp-commands/reference.md#archives) — Elenco, archivi e config
- [Diagnosi di un fallimento](https://flashdata.dev/it/docs/guides/yt-dlp-commands/reference.md#diagnostics) — Logs e verifica delle uscite

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

## Configurazione e Command Conventions


**Inizia con le dipendenze notturne e complete**

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

Le ricette di download utilizzano Deno e --impersonate="" come linea di base. Il secondo richiede curl-cffi e permette di scegliere un’impronta del browser disponibile. Linux/macOS comanda l'uso della sintasi Bash; per un lavoratore programmato, anche rendere disponibili queste dipendenze in quel ambiente di servizio.

Questi esempi terminali utilizzano l'installazione Python di yt-dlp. Utilizzare Python, o sostituire Python -m yt_dlp con il comando standalone yt-dlp. Utilizzare Linux prima, con macOS e Windows alternative nella guida di impostazione. Installare FFmpeg/ffprobe per fusione e Deno per risolvere il problema di YouTube. Sostituisci l'URL con la tua fonte.

| Convenzione | Perché è importante |
| --- | --- |
| Scrivere URL e template | Il shell interprete in modo diverso personaggi come &, spazi e parentesse. |
| Mantenere %(ext)s in filename | I media selezionati e il post-processing determinano l'estensione. |
| Utilizzare --no-playlist per un orologio URL | Un video collegato da un elenco di riproduzione non dovrebbe espandere in modo inaspettato il tuo lavoro. |
| Verifica la tua configurazione salata | Esempi possono ereditare un configlio globale. Utilizzare --ignore-config per un test isolato. |
| Windows .bat: doppio modello percentuale segni | Utilizzare il %(id) in un file di pacch, ma il %(id) in file di configurazione interattivi PowerShell e normale. |

- [Installare gli strumenti](https://flashdata.dev/it/docs/guides/how-to-use-yt-dlp/reference.md#install)
- [Creare una configurazione di raccolta riutilizzabile](https://flashdata.dev/it/docs/guides/how-to-use-yt-dlp/reference.md#repeatable)

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

## Qualità video e MP4


**Baseline:** ultimo notturno, Deno e FFmpeg, con `--impersonate=""`. Le ricette utilizzano Bash; sostituire l'URL di campione con la vostra fonte.

**Scarica un video con selezione predefinita**

```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"
```

Seleziona i flussi disponibili utilizzando le impostazioni di yt-dlp. Il contenitore non è necessariamente MP4.

**Elenco dei formati disponibili**

```bash
python -m yt_dlp --js-runtimes deno --impersonate="" --no-playlist \
  -F "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

I codec di controllo e le righe audio-only/video-only. ID di formato numerico non sono politiche di uscita portatili.

**Preferibilmente 1080p**

```bash
python -m yt_dlp --js-runtimes deno --impersonate="" --no-playlist -S "res:1080" \
  "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

Una preferenza: se non è disponibile alcun formato al di sotto o al di sopra dell'obiettivo, la sorta può scegliere uno sopra di esso.

**Per ottenere un massimo di 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 filtro: fallisce quando non corrisponde il formato. ritiene la scelta del codec sorgente.

**H.264 video e AAC audio in 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"
```

La selezione strettamente codec. richiede formati di corrispondenza e FFmpeg per la fusione separata.

> **Il contenitore non è codec**
> --merge-output-format sceglie il contenitore misto. --remux-video ripaglia i flussi compatibili. Non trasforma AV1 in H.264. Quando un decoder richiede un codec specifico, selezionare quel codec o pianificare un transcode separato.

- [Comprendere i selettori e i fallbacks](https://flashdata.dev/it/docs/guides/how-to-use-yt-dlp/reference.md#formats)

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

## Set dati AI: MP4 + capzioni + metadati


**Miglior video + audio, MP4, capture e metadati**

```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 unisce i flussi di sorgente. MP4 conserva i codec di sorgente; verifica la compatibilità del decoder e copertura di taglio separatamente.

- [DataSet Policy di produzione e cache mancanti](https://flashdata.dev/it/docs/guides/how-to-use-yt-dlp/reference.md#dataset)
- [Opzioni di set dati equivalenti Python](https://flashdata.dev/it/docs/guides/yt-dlp-python-api/reference.md#dataset)

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

## Il download esterno: aria2c


**Due connessioni, 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"
```

Richiede l’eseguibile aria2c. Verifica prima il download di un singolo video. Aumenta le connessioni dopo la verifica e riducile subito se compare l’errore 403.

aria2 ha la sua propria implementazione di rete. yt-dlp's curl-cffi impersonation non configurerà aria2's fingerprint. Se solo il download esterno fallisce, utilizzare --downloader nativo e confrontare la stessa fonte e la strada proxy.

- [Controlli di connessione e diagnosi di trasmissione](https://flashdata.dev/it/docs/guides/how-to-use-yt-dlp/reference.md#aria2)

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

## Il suo nome e MP3


**Salva il streaming audio originale**

```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"
```

Non MP3 conversione. utile quando il tuo pipeline di transcrizione o ripresa accetta il codec originale.

**Convertire a MP3 a bitrate di destinazione**

```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"
```

FFmpeg. 192K controlla il codificazione di uscita; non restaura la qualità della fonte.

**Preferisce M4A senza trascodificare**

```bash
python -m yt_dlp --js-runtimes deno --impersonate="" --no-playlist -f "ba[ext=m4a]" -P audio \
  "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

Fallo se non è disponibile alcun formato audio-solo M4A. Aggiungi /ba solo se la tua applicazione accetta altri contenitori di fonte.

**MP3 con metadati incorporati e copertura**

```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"
```

I passaggi metadata/thumbnail sono ulteriori post-processing. controllare il file finale, non solo il trasferimento.

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

## Capture e sottotitoli


**Elenco delle tracce disponibili**

```bash
python -m yt_dlp --js-runtimes deno --impersonate="" --no-playlist \
  --list-subs "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

Leggi le etichette linguistiche offerte da questa fonte prima di scegliere --sub-langs.

**Scarica solo i sottotitoli forniti in inglese**

```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"
```

Non ritorna alle capzioni automatiche e non scarica i media.

**Permesso anche capture automatiche in inglese**

```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"
```

* può corrispondere a varianti inglesi multiple. questo recupera i segni disponibili; non esegue il riconoscimento del discorso.

**Convertire le tracce selezionate in 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"
```

Richiede FFmpeg. Selezionare un altro codice linguistico da --list-subs se necessario.

**Inserisci i sottotitoli forniti in 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"
```

Scarica i media, le domande forniti in inglese sottotitoli e inserisce la pista disponibile. verifica prima se quella pista esiste.

Richiesta di tutte le lingue di taglio può aumentare notevolmente il numero di richieste e file. Mantenere esplicitamente le lingue richieste per il lavoro di routine. Conservare l'ID di fonte e il linguaggio nel inventario del database in modo che i trascriti non siano separati dai media che descrivono.

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

## Metadati e percorsi di uscita


**Imprimere i metadati di un video come JSON**

```bash
python -m yt_dlp --js-runtimes deno --impersonate="" --no-playlist \
  --dump-json "https://www.youtube.com/watch?v=jNQXAC9IVRw" > video.json
```

Simulate la download per default, ma esegue l'estrazione. La reindirizzamento sostituisce video.json.

**Scrivere un lato metadato completo senza media**

```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"
```

Crea un .info.json laterale.Questo è dati di estrattore operativo; campi di progetto prima di esponerlo pubblicamente.

**Scarica il miniaturismo solo**

```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"
```

Conserva il miniato disponibile nel suo formato sorgente. --convert-thumbnails jpg aggiunge un passo di conversione quando è richiesto JPEG.

**Imprima il percorso finale dei media dopo il trattamento**

```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"
```

A differenza di una fase predefinita --print, una stampa after_move aspetta un download reale e il suo passo finale.

**Appendite percorsi completati a un manifesto**

```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"
```

Aggiungi, quindi le retrazioni possono produrre entrate ripetute. trattalo come un registro di completamento, non un inventario deduplicato.

- [Progettazione dei metadati di Python](https://flashdata.dev/it/docs/guides/yt-dlp-python-api/reference.md#metadata)

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

## Il tempo e i capitoli


**Scarica i secondi 5 attraverso 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. Un limite di clip può alineare con le chiavi disponibili; verificare la produzione quando il tempo esatto è importante.

**Rincodare intorno alle taglie richieste**

```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"
```

Aggiunge il lavoro di re-codifica per migliorare il taglio ai confini richiesti. Verificare la durata risultante e audio/video allineamento.

**Dividere un video capitolato in file**

```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"
```

Utilizzare un video con metadati di capitolo. le uscite di capitolo sono separate dall'originale pieno download; spazio sul disco di bilancio per entrambi.

Utilizzare una politica di uscita o archivio diverso per i clip e i video completi. Un'ingresso archivio a livello di fonte non codifica le volte selezionate start/end, quindi un archivio condiviso può sopprimere un clip successivo che si intende creare.

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

## Le liste di gioco e le URL


**Scarica un elenco di URL conosciuto**

```bash
python -m yt_dlp --no-playlist --batch-file urls.txt -P collection -o "%(id)s.%(ext)s"
```

Creare un file UTF-8 con un'URL di visualizzazione per linea. --no-playlist si applica a visualizzare URL che includono il contesto della playlist.

**Verifica un playlist YouTube senza video completo**

```bash
python -m yt_dlp --flat-playlist \
  --dump-json "https://www.youtube.com/playlist?list=YOUR_PLAYLIST_ID" > playlist.jsonl
```

Un oggetto JSON per entrata. entrate piatte possono dimenticare i dettagli di durata e formato.

**Scarica le prime cinque entrate di 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"
```

Gli indizi di playlist sono l'indice di ordine, non identità. Mantenere l'ID video nel nome del file.

**Limitare i video idonei per data e durata**

```bash
python -m yt_dlp --dateafter 20260101 --match-filters "!is_live & duration <= 1800" \
  --batch-file urls.txt
```

Require oggetti non in diretta con una durata nota fino a 30 minuti, data o dopo gennaio 1, 2026.

**Stop dopo 10 nuovi download**

```bash
python -m yt_dlp --download-archive archive.txt --max-downloads 10 --batch-file urls.txt
```

Il limite controlla i file scaricati di recente, non quante richieste listing/extraction si verificano.

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

## Archivi e recupero


**Rispondere una collezione con la stessa politica**

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

I ID completati sono scappati. download parziali rimanere dove supportati. utilizzare gli stessi file e percorsi di uscita come il lavoro originale.

**Pace un lavoratore e leggi le sue pensioni**

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

Aggiungi un limite di lavoratore a livello di quo quando diversi processi condividono una rotta o una sessione.

**Cap trasferimento bandwidth**

```bash
python -m yt_dlp --js-runtimes deno --impersonate="" --limit-rate 2M \
  "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

Controlla il tasso di trasferimento dei media. non regola il numero di richieste di estrazione.

**Ridurre la concorrenza del fragmento nativo**

```bash
python -m yt_dlp --js-runtimes deno --impersonate="" --concurrent-fragments 1 \
  "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

Inizia con un fragmento in un momento quando si indaga 403s. Altri processi lavoratori aggiungono ancora le loro domande concorrenti.

> **L’archivio ha un lavoro specifico**
> Il codice di registrazione extractor/video è stato registrato dopo i download di successo. Non è un catalogo delle impostazioni di uscita o un controllo che un file esiste ancora. Mantenere archivi separati per le politiche audio, video e clip e non segnalare il lavoro fallito completato con --force-write-archive.

- [Una procedura di config e recupero riutilizzabile](https://flashdata.dev/it/docs/guides/how-to-use-yt-dlp/reference.md#repeatable)

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

## Configurazione e filename


**Carica solo la tua collezione esplicita config**

```bash
python -m yt_dlp --ignore-config --config-locations yt-dlp-work.conf --batch-file urls.txt
```

Il config chiaro è caricato anche con --ignore-config. Utilizzare percorsi completi per lavori pianificati.

**I nomi leggibili con identità stabile**

```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"
```

Il titolo è truncato in 150 byte in questo modello. ID distinguono titoli duplicati o cambianti.

**Utilizzare un directory temporaneo separato**

```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"
```

Assicurarsi che entrambi i directories abbiano spazio sufficiente; diversi file systems possono richiedere una copia.

Per le collezioni a lungo termine, decidere se i filenami dovrebbero essere chiavi di applicazione leggibili o stabili. I nomi e i titoli dei canali possono cambiare. Channel/video I ID sono migliori chiavi per la deduplicazione, con campi descrittivi tenuti in metadati.

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

## Cookie e percorsi di runtime


**Utilizzare il profilo del browser che ha accesso**

```bash
python -m yt_dlp --js-runtimes deno --impersonate="" \
  --cookies-from-browser "chrome:Profile 1" \
  --no-playlist "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

Sostituisci il Profile 1 con il tuo profilo del browser reale.Utilizza i cookie di sessione solo quando necessario, e li mantieni privati.

**Leggi un file cookie privato esistente**

```bash
python -m yt_dlp --js-runtimes deno --impersonate="" --cookies private/youtube-cookies.txt \
  --no-playlist "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

Require il formato di cookie di Netscape. Un'esportazione JSON non è equivalente.

**Utilizzare un Deno eseguibile al di fuori del PATH del lavoratore**

```bash
python -m yt_dlp --js-runtimes "deno:/opt/deno/bin/deno" --impersonate="" \
  --no-playlist "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

sostituire la strada con il Deno binario installato per il tuo lavoratore.

- [Cookie caricamento, scadenza e bot controlli](https://flashdata.dev/it/docs/guides/yt-dlp-sign-in-not-a-bot/reference.md)

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

## Diagnosi e verifica


**Verifica una pulita estrazione**

```bash
python -m yt_dlp --js-runtimes deno --impersonate="" --ignore-config --verbose --simulate \
  --no-playlist "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

Rimuove il config implicito e non salva nessun media. fa ancora richieste di estrazione e non dimostra che un trasferimento sarà successo.

**Scegliere un registro diagnostico privato**

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

Il redirect sostituisce il log. Redatta i valori cookie/header, le credenziali proxy e gli URL firmati prima di condividere.

**Controlla i flussi salvati e la durata**

```bash
ffprobe -v error -show_entries format=duration,size:stream=codec_type,codec_name,width,height -of json "YOUR_OUTPUT_FILE"
```

Utilizzare la strada finale, dopo il trattamento. ffprobe legge i titoli; non decodifica ogni quadro.

**Decodire il file salvato senza creare una produzione**

```bash
ffmpeg -v error -i "YOUR_OUTPUT_FILE" -f null -
```

Un controllo più profondo che legge l'intero file. Verifica lo stato di uscita e i messaggi.

**Aggiornare il pacchetto Python e controllare la versione**

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

- [Diagnosi 403 per fase](https://flashdata.dev/it/docs/guides/yt-dlp-403-forbidden/reference.md)
- [429: metadati e limiti di richiesta](https://flashdata.dev/it/docs/guides/yt-dlp-429-too-many-requests/reference.md)
- [Diagnosi di una risposta di bot-check](https://flashdata.dev/it/docs/guides/yt-dlp-sign-in-not-a-bot/reference.md)
- [Complete opzioni upstream](https://github.com/yt-dlp/yt-dlp#usage-and-options)
