# Polecenia yt-dlp do codziennej pracy

Skopiuj polecenia do pobierania wideo, dźwięku i napisów, tworzenia zbiorów danych i wznawiania kolekcji.

Odniesienie kanoniczne: https://flashdata.dev/pl/docs/guides/yt-dlp-commands
Przegląd: 2026-11-13 przez FlashData

- [Wideo i dźwięk](https://flashdata.dev/pl/docs/guides/yt-dlp-commands/reference.md#video) — Jakość, kodek i MP3
- [Kapsułki i metadata](https://flashdata.dev/pl/docs/guides/yt-dlp-commands/reference.md#subtitles) — Szydło i strukturowany wydajność
- [Kolekcje i odzyskiwanie](https://flashdata.dev/pl/docs/guides/yt-dlp-commands/reference.md#archives) — Lista, archiwum i konfig
- [Diagnoza niepowodzenia](https://flashdata.dev/pl/docs/guides/yt-dlp-commands/reference.md#diagnostics) — Logy i weryfikacja wyjścia

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

## Konwencje ustawienia i polecenia


**Zacznij od aktualnych nocy i kompletnych uzależnień**

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

Receptura do pobrania używa Deno i --impersonate="" jako podstawy. Ten ostatni wymaga curl-cffi i pozwala mu wybrać dostępny odcisk palca przeglądarki. Linux/macOS polecenie używa syntax Bash; dla pracownika zaplanowanego, również uczynić te zależności dostępne w tym środowisku serwisowym.

Te przykłady terminali wykorzystują instalację Python yt-dlp. Użyj Pythona w środowisku wirtualnym lub zastąp pythona -m yt_dlp za pomocą dowodu yt-dlp. Najpierw używaj systemu Linux, z alternatywami dla systemu macOS i systemu Windows w przewodniku ustawień. Instaluj FFmpeg/ffprobe do połączenia i Deno do rozwiązania wyzwania YouTube. Zastąpić przykładowy adres URL źródłem.

| Konwencja | Dlaczego to ważne |
| --- | --- |
| Cytaty URL i szablonów | W przeciwnym razie szale interpretuje takie postacie jak &, przestrzenia i parantezy. |
| Utrzymuj %(ext)s w filenamenach | Wybrane media i post-przetwarzanie określają rozszerzenie. |
| Użyj --no-playlist dla zegara URL | Wideo połączone z listy odtwarzania nie powinno nieoczekiwanie rozszerzać pracy. |
| Sprawdź Twoją konfigurację | Przykłady mogą dziedziczyć globalny konfigurator. użyj --ignore-config do izolowanego testu. |
| Windows .bat: podwójne znaky procentowe szablonu | Użyj %%(id)s w pliku zbioru, ale %(id)s w interaktywnych plikach PowerShell i normalnych plików konfiguracji. |

- [Instalacja narzędzi](https://flashdata.dev/pl/docs/guides/how-to-use-yt-dlp/reference.md#install)
- [Tworzenie ponownego użycia konfiguracji kolekcji](https://flashdata.dev/pl/docs/guides/how-to-use-yt-dlp/reference.md#repeatable)

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

## Jakość wideo i MP4


**Baseline:** najnowsze nocne, Deno i FFmpeg, z `--impersonate=""`. przepisy używają Bash; zastąpić adres URL próbki ze źródłem.

**Pobierz jeden film z wybranym standardem**

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

Wybierz dostępne strumienia za pomocą standardów yt-dlp. pojemnik niekoniecznie MP4.

**Lista dostępnych formatów**

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

Kodeky i rzędy audio-only/video-only. identyfikatory formatów liczbowych nie są przenośnymi politykami wyjścia.

**Najlepiej 1080p**

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

Preferencja: jeśli nie ma formatu w lub poniżej celu, sortowanie może wybrać jeden powyżej.

**Wymaga maksymalnego 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"
```

Filtr: nie działa, gdy żaden format nie odpowiada. utrzymuje wybór kodek źródłowy.

**H.264 wideo i AAC audio w 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"
```

Strict codec selection. wymaga dopasowania formatów i FFmpeg do pojedynczego łączania.

> **Kontainer nie jest kodekem**
> --merge-output-format wybiera mieszany pojemnik. --remux-video pakuje kompatybilne strumienie. Nie przekształca się AV1 w H.264. Kiedy decoder wymaga określonego kodek, wybierz ten kodek lub zaplanować oddzielny transkod.

- [Rozumieć selektory i falbacki](https://flashdata.dev/pl/docs/guides/how-to-use-yt-dlp/reference.md#formats)

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

## Zestaw danych AI: MP4 + kapcje + metadata


**Najlepsze filmy + audio, MP4, captions i metadata**

```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 łączy strumienia źródłowe. MP4 utrzymuje kodek źródłowy; sprawdź kompatybilność dekodera i oddzielnie pokrywa tagi.

- [Polityka wyjścia dataset i brakujące kapsułki](https://flashdata.dev/pl/docs/guides/how-to-use-yt-dlp/reference.md#dataset)
- [Opcje zestawu danych Python](https://flashdata.dev/pl/docs/guides/yt-dlp-python-api/reference.md#dataset)

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

## Pobierz zewnętrzny: aria2c


**Dwie połączenia, 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"
```

Wymaga programu aria2c. Najpierw sprawdź pobieranie jednego filmu. Dopiero potem zwiększ liczbę połączeń i zmniejsz ją od razu, gdy wystąpi błąd 403.

aria2 ma własną implementację sieciową. yt-dlp impersonacja curl-cffi nie konfiguruje odcisków palców aria2. Jeśli tylko zewnętrzny pobieracz nie działa, użyj --downloader native i porównaj tę samą drogę źródłową i proxy.

- [Kontrola połączeń i diagnoza przejścia](https://flashdata.dev/pl/docs/guides/how-to-use-yt-dlp/reference.md#aria2)

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

## Dźwięk i MP3


**Zapisz oryginalny strumień audio**

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

Nie MP3 konwersja. przydatne, gdy twój transcription lub odtwarzacz przewód akceptuje oryginalny kodek.

**Konwersja na MP3 przy bitrate docelowej**

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

Używa FFmpeg. 192K kontroluje kodowanie wyjścia; nie przywraca jakości źródła.

**Prefer M4A bez transkody**

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

Nie działa, jeśli nie ma dostępnego M4A tylko formatu audio. Dodaj /ba tylko wtedy, gdy aplikacja akceptuje inne pojemniki źródłowe.

**MP3 z wbudowanymi metadany i pokryciem**

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

Krok metadata/thumbnail to dodatkowe post-przetwarzanie. sprawdź ostateczne pliki, a nie tylko transferowe.

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

## Kaptuły i podtytuły


**Lista dostępnych ścieżek**

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

Przeczytaj etykiety językowe oferowane przez ten źródło przed wyborem --sub-langs.

**Pobierz dostarczone tylko angielskie podtytuły**

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

Nie spadnie z powrotem do automatycznych odczytów i nie pobiera mediów.

**Pozwalają również automatyczne angielskie czapki**

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

* może dopasować się do wielu wariantów angielskich. to odzyskuje dostępne ścieżki; nie prowadzi rozpoznawania mowy.

**Konwertuj wybrane ścieżki na 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"
```

Wymagane jest FFmpeg.Wymagane jest wybranie innego kodu językowego z --list-subs.

**Włącz podtytuły dostarczone w 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"
```

Pobiera media, zapytania dostarczone angielskie podtytuły i wprowadza dostępny ścieżkę. sprawdź, czy ta ścieżka istnieje najpierw.

Zapytanie o wszystkie języki napisów może znacznie zwiększyć liczbę zapytania i plików. Zachowaj wymagane języki wyraźnie do rutynowej pracy. Utrzymuj identyfikator źródłowy i język w zapasie zbiorników danych, aby transkrypcje nie były oddzielone od mediów opisanych przez nich.

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

## Metadaty i drogi wyjściowe


**Wpisz metadane jednego wideo jako JSON**

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

Simuluje pobieranie pod standardem, ale wykonuje ekstrakcję. przekierowanie zastępuje video.json.

**Napisz pełny metadata bez mediów**

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

Tworzy .info.json strona. to dane z ekspresora operacyjnego; pola projektu przed publikacją.

**Pobierz tylko miniaturę**

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

Oszczędza dostępny miniaturę w swoim formacie źródłowym. --convert-thumbnails jpg dodaje krok konwersji, gdy JPEG jest wymagany.

**Drukowanie ostatecznego ścieżki medialnej po przetwarzaniu**

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

W przeciwieństwie do standardowej fazy --print, druk after_move czeka na prawdziwe pobieranie i jego ostateczne działanie.

**Wprowadź zakończone ścieżki do manifestu**

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

Dodaj, więc rezygnacje mogą wytwarzać powtarzające się wpisy. traktuj je jako rekord zakończenia, a nie wyduplikowany zapas.

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

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

## Czasowe rzędy i rozdziały


**Pobierz sekundy 5 przez 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"
```

Wymagane FFmpeg. granica klipu może być dostosowana do dostępnych klawiatur; sprawdź wyjście, gdy dokładnie czas czasu.

**Re-encodowanie wokół żądanych cięć**

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

Dodaj prace ponownego kodowania, aby poprawić cięcie na żądanych granicach. Sprawdź wynikający czas trwania i audio/video alignment.

**Rozdzielamy rozdzielone wideo na pliki**

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

Wykorzystaj wideo z metadanymi rozdziału. wyjścia rozdziału są oddzielone od oryginalnego pełnego pobrania; przestrzeń na dysku budżetowym dla obu.

Wprowadzenie archiwum na poziomie źródłowym nie koduje wybranych start/end czasów, więc jeden udostępniony archiwum może usunąć późniejszy klip, który zamierzasz utworzyć.

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

## Lista wyświetleń i listy URL


**Pobierz znany listę URL**

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

Tworzenie pliku UTF-8 z jednym adresem URL na linie. --no-playlist ma zastosowanie do przeglądania adresów URL, które obejmują kontekst listy odtwarzania.

**Sprawdź listę odtwarzania YouTube bez pełnego ekstrakcji wideo**

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

Jeden JSON obiekt na wpis. płaskie wpisy mogą pominąć szczegóły długości i formatu.

**Pobierz pierwsze pięć wpisów z listy odtwarzania**

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

Indeksy Playlist są wyświetlane przez porządek, a nie tożsamość.

**Ograniczanie kwalifikowalnych filmów według daty i długości**

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

Wymaga nie-live elementów o znanej długości do 30 minut, datowanych w styczniu 1, 2026. Filtrowanie może nadal wymagać pro-video zapytania.

**Zatrzymaj się po 10 nowych pobieraniach**

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

Limit kontroluje nowo pobrane pliki, nie ile listing/extraction żądań występuje.

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

## Archiwum i odzyskiwanie


**Odtworzyć kolekcję z tą samą polityką**

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

Dokonane identyfikatory są przeniesione. częściowe pobrania ponownie się odtwarzają tam, gdzie są obsługiwane. Użyj tych samych archiwów i wyjściowych ścieżek, jak pierwotny praca.

**Zatrzymaj jednego pracownika i objęcie jego emerytur**

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

Dodaj limit pracownika na poziomie koła, gdy kilka procesów dzieli się trasą lub sesją.

**Wielkość przenoszenia bandwidth**

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

Kontrola prędkości przesyłania mediów. nie reguluje liczby żądań na ekstrakcję.

**Zmniejszenie konkurencji fragmentów wrodzonych**

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

Zacznij od jednego fragmentu w czasie, gdy bada 403s. Inne procesy pracowników nadal dodawać własne równoległe zapytania.

> **Archiwum ma konkretną pracę**
> Zarejestruje extractor/video identyfikatorów po udanych pobraniach. Nie jest to katalog ustawień wyjściowych ani sprawdzenie, czy plik nadal istnieje. Utrzymuj oddzielne archiwum dla polityki audio, wideo i klipów i nie oznacz nieudane prace zakończone z --force-write-archive.

- [Ponowne zastosowanie procedury konfigurowania i odzyskiwania](https://flashdata.dev/pl/docs/guides/how-to-use-yt-dlp/reference.md#repeatable)

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

## Konfiguracja i filename


**Wystarczy pobrać wyraźną kolekcję konfig**

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

Wyraźnie nazwany konfiguracja jest ładowana nawet z --ignore-config. Użyj pełnych ścieżek do zaplanowanych prac.

**Nazwy z stabilną tożsamością**

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

Tytuł jest w tym szablonie zniekształcony w 150 bajtach. identyfikatorzy odróżniają podwójne lub zmieniające się tytuły.

**Wykorzystuj oddzielny adresat tymczasowy**

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

Zadbaj o to, aby obie adresary miały wystarczającą ilość miejsca; różne systemy plików mogą wymagać kopii.

W przypadku długotrwałych kolekcji decyduj, czy nazwy filenamów powinny być czytelne przez ludzi lub stałe klucze aplikacyjne. Nazwy kanałów i tytuły mogą się zmieniać. Channel/video ID są lepszymi kluczami do deduplikacji, z polami opisowymi przechowywanymi w metadanych.

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

## Cookies i drogi runtime


**Korzystaj z profilu przeglądarki, który ma dostęp**

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

Zastąpić profil 1 z rzeczywistym profilu przeglądarki. użyj plików cookie sesji tylko wtedy, gdy jest to konieczne, i zachować je prywatne.

**Przeczytaj istniejący plik prywatnych plików cookie**

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

Wymaga format pliku cookie Netscape. eksportowanie JSON nie jest równoważne.

**Wykorzystuj wykonawczy Deno poza pracownikiem PATH**

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

Zastąpić ścieżkę z Deno binary zainstalowane dla twojego pracownika.

- [Przegląd plików cookie, wygaśnięcie i kontrolowanie botów](https://flashdata.dev/pl/docs/guides/yt-dlp-sign-in-not-a-bot/reference.md)

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

## Diagnoza i weryfikacja


**Sprawdź czystą ekstrakcję**

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

Usuwa implikowane konfiguracje i nie przechowuje żadnych mediów. nadal robi żądania ekstrakcji i nie udowadnia, że transfer będzie skuteczny.

**Zatrzymaj prywatny diagnostyczny 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
```

Prześlij zastępuje wartość log. Redact cookie/header wartości, zaufania proxy i podpisane adresy URL przed udostępnianiem.

**Sprawdź przepływ i czas trwania**

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

Użyj ostatniej drogi, po przetwarzaniu. ffprobe czyta nagłówki; nie dekoduje każdego ramy.

**Odkryj zapisany plik bez tworzenia wyjścia**

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

Więcej informacji na temat tego, co czyta cały plik. sprawdź status wyjścia i wiadomości.

**Aktualizuj pakiet Python i sprawdź jego wersję**

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

- [Diagnoza 403 według etapów](https://flashdata.dev/pl/docs/guides/yt-dlp-403-forbidden/reference.md)
- [429: metadata i granice zapytania](https://flashdata.dev/pl/docs/guides/yt-dlp-429-too-many-requests/reference.md)
- [Diagnoza odpowiedzi bot-check](https://flashdata.dev/pl/docs/guides/yt-dlp-sign-in-not-a-bot/reference.md)
- [Pełna referencja opcji upstream](https://github.com/yt-dlp/yt-dlp#usage-and-options)
