Salta al contenuto
IT
Ottieni la chiave API
Sfoglia la documentazione

Guide

Comandi yt-dlp per il lavoro quotidiano

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

In questa pagina

Configurazione e Command Conventions

Inizia con le dipendenze notturne e complete
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.

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

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

Set dati AI: MP4 + capzioni + metadati

Miglior video + audio, MP4, capture e metadati
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.

Il download esterno: aria2c

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

Il suo nome e MP3

Salva il streaming audio originale
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
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
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
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.

Capture e sottotitoli

Elenco delle tracce disponibili
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
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
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
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
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.

Metadati e percorsi di uscita

Imprimere i metadati di un video come JSON
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
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
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
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
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.

Il tempo e i capitoli

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

Le liste di gioco e le URL

Scarica un elenco di URL conosciuto
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
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
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
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
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.

Archivi e recupero

Rispondere una collezione con la stessa politica
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
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
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
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.

Configurazione e filename

Carica solo la tua collezione esplicita config
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
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
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.

Cookie e percorsi di runtime

Utilizzare il profilo del browser che ha accesso
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
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
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.

Diagnosi e verifica

Verifica una pulita estrazione
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
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
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
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
python -m pip install -U --pre "yt-dlp[default,curl-cffi]"
python -m yt_dlp --version