# Zo gebruik je yt-dlp

Een Linux-gerichte gids voor dagelijkse downloads met de nightly-versie, formaten, ondertitels, datasets en hervatbare verzamelingen.

Canonische referentie: https://flashdata.dev/nl/docs/guides/how-to-use-yt-dlp
Beoordeeld: 2026-11-13 door FlashData

- [Stel de tools op](https://flashdata.dev/nl/docs/guides/how-to-use-yt-dlp/reference.md#install) — Python, FFmpeg en JavaScript
- [Kies de uitkomst](https://flashdata.dev/nl/docs/guides/how-to-use-yt-dlp/reference.md#formats) — Video, audio en capties
- [Herhaal een collectie](https://flashdata.dev/nl/docs/guides/how-to-use-yt-dlp/reference.md#repeatable) — Manifest, config en archief
- [Fix een mislukte run](https://flashdata.dev/nl/docs/guides/how-to-use-yt-dlp/reference.md#maintain) — Vind de juiste diagnose

<a id="install"></a>

## Installeer de dagelijkse basislijn


**Start met Nightly + Deno + FFmpeg.** Gebruik een project-virtuele omgeving en maakt de browser-impersoonlijn mogelijk met `--impersonate=""`.De Linux-instelling hieronder installeert de tools; macOS en Windows-alternatieven zijn in de tabs.

**Linux**

Ubuntu / Debian voorbeeld met Python 3.11+. Installeren van de systeemtools, creëren van een project virtuele omgeving, installeren dan de huidige nacht en de extra's.


**Linux werkers opzetten**

```bash
sudo apt-get update
sudo apt-get install -y python3 python3-venv ffmpeg aria2 curl unzip
python3 -m venv .venv
source .venv/bin/activate
python -m pip install -U --pre "yt-dlp[default,curl-cffi]"
curl -fsSL https://deno.land/install.sh -o /tmp/install-deno.sh
sh /tmp/install-deno.sh
export PATH="$HOME/.deno/bin:$PATH"
deno --version
python -m yt_dlp --version
```


**macOS**

Met Homebrew geïnstalleerd, gebruik het voor Python, Deno, FFmpeg en aria2. Houd yt-dlp zelf in de projectomgeving zodat de nachtelijke update commando is hetzelfde als op Linux.


**MacOS optie**

```bash
brew install python deno ffmpeg aria2
python3 -m venv .venv
source .venv/bin/activate
python -m pip install -U --pre "yt-dlp[default,curl-cffi]"
deno --version
python -m yt_dlp --version
```


**Windows · PowerShell**

Installeer Python 3.11+, Deno en de FFmpeg-uitvoersmogelijkheden, en opent vervolgens een nieuw terminal. Gebruik de mediatranslater rechtstreeks als PowerShell de activatie blokkeert. aria2 is optioneel; installeren deze afzonderlijk als u het externe downloadrecept gebruikt.


**Windows Milieu**

```powershell
py -3 -m venv .venv
.\.venv\Scripts\python.exe -m pip install -U --pre "yt-dlp[default,curl-cffi]"
deno --version
ffmpeg -version
.\.venv\Scripts\python.exe -m yt_dlp --version
```


| Hulpmiddel | Wat het doet | Controleren |
| --- | --- | --- |
| Python 3.11+ | De Python-pakket en voorbeelden in deze serie worden uitgevoerd. | python --version |
| Laatste yt-dlp nachtelijk + standaard,curl-cffi extra | De huidige YouTube extractor, overeenkomstig EJS solver en browser impersonatie ondersteuning. | python -m yt_dlp --version |
| FFmpeg en ffprobe | Samenvoegen streams, audio converteren, clips snijden en inspecteren opgeslagen media. | ffmpeg -version / ffprobe -version |
| Deno 2.3+ (verplicht in deze werkstroom) | Het gaat om YouTube-uitdagingen. installeren op elke werknemer, niet alleen uw ontwikkelingssysteem. | deno --version |

**Installeren van de uitvoerende ook.** `[default]` levert de EJS-schriften; Deno is gescheiden. FFmpeg en ffprobe moet ook op de PATH van de werknemer zijn.

**Bekijk de volledige baseline**

```bash
deno --version
ffmpeg -version
ffprobe -version
python -m pip show yt-dlp yt-dlp-ejs curl-cffi
python -m yt_dlp --list-impersonate-targets
```

Als de doelen niet beschikbaar zijn, controleer dan dat curl-cffi is geïnstalleerd in deze exacte virtuele omgeving.

**Testextractie met Deno en browser-impersonatie**

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

Controleer de JS runtime en vraag-handelaar lijnen. een simulatie test extractie; volgt het met een echte overdracht.

De basislijn van FlashData omvat --impersonate=": het laat curl-cffi een beschikbare browser vingerafdruk kiezen. Dit verandert de vingerdruk van het verzoek; het biedt geen login cookies, opent JavaScript-ontwerpen of wijzigt de IP-uitgang. Als deze optie een werkroute vertraagt of fouten introduceert, herhaal hetzelfde een-video-test zonder dat en hou de werkende configuratie.

> **Een dienst heeft zijn eigen pad nodig**
> De Deno installator zet normaal de binaire in ~/.deno/bin. Een interactieve shell dat het gevonden, bewijst niet dat een service, container of cron kan werken. Stel de werknemer PATH of pass --js-runtimes deno:/absolute/path/to/deno. Gebruik de Python-pad van de virtuele omgeving in de service command.

- [Officiële installatie](https://github.com/yt-dlp/yt-dlp/wiki/Installation)
- [FFmpeg downloads](https://ffmpeg.org/download.html)
- [Installeren van Deno](https://docs.deno.com/runtime/getting_started/installation/)
- [YouTube runtime installatie](https://github.com/yt-dlp/yt-dlp/wiki/EJS)

<a id="verify-install"></a>

### Controleer de vrijlating voordat u het op een werknemer plaatst


Krijg executables vanaf de officiële release pagina van het project, of installeren de Python-pakket uit de gepubliceerde pakketbron. Als u een standaard binaire downloaden, vergelijk dan de SHA-256 met de matching filename in die release SHA2-256SUMS. Record de release en checksum met uw werknemersbeeld zodat u precies kunt identificeren wat er ging.

**Linux**


**Hash de gedownload bestand**

```bash
sha256sum yt-dlp
```


**macOS**


**Hash de gedownload bestand**

```bash
shasum -a 256 yt-dlp_macos
```


**Windows**


**Hash de gedownload bestand**

```powershell
Get-FileHash -Algorithm SHA256 .\yt-dlp.exe
```


Een checksum vergelijking is alleen nuttig wanneer de verwachte waarde afkomstig is van de vertrouwde release, niet dezelfde onbekende spiegel als de uitvoerbare. Als de beveiligingsoftware een bestand vlaggt, onderzoekt u de bron en rapporteert u voordat u een uitzondering maakt. Open-source beschikbaarheid alleen is geen bewijs dat elke gedownload binaire of derde-party plugin veilig is.

Verwerken gedeelde configuratiebestanden als code om te beoordelen: opties zoals --exec kan de commando's lanceren, en plugins toevoegen code aan het downloaderproces. Houd browser cookies, proxy-certificaten en gesignaleerde URL's uit configuratie voorbeelden en diagnostische rapporten.

- [Officiële verslagen en checksums](https://github.com/yt-dlp/yt-dlp/releases)

<a id="first-download"></a>

## Download een video


**Uit één korte video eerst.** Citat de URL, voeg `--no-playlist` toe en noem de bestand door video ID. De opdracht drukt de laatste route na fusie en post-verwerking.

**Een video, een output map**

```bash
python -m yt_dlp --js-runtimes deno --impersonate="" --no-playlist -P downloads \
  -o "%(id)s.%(ext)s" --print after_move:filepath \
  "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

De gedrukte route is de bestand na fusie en post-verwerking. Open die route; veronderstel niet dat de bestand zal eindigen in .mp4.

Zonder een format override, yt-dlp kiest zijn voorkeurs beschikbaar streams. Hoogwaardige bronnen hebben vaak afzonderlijke video en audio streams, dus twee overdrachten gevolgd door een FFmpeg fusie zijn normaal. Een .part-bestand en een .part-bestand kunnen verschijnen terwijl de werkzaamheden worden uitgevoerd.

> **Niet hardcode de uitbreiding**
> Houd %(ext)s in de uitgangsmodel.Namen van een WebM stroom file.mp4 verandert alleen zijn naam.Format selectie, remuxing en conversie beslist wat er binnen het bestand is.

<a id="formats"></a>

## Kies kwaliteit en codecs


**Controleer de formaten van deze video**

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

**Kies een beleid, niet een gecopiëerde formatsID.** Check resolutie, codecs en afzonderlijke audio/video tracks.

| Selectie of optie | Betekenis | Wanneer het te gebruiken |
| --- | --- | --- |
| Bv + ba | Kies een video-eigen stream en een audio-eigen stream; FFmpeg combineert ze. | Je hebt beide tracks nodig en kunt lokaal fuseren. |
| A/B | Probeer selector A, dan B als A niet beschikbaar is. | Definieer een uitdrukkelijke fallback in plaats van te veronderstellen dat elke bron dezelfde formaten heeft. |
| [height<=1080] | Verwijder stromen boven 1080 pixels hoog. | Een harde bovenbonden is een vereiste. |
| -S res:1080 | Prefereren resolutie tot 1080; je kunt een grotere selecteren wanneer er geen van de onderstaande is beschikbaar. | 1080p is een voorkeur in plaats van een harde plafond. |
| --merge-output-format mp4 | Kies de container bij het mengen van afzonderlijke stromen. | U hebt al compatibele stromen geselecteerd. het transcode codecs niet. |

**Houd de source codecs, met een harde 1080p plafond**

```bash
python -m yt_dlp --js-runtimes deno --impersonate="" --no-playlist \
  -f "bv*[height<=1080]+ba/b[height<=1080]" -P downloads \
  "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

Dit kan WebM, MP4 of een ander ondersteunde container produceren. het faalt als geen format voldoet aan de plafond; het downloaden niet stil 4K.

Voor een editor of playback stack dat specifiek H.264 video en AAC audio vereist, filteren deze codecs en vallen in MP4. MP4 is een container: een stroom in een MP4 container kan nog steeds een codec bevatten die uw applicatie niet kan decoderen.

**Vraag H.264 + AAC, tot 1080p**

```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 -P downloads "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

Als de vereiste codecs niet beschikbaar zijn, mislukt deze strikte selector. beslist of u verschillende source codecs of transcode accepteert; verwijder de vereiste niet per ongeluk.

Remuxing herverpakkt stromen zonder ze te hercoderen. Transcoding verandert codecs en consumeert CPU terwijl potentieel kwaliteit verandert. Gebruik --remux-video wanneer de stromen al passen aan de doelcontainer; gebruik een gewone FFmpeg conversie wanneer een downstream decoder verschillende codecs vereist.

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

## Speel audio of MP3


Als uw transcriptiedreven de bron audio codec accepteert, download dan die streaming direct. Dit vermijdt onnodige verliesconversie. MP3 is nuttig wanneer een consument specifiek nodig heeft; een hoge MP3 bitrate kan niet herstellen van de details die al verloren zijn in de bron.

**Houd de beste beschikbare audio-stromen**

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

Verwachten de bron container en codec, meestal M4A/AAC of WebM/Opus.

**Convert audio naar MP3**

```bash
python -m yt_dlp --js-runtimes deno --impersonate="" --no-playlist -f ba -x \
  --audio-format mp3 --audio-quality 0 -P audio -o "%(id)s.%(ext)s" \
  "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

Require FFmpeg. --audio-quality 0 selecteert de beste variabele-kwaliteitsinstelling; gebruik een bitrate zoals 192K wanneer uw downstream specificatie een vereist.

<a id="sidecars"></a>

## Speel capties en metadata


Een nuttige collectie heeft meer nodig dan filenamen. Houd video-ID's, bronnenURL's, titels, duur en beschikbare capties op zodat u de collectie kunt zoeken en een activa terug kunt traceeren naar de bronnen. Begin met het opnemen van de opname tracks; het vragen en betekent niet dat elke video een Engelse track heeft.

**Inspecteer capties, bespaar Engelse tracks zonder media**

```bash
python -m yt_dlp --list-subs "https://www.youtube.com/watch?v=jNQXAC9IVRw"
python -m yt_dlp --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"
```

--write-subs selecteert geleverde ondertitels; --write-auto-subs toelaat ook automatische capties. Dit herstelt bestaande tracks en transcribeert geen video die geen.

**Media met metadata en een miniatuur**

```bash
python -m yt_dlp --js-runtimes deno --impersonate="" --no-playlist --write-info-json \
  --write-thumbnail -P downloads -o "%(id)s.%(ext)s" \
  "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

De .info.json bestand is gedetailleerde operationele metadata, niet een schone openbare API-respons. Het kan uitgestorven media-URL's en verzoekgerelateerde velden omvatten. Houd de volledige zijdek met de collectie en exporteer alleen de velden die uw downstream systeem nodig heeft. Als je SRT nodig hebt in plaats van VTT, voeg --convert-subs srt toe en zorg ervoor dat FFmpeg beschikbaar is.

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

## Een AI-dataset item maken


Voor een trainingssamenstelling, besluiten de media en tekstuitgangen samen. Een gemeenschappelijke vereiste is de beste beschikbare video en audio, samengebracht in MP4, met tijdsgeformate capties en extractie metadata onder dezelfde video ID. Een resolutie dak nuttig voor vooruitzichten is meestal de verkeerde standaard voor een bron-kwaliteitsdataset.

**Download een volledige dataset item**

```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" \
  --print after_move:filepath "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

Bash voorbeeld. FFmpeg combineert afzonderlijke stromen; --remux-video bedekt ook een gecombineerde stroom-fallback. Gebruik een exacte taaltag van --list-subs; vervang en met de taal uw dataset behoeften.

Begin met een exacte opname taal. In onze live check, en.* gekozen en, en-en en en-de; de derde track teruggekeerd 429 voordat de media downloading begon. Een opnamefout kan het item op dat stadium stoppen. Na een koude daling, terugtrek alleen de vereiste track, of split media en caption jobs als uw collectie moet houden media ingesteld in beweging.

De /best fallback toelaat een gecombineerde video/audio stroom wanneer afzonderlijke tracks niet beschikbaar zijn. Verwijder dat terugval als uw collectieovereenkomst een afzonderlijke bestvideo en bestaudio bronnen vereist. MP4 betekent niet H.264: dit recept houdt de geselecteerde bron codecs. Gebruik de streng H.264/AAC selector hierboven als uw training decoder die codecs vereist, of transcode als een aparte, geregistreerde stap.

**Verwachtte bestanden wanneer er een Engelse opname track bestaat**

```text
dataset/VIDEO_ID/
  VIDEO_ID.mp4
  VIDEO_ID.info.json
  VIDEO_ID.en.vtt
```

De caption suffix gebruikt de werkelijke taaltag. geen caption bestand wordt gemaakt wanneer de gevraagd track niet beschikbaar is; niet markeren tekstdekking compleet alleen omdat de MP4 is voltooid.

| Vereist | Samenvatting Besluit |
| --- | --- |
| De hoogste beschikbare bronkwaliteit | Gebruik bestvideo+bestaudio, houd de source codecs en controleer de gemengde stromen met ffprobe. |
| Tijdschema tekst | Houd VTT/SRT segments en taal naast de video-ID. Flattening tekst laat de tijdstip van de clips afwijken. |
| Ontbrekende bijschriften | Speel uitdrukkelijk tekenen die ontbreken.Router het bewaard audio naar uw transcriptie-stap als tekst verplicht is. |
| Capties voor veel talen | Alle aanvullende tracks voegt aanvragen toe en kan onafhankelijk van de media 429 ontmoeten. |
| Resumable media + tekstlevering | Gebruik een afzonderlijke dataset archief en een inventory met media, metadata en caption-staten. Een archiefinvoer bewijst niet dat alle vereiste pagina's bestaan. |

Gebruik geen archief dat door een eerdere media is gemaakt, alleen voor deze nieuwe beleid: gearchiveerde video's kunnen worden overgedragen voordat hun ontbrekende capties worden verzameld. Of het uitvoeren van de dataset beleid met zijn eigen archief of een afzonderlijke tag-reparatie pas voor ID's ontbrekende tekst. Speel originele capties; als uw model schoon transcript tekst nodig heeft, verzamel het in een versieerde verwerkingstap.

- [Hetzelfde dataset recept in Python](https://flashdata.dev/nl/docs/guides/yt-dlp-python-api/reference.md#dataset)
- [Handle caption en metadata 429s](https://flashdata.dev/nl/docs/guides/yt-dlp-429-too-many-requests/reference.md)

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

## Verbeter de overdracht doorvoer zonder een IP te overwinnen


aria2c kan helpen wanneer een enkele verbinding een onbetrouwbare of hoge latentie-link ondergaat. Het kan geen weigerd spelerverzoek of een gevlagde exit IP repareren. Maak eerst de native downloader werken op één bron; dan vergelijk de overdracht tijd en fouten met een klein aantal aria2 verbindingen.

**Begin met twee verbindingen per HTTP overdracht**

```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 -o "%(id)s.%(ext)s" "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

Installeer aria2 eerst. Houd DASH/HLS hier met de inheemse downloader zodat segment concurrentie uitdrukkelijk blijft.

| Controleer | Wat het beperkt |
| --- | --- |
| aria2c -x 2 | Verbindingen naar één server voor een download. |
| aria2c -s 2 | Verzoek om splitsingen voor één bestand; splitsing hangt ook af van bestandgrootte en serverondersteuning. |
| aria2c -j 1 | De concurrente items binnen die aria2 oproep, niet andere yt-dlp werknemers. |
| --concurrent-fragments 1 | Fragment downloads binnen de native DASH/HLS downloader. |
| Uw werk Queue | De totale actieve video's delen dezelfde host of proxy-uitgang IP. |

curl-cffi impersonen behoort tot yt-dlp eigen verzoeken; het instelt aria2 TLS-vingerdruk niet. Als de native downloads werken, maar aria2 krijgt 403, terug naar de native voordat u de ongerelateerde extractor-instellingen wijzigt. Houd de extract en de externe overdracht op dezelfde proxy-sessie.

In de werking van FlashData kan het verhogen van de concurrentie te agressief een werkroute onmiddellijk terugkeren 403. Als dit gebeurt, stop de andere banen, ga terug naar een werknemer en een verbinding, dan herstelt. Vergoeding niet door meer aria2 delen toe te voegen of hetzelfde ontkenbare stroom in parallel terug te trekken. Als dat IP bij lage lading wordt afgewezen, gebruik dan de 403 IP-vervangingswerkstroom.

**Conservatieve native transfer voor vergelijking**

```bash
python -m yt_dlp --js-runtimes deno --impersonate="" --no-playlist \
  --downloader native --concurrent-fragments 1 --limit-rate 2M \
  --sleep-requests 2 --sleep-interval 5 --max-sleep-interval 10 \
  -P diagnostics "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

2M is een diagnostische bandbreedte cap, niet een universele YouTube-grens. verhogen doorlopen geleidelijk pas na de route werkt.

- [aria2 verbinding en split opties](https://aria2.github.io/manual/en/html/aria2c.html)
- [403 herstelbevel](https://flashdata.dev/nl/docs/guides/yt-dlp-403-forbidden/reference.md#rate)
- [Rate controles voor metadata en capties](https://flashdata.dev/nl/docs/guides/yt-dlp-429-too-many-requests/reference.md#pacing)

<a id="collections"></a>

## Een collectie voorbereiden


Voor een klein bekende set, creëer een UTF-8 urls.txt met één url per lijn. Voor een YouTube-spelerlijst, voer eerst zijn ID's op in een manifest. Flat extraction inspecteert de playlist listing zonder een volledige extractie voor elk video te doen; het is nuttig voor scope review, maar zijn inzichten kunnen de duur, formaten en beschikbaarheid details ontbreken.

**Een YouTube-playlist manifest maken**

```bash
python -m yt_dlp --flat-playlist --print "https://www.youtube.com/watch?v=%(id)s" \
  "https://www.youtube.com/playlist?list=YOUR_PLAYLIST_ID" > urls.txt
```

Vervang YOUR_PLAYLIST_ID. Inspecteer urls.txt voordat u de media-overdracht begint. De herroeping vervangt dit manifest als u het opnieuw uitvoert.

Om een collectie te testen, selecteer een paar afleveringen met --playlist-items 1:5. De /videos-tab van een kanaal is een duidelijker startpunt voor geüpload video's dan een ambiguur kanaal homepage. Vergeet de playlist-bestelling niet als identiteit te behandelen: items kunnen worden ingezet, herbesteld of verwijderd.

| Filter | Gebruik | consequenties |
| --- | --- | --- |
| --playlist-items 1:5 | De eerste vijf inzichten in de huidige lijst. | Nuttig voor een kleine proef, niet een duurzame checkpoint. |
| --dateafter 20260101 | Houd de inzichten gedateerd op of na januari 1, 2026. | Date filtering kan nog steeds per-video extractie vereisen. |
| --match-filters "!is_live & duration <= 1800" | Verplich een niet-levende item met een bekende duur tot maximaal 30 minuten. | Inschrijvingen met onbekende duur passen niet overeen met dit strikte filter. |
| --download-archive archive.txt | Skip source ID's die al zijn opgenomen door eerdere downloads. | Werkt over veranderde titels en playlist posities. |

<a id="repeatable"></a>

## Een collectie veilig opnieuw maken


Zorg voor yt-dlp-work.conf in uw collectie map naast urls.txt. Het bepaalt de uitvoerbeleid eenmaal, geeft de collectie zijn eigen archief en beperkt de retries. Houd outputbestanden en dit archief samen: een archief op de succes van de extractor en ID, niet door het huidige bestand of locatie.

**yt-dlp-work.conf**

```text
# YouTube worker baseline
--js-runtimes deno
--impersonate=""
--concurrent-fragments 1

# Output policy
--no-playlist
-f "bv*[height<=1080]+ba/b[height<=1080]"
-P downloads
-o "%(channel_id)s/%(id)s.%(ext)s"
--write-info-json

# Resume and remember completed media
--continue
--download-archive archive.txt
--no-abort-on-error

# Bound each attempt and spread out work
--retries 5
--fragment-retries 5
--socket-timeout 30
--sleep-requests 1
--sleep-interval 5
--max-sleep-interval 10

# Append paths only after the final move
--print-to-file after_move:filepath completed-paths.txt
```

Plain tekst configuratie, één optie per lijn. stappen in dit voorbeeld zijn relatief aan de werkdirectie. Gebruik absolute stappen wanneer een schemaar elders kan beginnen.

**De collectie rijden**

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

--ignore-config verwijdert implicite user/system configuratie; een uitdrukkelijk geleverde --config-locations bestand is nog steeds geladen.

Hetzelfde bevel na een onderbreking. De voltooide ID's worden verlaten en herhaalde gedeeltelijke overdrachten blijven waar ondersteund. De ontplooiingen van de extract kunnen op de volgende ronde herzien. De standaard .part-bestanden zijn nuttig; verwijder ze niet als een routine retry stap.

> **Afzonderlijke archieven voor afzonderlijke output**
> Een enkele ID in archive.txt onderscheidt MP3, 1080p en 4K niet. Gebruik verschillende archiefbestanden voor verschillende outputbeleid. Als u een media-bestand verwijdert, maar de archief inhoudt, yt-dlp zal het nog steeds verlaten. Als u later uploaden van bestanden naar cloud opslag, opnemen u de succes van uploaden afzonderlijk van de lokale download succes.

--no-abort-on-error blijft verleden ontoegankelijke inputs, maar een run kan nog steeds uitkomen nonzero en post-verwerking fouten vereisen aandacht. Vermijd het toevoegen van --ignore-errors alleen om een groene baan te krijgen: het kan post-verwerking mislukkingen behandelen als succesvolle downloads. Bekijk de log en voltooide output's voordat u de collectie volledig verklaart.

<a id="verify"></a>

## Bekijk de afgeronde bestanden


De completed-paths.txt bestand is een nuttig startbestand. Test de werkelijke einduitgang in plaats van een tijdelijke video-only stream. ffprobe leest container en streamt metadata; een aparte decodering pass vangt problemen die alleen een leesbare header zal missen.

**Check een afgerond bestand**

```bash
ffprobe -v error -show_entries format=duration,size:stream=codec_type,codec_name,width,height -of json "downloads/CHANNEL_ID/VIDEO_ID.mp4"
```

Vervang de route met een van completed-paths.txt. Check de verwachte duur, vereiste audio/video stromen en decoder-compatible codecs.

**Volledige decode check**

```bash
ffmpeg -v error -i "downloads/CHANNEL_ID/VIDEO_ID.mp4" -f null -
```

Lees en decodeer het hele bestand zonder een nieuwe media-uitgang te creëren. controleer de uitgangsstatus en berichten; dit duurt langer dan ffprobe.

| Vinding | Wat je moet doen |
| --- | --- |
| Alleen een .part of afzonderlijke streamsbestand blijft | Controleer de transfer/merge-fout en herhaal het oorspronkelijke werk; etiketter niet de gemiddelde bestand voltooid. |
| Video speelt zonder geluid | Controleer het geselecteerde formaat en ffprobe stromen. een video-eigen formaat vereist een audio selectie en fusie. |
| MP4 zal niet open worden in uw editor | Controleer de codecs, niet alleen de uitbreiding; selecteer compatibele stromen of transcode uitdrukkelijk. |
| Archief ID maar geen lokale bestand | Controleer of het bestand moved/deleted. is, verzamel de inventaris voordat u archiefinschrijvingen wijzigt. |

<a id="schedule"></a>

## 9: Verplaats een bewezen opdracht naar een geplande baan


Voer de volledige bestelling met succes handmatig uit voordat u het schema maakt. Een schema begint meestal met een andere PATH en werkdirector. Geef het de volledige Python-pad van de virtuele omgeving, de volledige configuratiepad en een uitdrukkelijke werkdirectuur; ook maak FFmpeg en de JavaScript-werktijd beschikbaar voor dat proces.

- Gebruik een enkele werknemer voor een collection/archive. Laat de loop van gisteren niet overlappen de loop van vandaag tegen dezelfde uitgangen.
- Gebruik op Linux een timer/service of cron-input met een werkdirector en een lock zoals een flock. Houd logs buiten de media map en draai ze om.
- Op macOS, gebruik de lanceer met absolute uitvoerbare en werk-director paden.
- Op Windows Task Schema, stelt Programma in de omgeving python.exe, Argumenten in -m yt_dlp plus de configuratie en set-opties, en Start in de collectie map.
- Record start/end tijd, uitgevoerde versie, bron manifest, uitgangsstatus en completed/failed tellen. een nonzero batch uitgang impliceert niet elk item mislukte.
- Houd cookies en bestemmingskreditialen uit het gedeelde configuratie-reserve.Geef een baan alleen de credentialen die het nodig heeft.

De slaapopties in de config werken binnen één proces. Tien werknemers die dezelfde instellingen gebruiken, produceren nog steeds tien overlappende stromen van verzoeken. Het verhogen van --concurrent-fragments verandert de concurrentie van fragmenten binnen een downloads, niet het aantal video's in uw jobcoach.

<a id="maintain"></a>

## Kies de juiste foutguide


**Update deze Python-omgeving**

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

Wanneer een eerder werkbare bron breekt, update naar de laatste nachtelijk eerst, inclusief de matching extra. Voor de onafhankelijke binaire gebruik yt-dlp --update-to 's nachts; -U alleen blijft op het huidige kanaal. Voer een kleine kanarij na elke update, bouw vervolgens de werknemers opnieuw en registreer de herziening zodat de vloot niet stilzwijgend de release's mixt.

| Symptoom | Begin hier |
| --- | --- |
| `Requested format is not available` | Lijst formaten en controleer uw strikte filters voordat u de retries wijzigt. |
| `ffmpeg not found` / `ffprobe and ffmpeg not found` | Check PATH vanuit het werkelijke werknemer of schemaar account. |
| JavaScript-uitdaging / missing runtime waarschuwing | Controleer de werkingtijddetectie en het overeenkomstige EJS-pakket. |
| HTTP 403 tijdens de overdracht | Identificeer de weigerde host en stage; afzonderlijke extractie van media overdracht. |
| HTTP 429 | Stop de aangetaste IP, laat een kooldown en lagere extraction/caption verzoekfrequentie. |
| `Sign in to confirm you’re not a bot` | Stop de set en diagnoseer één bron, sessie en netwerk. |

- [403 Diagnose werkstromen](https://flashdata.dev/nl/docs/guides/yt-dlp-403-forbidden/reference.md)
- [Bot-check diagnostische werkstromen](https://flashdata.dev/nl/docs/guides/yt-dlp-sign-in-not-a-bot/reference.md)
- [429 Rate-limit herstel](https://flashdata.dev/nl/docs/guides/yt-dlp-429-too-many-requests/reference.md)
- [Dagelijkse Command Referentie](https://flashdata.dev/nl/docs/guides/yt-dlp-commands/reference.md)
- [Een Python-werkster maken](https://flashdata.dev/nl/docs/guides/yt-dlp-python-api/reference.md)

<a id="managed-downloads"></a>

## Wanneer de uitstoot behoort tot een cloudpipe


Als u de downloader wilt bezitten, geven de bovenstaande werkstromen u controle over bestanden, formaten en verwerking. Als uw applicatie een voltooide media nodig heeft die naar opslag is geleverd, biedt FlashData traceerde YouTube-download jobs, botbehandeling, proxy-routing en retries. Uw aanvraag stuurt de bron- en uitgangsinstellingen, behoudt vervolgens het werk-ID en leveringsprekend.

- [Vergelijk de twee operationele modellen](https://flashdata.dev/nl/docs/guides/flashdata-vs-yt-dlp/reference.md)
- [YouTube-video’s in bulk downloaden](https://flashdata.dev/nl/products/youtube-download#bulk-downloads)
- [Probeer de download demo](https://flashdata.dev/nl/products/youtube-download#playground)
- [Download API verwijzing](https://flashdata.dev/nl/docs/sources/youtube_download/reference.md)

<a id="references"></a>

## Referentiematerialen


De upstream optie verwijzing is de bron van waarheid voor uw geïnstalleerde versie. Gebruik deze secties bij het wijzigen van een verzamelbeleid of bijwerken van een werknemersbeeld.

- [Format selectie en sorteren](https://github.com/yt-dlp/yt-dlp#format-selection)
- [Configuratie Loading](https://github.com/yt-dlp/yt-dlp#configuration)
- [Uitgangs templates](https://github.com/yt-dlp/yt-dlp#output-template)
- [Veelgestelde vragen over yt-dlp](https://github.com/yt-dlp/yt-dlp/wiki/FAQ)
