# yt-dlp-Befehle für den Alltag

Kopiere Befehle für Video, Audio, Untertitel, Datensätze und das Fortsetzen von Sammlungen.

Kanonische Referenz: https://flashdata.dev/de/docs/guides/yt-dlp-commands
Test: 2026-11-13 von FlashData

- [Video und Audio](https://flashdata.dev/de/docs/guides/yt-dlp-commands/reference.md#video) — Qualität, Codecs und MP3
- [Kaptionen und Metadaten](https://flashdata.dev/de/docs/guides/yt-dlp-commands/reference.md#subtitles) — Sidecars und strukturierte Ausgabe
- [Sammlungen und Erholung](https://flashdata.dev/de/docs/guides/yt-dlp-commands/reference.md#archives) — Liste, Archiv und Konfig
- [Diagnose eines Scheitern](https://flashdata.dev/de/docs/guides/yt-dlp-commands/reference.md#diagnostics) — Logs und Ausgangskontrolle

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

## Setup und Command Konventionen


**Beginnen Sie mit den aktuellen Nacht- und vollständigen Abhängigkeiten**

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

Die Download-Rezepte verwenden Deno und --impersonate="" als Grundlinie. Das letzte erfordert curl-cffi und lässt es einen verfügbaren Browser-Fingerprint auswählen. Linux/macOS befehlt die Benutzung von Bash Syntax; für einen geplanten Arbeitnehmer, machen diese Abhängigkeiten auch in diesem Service-Umfeld zur Verfügung.

Diese Terminal-Exemplen verwenden die Python-Installation von yt-dlp. Verwenden Sie Ihre virtuelle Umgebung Python, oder ersetzen Sie Python -m yt_dlp mit der Standalone yt-dlp-Kommand. Verwenden Sie Linux zuerst, mit macOS und Windows-Alternativen im Setup-Guide. Installieren Sie FFmpeg/ffprobe für die Fusion und Deno für die YouTube-Problemlösung. Ersetzen Sie die URL-Adresse mit Ihrer Quelle.

| Übereinkommen | Warum es wichtig ist |
| --- | --- |
| URLs und Templates | Die Schale interpretiert anders Charaktere wie &, Räume und Parenthesen. |
| %(ext)s in Filenamen halten | Die ausgewählten Medien und Post-Verarbeitung bestimmen die Erweiterung. |
| Verwenden Sie --no-playlist für eine Uhr URL | Ein Video, das von einer Playlist verknüpft wird, sollte nicht unerwartet Ihre Arbeit erweitern. |
| Überprüfen Sie Ihre gespeicherten Konfiguration | Beispiele können eine globale Konfiguration erben. Verwenden Sie --ignore-config für einen isolierten Test. |
| Windows .bat: doppelte Prozentsatz-Signale | Verwenden Sie %%(id)s in einem Battch-Datei, aber %(id)s in interaktiven PowerShell und normalen Konfigurierungsdateien. |

- [Installieren Sie die Tools](https://flashdata.dev/de/docs/guides/how-to-use-yt-dlp/reference.md#install)
- [Erstellen Sie eine wiederverwendbare Sammelkonfiguration](https://flashdata.dev/de/docs/guides/how-to-use-yt-dlp/reference.md#repeatable)

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

## Videoqualität und MP4


**Baseline:** neueste Nacht, Deno und FFmpeg, mit `--impersonate=""`. Die Rezepte verwenden Bash; ersetzen Sie die URL der Probe mit Ihrer Quelle.

**Download eines Videos mit Standardwahl**

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

Wählen Sie verfügbare Streams mit den Standardwerte yt-dlp aus. Der Container ist nicht unbedingt MP4.

**Liste verfügbare Formate**

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

Inspektieren Sie Codecs und audio-only/video-only Zeilen. Numerische Format-IDs sind keine tragbaren Ausgangsbestimmungen.

**Vorzugsweise 1080p**

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

Eine Vorliebe: Wenn kein Format am oder unter dem Ziel verfügbar ist, kann die Sortierung einen über ihn wählen.

**Erhalten Sie ein Maximum von 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"
```

Ein Filter: Scheitert, wenn kein Format vereinbart. Er hält die Quellcode-Wahl auf.

**H.264 Video und 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"
```

Strenge Codec-Serie. Erfordert matching-Formate und FFmpeg für separate Stream-Fusion.

> **Container ist kein Codec**
> --merge-output-format wählt den gemischten Container. --remux-video verpackt kompatible Ströme. Auch wird AV1 nicht in H.264 umgewandelt. Wenn ein Dekoder einen spezifischen Codec benötigt, wählen Sie diesen Codec aus oder planen Sie einen separaten Transcode.

- [Selektoren und Fallbacks verstehen](https://flashdata.dev/de/docs/guides/how-to-use-yt-dlp/reference.md#formats)

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

## AI-Daten: MP4 + Kaptionen + Metadaten


**Beste Video + Audio, MP4, Captions und Metadaten**

```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 vereint Quellströme. MP4 hält Quellcodes; überprüft die Decoder-Kompatibilität und den Abschlüssel abgesehen.

- [Dataset-Ausgangspolitik und fehlende Kaptionen](https://flashdata.dev/de/docs/guides/how-to-use-yt-dlp/reference.md#dataset)
- [Äquivalent Python Datensatz-Optionen](https://flashdata.dev/de/docs/guides/yt-dlp-python-api/reference.md#dataset)

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

## Externe Downloader: aria2c


**Zwei Verbindungen, 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"
```

Setzt die ausführbare Datei aria2c voraus. Prüfe zuerst den Download eines einzelnen Videos. Erhöhe erst dann die Zahl der Verbindungen und reduziere sie sofort bei Fehler 403.

aria2 hat eine eigene Netzwerkimplementierung. yt-dlp Impersonenierung curl-cffi konfiguriert nicht aria2 Fingerabdruck. Wenn nur der externe Downloader versagt, verwenden Sie --downloader native und vergleichen Sie die gleiche Quelle und Proxy-Route.

- [Verbindungskontrolle und Durchgangsdiagnose](https://flashdata.dev/de/docs/guides/how-to-use-yt-dlp/reference.md#aria2)

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

## Audio und MP3


**Speichern Sie den ursprünglichen Audio-Stream**

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

Keine MP3-Konvertierung. nützlich, wenn Ihre Transcription oder Playback-Pipeline den ursprünglichen Codec akzeptiert.

**Konvertieren Sie MP3 zu einem Zielbitrate**

```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 kontrolliert die Ausgangs-Coding; es wiederhaltet nicht Quellqualität.

**Vorzugsweise M4A ohne Transcoding**

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

Versagen, wenn kein M4A Audio-only Format verfügbar ist. Add /ba nur, wenn Ihre Anwendung andere Quellcontainer akzeptiert.

**MP3 mit eingebetteten Metadaten und Abdeckung**

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

Die Schritte metadata/thumbnail sind zusätzliche Post-Verarbeitung. Überprüfen Sie die endgültige Datei, nicht nur die Transfer-Hoch.

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

## Kapitel und Untertitel


**Liste der verfügbaren Spuren**

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

Lesen Sie die von dieser Quelle angebotenen Sprachtags, bevor Sie --sub-langs wählen.

**Download angebotene Englisch Untertitel nur**

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

Es fällt nicht zurück zu automatischen Fassungen und herunterladen nicht die Medien.

**Auch automatische Englisch-Kaptionen erlaubt**

```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.* kann mehrere Englisch-Varianten entsprechen.Dies erfasst verfügbare Spuren; es führt keine Spracherkennung.

**Umwandeln Sie ausgewählte Spuren 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"
```

Erfordert FFmpeg. Wählen Sie bei Bedarf einen anderen Sprachcode aus --list-subs aus.

**In den zugelassenen Untertiteln in MKV eingefügt**

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

Laden Sie Medien herunter, fordern Sie Angebotsunterschriften und geben Sie die verfügbare Track ein. Prüfen Sie, ob diese Track zuerst existiert.

Die Anfrage aller Übersetzungssprachen kann die Anzahl der Anfragen und Dateien erheblich erhöhen. Halten Sie die angestrebten Sprachen für die Routinearbeit ausdrücklich. Bewahren Sie die Quell-ID und Sprache in Ihrem Datensatz-Inventor, damit Transcripts nicht von den Medien, die sie beschreiben, abgesehen werden.

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

## Metadaten und Ausgangswege


**Drucken Sie die Metadaten eines Videos als JSON**

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

Simuliert die Download nach Vorwahl, aber führt die Extraction durch. Die Umleitung ersetzt video.json.

**Schreiben Sie eine vollständige Metadaten-Seitenkarte ohne Medien**

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

Erstellt eine .info.json Seitenfläche. Dies ist die operationelle Extraktordaten; Projektfelder, bevor sie öffentlich exponiert wird.

**Download nur das Miniatüre**

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

Speichert das verfügbare Mini-Nummer in seinem Quellformat. --convert-thumbnails jpg fügt ein Konvertierungsstadium hinzu, wenn JPEG erforderlich ist.

**Drucken Sie den letzten Medienweg nach der Verarbeitung**

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

Im Gegensatz zu einem Standard-Schritt --print wartet ein after_move Druck auf eine echte Download und seine endgültige Bewegung.

**Erfüllte Wege zu einem Manifest**

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

Fügen Sie hinzu, so dass Retries wiederholte Eingänge produzieren können. behandeln Sie es als ein Vollendungslog, nicht als eine deduplierte Inventory.

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

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

## Zeiträume und Kapitel


**Download Sekunden 5 durch 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"
```

Anforderung FFmpeg. Ein Clip-Grenz kann mit verfügbaren Schlüsselframes angepasst werden; überprüfen Sie den Ausgang, wenn die genaue Timing wichtig ist.

**Re-code um die gebuchten Abschnitten**

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

Erhöht die Wiederkodearbeit, um die Abschnittsgrenze zu verbessern. Überprüfen Sie die resultierende Dauer und audio/video Anpassung.

**Teilen Sie ein Kapitelvideo in Dateien**

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

Nutzen Sie ein Video mit Kapitelmetadata. Kapitel-Ausgänge sind von der ursprünglichen vollständigen Download getrennt; Budget-Disk-Raum für beide.

Verwenden Sie eine andere Ausgangsrichtlinie oder Archiv für Clips und vollständige Videos. Eine Quell-Level-Archiv-Einträge verschlüsselt nicht die ausgewählten start/end-Träume, so dass ein gemeinsamer Archiv einen späteren Klip, den Sie erstellen möchten, abschalten kann.

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

## Playlisten und URL-Listen


**Download einer bekannten URL-Liste**

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

Erstellen Sie eine UTF-8 Datei mit einem Watch URL pro Zeile. --no-playlist gilt für die Anzeige von URLs, die den Playlist-Kontext enthalten.

**Überprüfen Sie eine YouTube-Playlist ohne vollständige Video-Extraktion**

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

Ein JSON Objekt pro Eingang. Flachte Eingänge können Dauer und Formatdetails vergessen.

**Download der ersten fünf Playlist-Eintrag**

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

Die Playlist-Indizes zeigen die Bestellung, nicht die Identität.Halten Sie das Video-ID im Dateiname.

**Begrenzen der Anforderungen an die Anforderungen an die Date und Dauer**

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

Es erfordert nicht-live-artikel mit bekannter Dauer bis 30 Minuten, datiert am oder nach Januar 1, 2026. Filterung kann noch per-video-Anfragen erforderlich.

**Stop nach zehn neuen Downloads**

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

Die Grenze kontrolliert neu heruntergeladenen Dateien, nicht wie viele listing/extraction Anfragen auftreten.

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

## Archiv und Wiederherstellung


**Wiederholen Sie eine Sammlung mit der gleichen Politik**

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

Vollendete IDs werden verschoben. Teilhafte Downloads wieder auftreten, wo unterstützt wird. Verwenden Sie die gleichen Archiv- und Ausgangswege wie die ursprüngliche Arbeit.

**Ein Arbeitnehmer freist und verpflichtet seine Renten**

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

Diese sind Prozesseinstellungen. fügen Sie eine Quelle-Level-Arbeitergrenze hinzu, wenn mehrere Prozesse eine Route oder eine Sitzung teilen.

**Kapazität Transfer Bandwidth**

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

Kontrolliert die Medienübertragungsrate. Es reguliert nicht die Anzahl der Ausführungsanfragen.

**Reduzieren Sie die Konkurrenz in der natürlichen Fragmente**

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

Beginnen Sie mit einem Fragment zu einem Zeitpunkt, wenn Sie 403s untersuchen. Andere Arbeiterprozesse fügen noch ihre eigenen gleichzeitigen Anfragen hinzu.

> **Das Archiv hat eine besondere Arbeit**
> Es speichert extractor/video-IDs nach erfolgreichen Downloads. Es ist kein Katalog der Ausgangsinstellungen oder eine Überprüfung, dass ein Datei noch existiert. Halten Sie separate Archiv für Audio, Video und Clip-Politiken und markieren Sie nicht die erfolglosen Arbeit vollständig mit --force-write-archive.

- [Eine erneute Konfiguration und Wiederherstellung](https://flashdata.dev/de/docs/guides/how-to-use-yt-dlp/reference.md#repeatable)

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

## Konfiguration und Filenamen


**Laden Sie nur Ihre explicite Sammlung config**

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

Die ausdrücklich benannte Konfiguration wird sogar mit --ignore-config geladen. Verwenden Sie volle Pfade für geplante Jobs.

**Lesbare Namen mit stabiler Identität**

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

Der Titel wird in 150-Bytes in diesem Template vertrinkt. IDs unterscheiden duplikierte oder ändernde Titel.

**Verwenden Sie eine separate temporäre Katalog**

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

Stellen Sie sicher, dass beide Directory genügend Platz haben; verschiedene Dateisysteme können eine Kopie benötigen.

Für langlebige Sammlungen entscheiden Sie, ob Filenamen menschlich gelesen oder stabile Anwendungsschlüssel sein sollten. Kanalnamen und Titel können sich ändern. Channel/video IDs sind bessere Schlüssel für Deduplikation, mit beschreibenden Feldern in Metadaten gehalten.

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

## Cookies und Runtime-Paths


**Verwenden Sie das Browser-Profil, das Zugriff hat**

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

Ersetzen Sie Profile 1 mit Ihrem tatsächlichen Browser-Profil. Verwenden Sie Session-Cookies nur, wenn nötig, und halten Sie sie privat.

**Lesen Sie eine vorhandene private Cookie-Datei**

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

Es erfordert Netscape Cookie-Format. Ein JSON Export ist nicht gleichwertig.

**Verwenden Sie einen Deno-Exekutiver außerhalb des Arbeiters PATH**

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

Ersetzen Sie den Weg mit dem Deno-Binarium, das für Ihren Arbeitnehmer installiert ist.

- [Cookie-Laden, Auslauf und Bot-Checks](https://flashdata.dev/de/docs/guides/yt-dlp-sign-in-not-a-bot/reference.md)

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

## Diagnose und Verifizierung


**Überprüfen Sie eine saubere Extraction**

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

Es entfernt implizit Konfig und speichert keine Medien. Es macht immer noch Extraction Anfragen und beweist nicht, dass eine Übertragung erfolgreich wird.

**Erfassung eines privaten Diagnose-Log**

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

Die Umleitung ersetzt die Log. Redakt cookie/header Werte, Proxy-Kreditials und unterzeichneten URLs vor dem Teilen.

**Überprüfen Sie gesparte Ströme und Dauer**

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

Verwenden Sie den endgültigen Weg, nach der Verarbeitung. ffprobe Lesen Sie die Header; es dekodiert nicht jedes Rahmen.

**Die gespeicherten Dateien dekotieren, ohne Ausgang zu erstellen**

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

Eine tieferen Überprüfung, die das gesamte Datei liest. Überprüfen Sie den Status des Ausgangs und die Nachrichten.

**Aktualisieren Sie das Python-Paket und überprüfen Sie seine Version**

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

- [Diagnose 403 nach Stufe](https://flashdata.dev/de/docs/guides/yt-dlp-403-forbidden/reference.md)
- [429: Metadaten und Nachteile Anfrage Grenzen](https://flashdata.dev/de/docs/guides/yt-dlp-429-too-many-requests/reference.md)
- [Eine BOT-Check-Reaktion zu diagnostizieren](https://flashdata.dev/de/docs/guides/yt-dlp-sign-in-not-a-bot/reference.md)
- [Komplette Upstream-Option Referenz](https://github.com/yt-dlp/yt-dlp#usage-and-options)
