# Comandos de yt-dlp para el trabajo diario

Copia comandos para vídeo, audio, subtítulos, conjuntos de datos y reanudación de recopilaciones.

Referencia canónica: https://flashdata.dev/es/docs/guides/yt-dlp-commands
Revisado: 2026-11-13 por FlashData

- [Vídeo y audio](https://flashdata.dev/es/docs/guides/yt-dlp-commands/reference.md#video) — Calidad, codecos y MP3
- [Capciones y metadatos](https://flashdata.dev/es/docs/guides/yt-dlp-commands/reference.md#subtitles) — Cortes y producción estructurada
- [Colecciones y recuperación](https://flashdata.dev/es/docs/guides/yt-dlp-commands/reference.md#archives) — Lista, archivos y config
- [Diagnóstico de fracaso](https://flashdata.dev/es/docs/guides/yt-dlp-commands/reference.md#diagnostics) — Logs y verificación de salida

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

## Configuración y Convenciones de Comando


**Comenzando con las dependencias nocturnas y completas**

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

Las recetas de descarga utilizan Deno y --impersonate="" como la línea de base. Este último requiere curl-cffi y le permite elegir una impresión de huella disponible en el navegador. Linux/macOS comanda utilizar la síntese de Bash; para un trabajador programado, también hacer estas dependencias disponibles en ese entorno de servicio.

Estos ejemplos terminales utilizan la instalación de Python de yt-dlp. Utilice su entorno virtual Python, o sustituye el Python -m yt_dlp con el comando de un solo yt-dlp. Utilice Linux primero, con las alternativas de macOS y Windows en la guía de configuración. Instalar FFmpeg/ffprobe para la fusión y Deno para la solución del reto de YouTube. Substituye el URL de ejemplo con su fuente.

| Convenio | Por qué importa |
| --- | --- |
| URLs y templates | El shell de otra manera interpreta personajes como &, espacios y parentesas. |
| Mantener %(ext)s en filenames | Los medios seleccionados y el post-procesamiento determinan la extensión. |
| Utilice --no-playlist para una URL de reloj | Un vídeo vinculado a una lista de reproducción no debe extender inesperadamente su trabajo. |
| Verifique su configuración salvada | Los ejemplos pueden heredar un config global.Utilizar --ignore-config para un test aislado. |
| Windows .bat: doble modelo de porcentaje de signos | Utilice %(id)s en un archivo de batch, pero %(id)s en los archivos de PowerShell interactivos y de configuración normal. |

- [Instalar las herramientas](https://flashdata.dev/es/docs/guides/how-to-use-yt-dlp/reference.md#install)
- [Construye una configuración de recogida reutilizable](https://flashdata.dev/es/docs/guides/how-to-use-yt-dlp/reference.md#repeatable)

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

## La calidad del video y MP4


**Base Line:** más reciente por la noche, Deno y FFmpeg, con `--impersonate=""`. Las recetas utilizan Bash; reemplazar la URL de muestra con su fuente.

**Descargar un video con selección de parcelas**

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

Selecciona los flujos disponibles utilizando las defectos de yt-dlp. El contenedor no es necesariamente MP4.

**Lista de formatos disponibles**

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

Los codecos de inspección y las líneas audio-only/video-only. los ID de formato numérico no son políticas de salida portátiles.

**Preferimos 1080p**

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

Una preferencia: si no hay formato en o debajo del objetivo disponible, la clasificación puede elegir uno sobre él.

**El máximo 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 filtro: fallan cuando no se ajusta el formato.Retence la elección de codec de fuente.

**H.264 vídeo y AAC audio en 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"
```

Requiere formatos de ajuste y FFmpeg para la fusión de corriente separada.

> **El contenedor no es codec**
> --merge-output-format elige el contenedor mezclado. --remux-video repacta los flujos compatibles. No se convierte AV1 en H.264. Cuando un decoder requiere un codec específico, seleccione ese codec o planea un transcódico separado.

- [Comprender los selectores y los fallbacks](https://flashdata.dev/es/docs/guides/how-to-use-yt-dlp/reference.md#formats)

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

## Sitio de datos: MP4 + capciones + metadatos


**Mejor vídeo + audio, MP4, capciones y metadatos**

```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 se une los flujos de fuente. MP4 mantiene los codecos de fuente; comprobar la compatibilidad del decoder y la cobertura de la etiqueta separadamente.

- [Política de salida de Dataset y capciones faltantes](https://flashdata.dev/es/docs/guides/how-to-use-yt-dlp/reference.md#dataset)
- [Opciones de conjunto de datos de Python](https://flashdata.dev/es/docs/guides/yt-dlp-python-api/reference.md#dataset)

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

## Descargar de la página: aria2c


**Dos conexiones, nativas 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"
```

Requiere el ejecutable aria2c. Comprueba primero que se descarga un solo vídeo. Aumenta las conexiones después y redúcelas en cuanto aparezca un error 403.

aria2 tiene su propia implementación de red. yt-dlp la impersonización curl-cffi no configura la imprenta de aria2. Si sólo el descargador externo fallan, utilice --downloader nativo y comparar la misma ruta de fuente y proxy.

- [Control de conexión y diagnóstico de transmisión](https://flashdata.dev/es/docs/guides/how-to-use-yt-dlp/reference.md#aria2)

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

## El audio y MP3


**Salva el 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"
```

No MP3 conversión. útil cuando su transcripción o pipeline de reproducción acepta el codec original.

**Convertir a MP3 en una bitratura de meta**

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

Uso FFmpeg. 192K controla el codificación de la salida; no restaura la calidad de la fuente.

**Preferir M4A sin transcodificación**

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

Fallece si no hay formato M4A audio-uniforme disponible.Añadir /ba sólo si su aplicación acepta otros contenedores de fuente.

**MP3 con metadatos y cubierta incorporados**

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

Los pasos metadata/thumbnail son adicionales después de procesamiento. verifique el archivo final, no sólo el huevo de transferencia.

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

## Capítulos y subtítulos


**Lista de pistas disponibles**

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

Lea las etiquetas de lenguaje ofrecidas por esta fuente antes de elegir --sub-langs.

**Descargar subtitulos en inglés solo**

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

No cae de vuelta a capciones automáticas y no descarga los medios.

**También permite capciones de inglés automáticas**

```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.* puede corresponder a varias variantes de inglés. Esto recoge las pistas disponibles; no realiza el reconocimiento del habla.

**Convertir las pistas seleccionadas a 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"
```

Requiere FFmpeg. Seleccione otro código de lenguaje de --list-subs si es necesario.

**Incluye los subtitulos suministrados en 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"
```

Descarga los medios, solicitudes suministradas en inglés y inserta la pista disponible. ver si esa pista existe primero.

Requestar todas las lenguas de la etiqueta puede aumentar significativamente el número de solicitudes y archivos. Mantenga los idiomas solicitados explícitos para el trabajo de rutina. Conserva el ID de fuente y el idioma en su inventario de los datos para que los transcriptos no se desprenden de los medios que describen.

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

## Metadatos y Paths de salida


**Imprimir los metadatos de un vídeo como JSON**

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

Simula la descarga por defecto, pero realiza la extracción. La redireción sustituye video.json.

**Escribir un lateral de metadatos completo sin medios**

```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 lateral. Esto es datos de extractor operativo; campos de proyecto antes de exponerlos públicamente.

**Descarga el mini-enlace 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"
```

Salva el minial disponible en su formato de fuente. --convert-thumbnails jpg añade un paso de conversión cuando se requiere JPEG.

**Imprimir el camino de los medios finales después del procesamiento**

```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 diferencia de una etapa de default --print, una impresión after_move espera para un descarga real y su movimiento final.

**Añadir los caminos completos a un manifiesto**

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

Apendices, así que las retrasas pueden producir entradas repetidas. Tratarlo como un log de cumplimiento, no un inventario deduplicado.

- [Proyección de metadatos de Python](https://flashdata.dev/es/docs/guides/yt-dlp-python-api/reference.md#metadata)

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

## Temas y capítulos


**Descargar segundos 5 a través de 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 límite de clip puede alinearse con los marcados de teclado disponibles; verifique la salida cuando el tiempo exacto se refiere.

**Re-encodado alrededor de los cortes solicitados**

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

Ads trabajo de re-encodamiento para mejorar la corte en los límites solicitados. Inspeccionar la duración resultante y audio/video alineación.

**Dividir un video en archivos**

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

Utilice un video con metadatos de capítulo. las salida de capítulo son separadas del original completo de descarga; espacio de disco presupuestario para ambos.

Utilice una política de salida o archivo diferente para clips y videos completos. Una entrada de archivo de nivel de fuente no codifica las veces seleccionadas start/end, por lo que un archivo compartido puede suprimir un clip posterior que intenta crear.

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

## Lista de juegos y URL


**Descargar una lista de URL conocido**

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

Crea un archivo UTF-8 con una URL de observación por línea. --no-playlist se aplica a ver URL que incluyen el contexto de lista de reproducción.

**Inspeccionar una lista de reproducción de YouTube sin extracción de vídeo completa**

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

Un objeto JSON por entrada.Entradas de plano pueden omitir los detalles de duración y formato.

**Descarga las primeras cinco entradas 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"
```

Los índices de lista de reproducción muestran orden, no identidad.Manten el ID de vídeo en el nombre de archivo.

**Limitar los videos elegibles por fecha y duración**

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

Requiere artículos no en vivo con una duración conocida hasta 30 minutos, datados en o después de enero 1, 2026.

**Descargar después de 10 nuevas descargas**

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

El límite controla los archivos recién descargados, no cuántos pedidos listing/extraction ocurren.

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

## Archivo y recuperación


**Recuperar una colección con la misma política**

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

Los IDs completos se descuidaron.Las descargas parciales se resumen donde se apoyan.Utilizar los mismos archivos y rutas de salida como el trabajo original.

**Pace a un trabajador y vincula sus jubilaciones**

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

Añade un límite de trabajador de nivel de cueva cuando varios procesos comparten una ruta o sesión.

**Cap transferencia de banda**

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

Controlar la tasa de transferencia de medios. no regula el número de solicitudes de extracción.

**Reducir la concorrencia de fragmentos nativos**

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

Comienza con un fragmento a la vez cuando investiga 403s. Otros procesos de trabajadores todavía añaden sus propias solicitudes concurrentes.

> **El archivo tiene un trabajo específico**
> Recuerda extractor/video IDs después de descargas exitosas. No es un catálogo de configuraciones de salida o un cheque de que un archivo todavía existe. Mantenga archivos separados para las políticas de audio, vídeo y clip, y no marca el trabajo fallado completo con --force-write-archive.

- [Un proceso de reutilización y recuperación](https://flashdata.dev/es/docs/guides/how-to-use-yt-dlp/reference.md#repeatable)

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

## Configuración y filenames


**Sólo cargue su colección explícita config**

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

El nombre explicitamente denominado de la configuración se carga incluso con --ignore-config. Utilice los caminos completos para los trabajos programados.

**Nombres con identidad estable**

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

El título se truncó en 150 bajos en este modelo. IDs distinguen títulos duplicados o cambiantes.

**Utilice un directorio temporal separado**

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

Asegúrese de que ambas directorias tienen espacio suficiente; diferentes sistemas de archivos pueden requerir una copia.

Para las colecciones de larga duración, decida si los filenames deben ser clave de aplicación humano-leable o estable. Los nombres y los títulos de los canales pueden cambiar. Channel/video Los IDs son mejores claves para la deduplicacin, con campos descriptivos conservados en metadatos.

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

## Cookies y caminos de tiempo de trabajo


**Utilice el perfil de navegador que tiene acceso**

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

Substituye el perfil 1 con su perfil de navegador real. Utilice las cookies de sesión sólo cuando sea necesario, y mantenga privadas.

**Leer un archivo de cookies privados existente**

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

Requiere el formato de cookie de Netscape. Un JSON de exportación no es equivalente.

**Utilice un Deno ejecutable fuera del PATH del trabajador**

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

Substituye el camino con el Deno binario instalado para su trabajador.

- [Carga de cookies, expiración y bot checks](https://flashdata.dev/es/docs/guides/yt-dlp-sign-in-not-a-bot/reference.md)

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

## Diagnóstico y verificación


**Inspeccion de una extracción limpia**

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

Elimina el configurador implicito y no salva ningún medio. todavía hace solicitudes de extracción y no demuestra que un traslado va a ser exitoso.

**Capturar un log de diagnóstico privado**

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

Redact cookie/header valores, credenciales de proxy y URLs firmados antes de compartir.

**Inspeccion de los flujos y la duración salvos**

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

Utilice el camino final, después de procesar. ffprobe lee los heads; no decodifica cada marco.

**Descifrar el archivo salvado sin crear salida**

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

Un examen más profundo que lee todo el archivo. ver el estado de salida y los mensajes.

**Actualizar el paquete de Python y ver la versión**

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

- [Diagnóstico 403 por etapa](https://flashdata.dev/es/docs/guides/yt-dlp-403-forbidden/reference.md)
- [429: metadatos y límites de solicitud de la nota](https://flashdata.dev/es/docs/guides/yt-dlp-429-too-many-requests/reference.md)
- [Diagnóstico de respuesta bot-check](https://flashdata.dev/es/docs/guides/yt-dlp-sign-in-not-a-bot/reference.md)
- [Referencia Opcional de Upstream](https://github.com/yt-dlp/yt-dlp#usage-and-options)
