# रोज़ाना काम के लिए yt-dlp कमांड

वीडियो, ऑडियो, कैप्शन, डेटासेट और संग्रह को फिर से शुरू करने के लिए कमांड कॉपी करें।

कैनोनिकल संदर्भ: https://flashdata.dev/hi/docs/guides/yt-dlp-commands
समीक्षित: 2026-11-13 द्वारा FlashData

- [वीडियो और ऑडियो](https://flashdata.dev/hi/docs/guides/yt-dlp-commands/reference.md#video) — गुणवत्ता, कोडेक और MP3
- [कब्जे और मेटाडेटा](https://flashdata.dev/hi/docs/guides/yt-dlp-commands/reference.md#subtitles) — सिडकेयर और संरचित उत्पादन
- [संग्रह और पुनर्प्राप्ति](https://flashdata.dev/hi/docs/guides/yt-dlp-commands/reference.md#archives) — सूची, संग्रह और config
- [एक असफलता का निदान](https://flashdata.dev/hi/docs/guides/yt-dlp-commands/reference.md#diagnostics) — रिकॉर्ड और आउटपुट की जांच

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

## स्थापना और कमांड सम्मेलन


**वर्तमान रात और पूर्ण निर्भरताओं से शुरू करें**

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

डाउनलोड व्यंजनों के आधार पर Deno और --impersonate="" का उपयोग करें। यह curl-cffi की आवश्यकता होती है और इसे उपलब्ध ब्राउज़र उंगलियों के निशान का चयन करने की अनुमति देता है। Linux/macOS कमांड बश सिंटाक्स का उपयोग करते हैं; एक योजनाबद्ध कार्यकर्ता के लिए, भी इन निर्भरताओं को उस सेवा वातावरण में उपलब्ध कराएं।

इन टर्मिनल उदाहरणों में Python yt-dlp की स्थापना का उपयोग किया जाता है। अपने वर्चुअल-पर्यावरण Python का उपयोग करें, या Python -m yt_dlp को एकल yt-dlp कमांड के साथ बदल दें। सबसे पहले, सेटअप गाइड में macOS और Windows विकल्पों के साथ लिनक्स का उपयोग करें। संयुक्त करने के लिए FFmpeg/ffprobe स्थापित करें और YouTube चुनौती समाधान के लिए Deno। उदाहरण URL को अपने स्रोत के साथ बदल दें।

| सम्मेलन | क्यों मायने रखता है |
| --- | --- |
| URL और टेम्पलेट्स का चयन करें | शेल अन्यथा &, स्थानों और पैरानेजेशन जैसे पात्रों को व्याख्या करता है। |
| फ़ाइल नामों में %(ext)s रखें | चुने हुए मीडिया और पोस्ट-प्रसंस्करण विस्तार को निर्धारित करता है। |
| --no-playlist का उपयोग एक घड़ी URL के लिए करें | एक प्लेलिस्ट से लिंक किए गए वीडियो को अप्रत्याशित रूप से अपना काम विस्तार नहीं करना चाहिए। |
| अपनी संरक्षित कॉन्फ़िगरेशन की जांच करें | उदाहरण एक वैश्विक कॉन्फ़िगरेशन का विरासत हो सकता है. एक अलग परीक्षण के लिए --ignore-config का उपयोग करें. |
| Windows .bat: डबल टेम्पलेट प्रतिशत संकेत | एक बैच फ़ाइल में %%(id) का उपयोग करें, लेकिन इंटरैक्टिव PowerShell और सामान्य कॉन्फ़िगर फ़ाइलों में %(id) का उपयोग करें। |

- [उपकरणों को स्थापित करें](https://flashdata.dev/hi/docs/guides/how-to-use-yt-dlp/reference.md#install)
- [एक पुन: उपयोग योग्य संग्रह कॉन्फ़िगरेशन बनाएं](https://flashdata.dev/hi/docs/guides/how-to-use-yt-dlp/reference.md#repeatable)

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

## वीडियो गुणवत्ता और MP4


**बेसलाइन:** नवीनतम रात में, डेनो और FFmpeg, के साथ `--impersonate=""`. व्यंजनों का उपयोग बश; अपने स्रोत के साथ नमूना URL को बदल दें.

**डिफ़ॉल्ट चयन के साथ एक वीडियो डाउनलोड करें**

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

yt-dlp के मानक का उपयोग करके उपलब्ध प्रवाह का चयन करें. कंटेनर जरूरी नहीं है MP4।

**उपलब्ध फ़ॉर्मेट्स की सूची**

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

निरीक्षण कोडेक और audio-only/video-only पंक्तियां. संख्यात्मक प्रारूप आईडी पोर्टेबल आउटपुट नीति नहीं हैं.

**1080p के बारे में**

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

एक प्राथमिकता: यदि लक्ष्य के ऊपर या नीचे कोई प्रारूप उपलब्ध नहीं है, तो वर्गीकरण उस पर एक चुन सकता है।

**अधिकतम 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"
```

फ़िल्टर: जब कोई प्रारूप नहीं मिलता है तो विफल होता है. स्रोत कोडेक विकल्प बनाए रखता है.

**H.264 वीडियो और AAC ऑडियो में 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"
```

सख्त कोडेक चयन. फिट करने के लिए प्रारूपों और FFmpeg को अलग-अलग प्रवाह के लिए मिलाने की आवश्यकता होती है.

> **कंटेनर कोड नहीं है**
> --merge-output-format मिश्रित कंटेनर का चयन करता है. --remux-video संगत प्रवाह को फिर से पैक करता है. और फिर भी, यह भी नहीं है कि H.264 में AV1 को बदल दिया जाए। जब एक डिकोडर को एक विशिष्ट कोडेक की आवश्यकता होती है, तो उस कोडेक को चुनें या एक अलग ट्रांसकोड योजना करें।

- [Selectors और Fallbacks को समझें](https://flashdata.dev/hi/docs/guides/how-to-use-yt-dlp/reference.md#formats)

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

## एआई डेटासेट: MP4 + कप्शन + मेटाडेटा


**सर्वश्रेष्ठ वीडियो + ऑडियो, MP4, कब्जे और मेटाडेटा**

```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 स्रोत प्रवाहों को जोड़ता है. MP4 स्रोत कोडेक रखता है; डिकोडर संगतता और टैप कवरेज को अलग से जांचें।

- [डेटासेट आउटपुट नीति और अनुपस्थित कैप्शन](https://flashdata.dev/hi/docs/guides/how-to-use-yt-dlp/reference.md#dataset)
- [Python डेटा सेट विकल्प](https://flashdata.dev/hi/docs/guides/yt-dlp-python-api/reference.md#dataset)

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

## बाहरी डाउनलोडर: aria2c


**दो कनेक्शन, मूल 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"
```

इसके लिए aria2c प्रोग्राम चाहिए। एक वीडियो का डाउनलोड सफल होने के बाद ही कनेक्शन बढ़ाएँ और 403 त्रुटि आने पर उन्हें तुरंत कम करें।

aria2 के पास अपना खुद का नेटवर्क कार्यान्वयन है. yt-dlp के curl-cffi के प्रतिबिंब aria2 के उंगलियों के निशान को समायोजित नहीं करते हैं. यदि केवल बाहरी डाउनलोडर विफल हो जाता है, तो --downloader मूल का उपयोग करें और एक ही स्रोत और प्रॉक्सी रास्ते की तुलना करें।

- [कनेक्शन नियंत्रण और पारगमन निदान](https://flashdata.dev/hi/docs/guides/how-to-use-yt-dlp/reference.md#aria2)

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

## ध्वनि और MP3


**मूल ऑडियो स्ट्रीम को बचाएं**

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

कोई MP3 रूपांतरण. उपयोगी जब आपका ट्रांसक्रिप्शन या प्लेबैक पाइपलाइन मूल कोडेक को स्वीकार करता है.

**MP3 में एक लक्ष्य बिटराइट पर परिवर्तित करें**

```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 उत्पादन कोडिंग को नियंत्रित करता है; यह स्रोत गुणवत्ता को पुनर्स्थापित नहीं करता है.

**M4A बिना ट्रांसकोडिंग के**

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

असफल होता है अगर कोई M4A ऑडियो-केवल प्रारूप उपलब्ध नहीं है. Add /ba only if your application accepts other source containers.

**MP3 में शामिल मेटाडेटा और कवर के साथ**

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

metadata/thumbnail चरण अतिरिक्त पोस्ट-प्रसंस्करण हैं. अंतिम फ़ाइल की जांच करें, न कि केवल स्थानांतरण कोच।

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

## कब्जे और उपनाम


**उपलब्ध ट्रैक सूची**

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

इस स्रोत द्वारा प्रदान की गई भाषा टैग को पढ़ने से पहले --sub-langs का चयन करें।

**डाउनलोड किए गए अंग्रेजी उपनाम केवल**

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

यह स्वचालित कब्जे में वापस नहीं आता है और मीडिया को डाउनलोड नहीं करता है।

**स्वचालित अंग्रेजी कैप्शन भी अनुमति देता है**

```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.* कई अंग्रेजी संस्करणों के अनुरूप हो सकता है. यह उपलब्ध ट्रैक प्राप्त करता है; यह भाषण पहचान नहीं चलाता है.

**चयनित ट्रैक को 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"
```

FFmpeg की आवश्यकता होती है. जरूरत पड़ने पर --list-subs से एक और भाषा कोड चुनें.

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

मीडिया डाउनलोड, अनुरोधों को अंग्रेजी उपशीर्षक प्रदान करते हैं और उपलब्ध ट्रैक को शामिल करते हैं. पहले जांचें कि क्या यह ट्रैक मौजूद है.

सभी प्रतिलिपि भाषाओं की मांग करने से अनुरोधों और फ़ाइलों की संख्या में काफी वृद्धि हो सकती है। नियमित कार्य के लिए अनुरोधित भाषाओं को स्पष्ट रखें। अपने डेटासेट आंकड़े में स्रोत आईडी और भाषा को संरक्षित करें ताकि ट्रांसक्रिप्ट उन्हें वर्णित मीडिया से अलग न किया जा सके।

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

## मेटाडेटा और आउटपुट मार्ग


**एक वीडियो के मेटाडेटा को JSON के रूप में प्रिंट करें**

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

डाउनलोड को डिफ़ॉल्ट रूप से सिमुलेशन करता है, लेकिन निष्कर्षण करता है. रीडिट video.json को बदल देता है.

**मीडिया के बिना एक पूर्ण मेटाडेटा साइडर लिखें**

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

यह एक .info.json साइड इक्सेर बनाता है. यह ऑपरेटिंग एक्सट्रैक्टर डेटा है; प्रोजेक्ट फ़ील्ड इसे सार्वजनिक रूप से प्रदर्शित करने से पहले।

**केवल छोटे-छोटे टुकड़े डाउनलोड करें**

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

यह स्रोत प्रारूप में उपलब्ध छोटे को बचाता है. --convert-thumbnails jpg JPEG की आवश्यकता होने पर एक रूपांतरण चरण जोड़ता है.

**प्रसंस्करण के बाद अंतिम मीडिया मार्ग प्रिंट करें**

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

एक डिफ़ॉल्ट चरण --print के विपरीत, एक after_move प्रिंट एक वास्तविक डाउनलोड और इसके अंतिम कदम के लिए इंतजार करता है।

**एक प्रदर्शन के लिए पूर्ण मार्गों को जोड़ें**

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

एप्जेड, इसलिए रिट्री बार-बार इनपुट का उत्पादन कर सकते हैं. इसे एक पूर्ण लॉग के रूप में व्यवहार करें, एक डिडपलिक्टेड आंकड़ा नहीं।

- [Python मेटाडेटा प्रोजेक्शन](https://flashdata.dev/hi/docs/guides/yt-dlp-python-api/reference.md#metadata)

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

## समय और अध्याय


**10 के माध्यम से 5 सेकंड डाउनलोड करें**

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

FFmpeg की आवश्यकता होती है. एक क्लिप सीमा उपलब्ध कुंजी फ्रेम के साथ संरेखित हो सकती है; जब सटीक टाइमिंग बात होती है तो आउटपुट की जांच करें.

**अनुरोध किए गए कटौती के आसपास पुन: कोड करें**

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

अनुरोध की सीमाओं पर कटौती में सुधार करने के लिए पुन: कोडिंग कार्य जोड़ें. परिणामस्वरूप अवधि और audio/video समायोजन की जांच करें.

**फ़ाइलों में एक अध्याय वीडियो विभाजित करें**

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

अध्याय के मेटाडेटा के साथ एक वीडियो का उपयोग करें. अध्याय आउटपुट मूल पूर्ण डाउनलोड से अलग हैं; दोनों के लिए बजट डिस्क स्थान।

क्लिप्स और पूर्ण वीडियो के लिए एक अलग आउटपुट नीति या संग्रह का उपयोग करें. स्रोत स्तर के संग्रह इनपुट को चुने गए start/end समय को एन्कोडिंग नहीं करता है, इसलिए एक साझा संग्रह एक बाद के क्लिप को खत्म कर सकता है जिसे आप बनाना चाहते हैं.

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

## प्लेलिस्ट और URL सूची


**एक ज्ञात URL सूची डाउनलोड करें**

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

एक यूटीएफ-8 फ़ाइल बनाएं जिसमें एक बार URL को एक पंक्ति में देखा जाता है. --no-playlist उन URL को देखने के लिए लागू होता है जिनमें प्लेलिस्ट संदर्भ शामिल है.

**पूर्ण वीडियो निकालने के बिना YouTube प्लेलिस्ट की जांच करें**

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

हर एंट्री के लिए एक JSON ऑब्जेक्ट। फ़्लैट एंट्री में अवधि और फ़ॉर्मैट की जानकारी छूट सकती है।

**डाउनलोड करें पहले पांच प्लेलिस्ट इनपुट**

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

प्लेलिस्ट सूचियों को आदेश दिखाया जाता है, पहचान नहीं. फ़ाइल नाम में वीडियो आईडी रखें.

**तारीख और अवधि के आधार पर योग्य वीडियो सीमित करें**

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

यह अप्रत्यक्ष वस्तुओं की आवश्यकता है, जिनकी ज्ञात अवधि 30 मिनट तक है, जो जनवरी 1, 2026 के बाद या बाद में तारीख है।

**10 नए डाउनलोड के बाद बंद**

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

सीमा नए डाउनलोड किए गए फ़ाइलों को नियंत्रित करती है, न कि कितने listing/extraction अनुरोध होते हैं. अगले दौर के लिए संग्रह को बनाए रखें.

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

## Archive and पुनर्प्राप्ति


**एक ही नीति के साथ एक संग्रह को पुनर्स्थापित करें**

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

पूरा आईडी खो दिए जाते हैं. भाग डाउनलोड जहां समर्थित है फिर से आते हैं. मूल नौकरी के समान संग्रह और आउटपुट मार्ग का उपयोग करें.

**एक कार्यकर्ता को शांति दें और अपने सेवानिवृत्ति को बाध्य करें**

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

यह प्रक्रिया-प्रति-सेटिंग्स हैं. जब कई प्रक्रियाओं को एक मार्ग या सत्र साझा किया जाता है तो क्यूई स्तर के श्रमिकों की सीमा जोड़ें.

**Cap Transfer बैंडविड्थ**

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

मीडिया ट्रांसफर दर नियंत्रित करता है. यह निकालने के अनुरोधों की संख्या को विनियमित नहीं करता है.

**घरेलू फ्रेमवर्क प्रतिस्पर्धा को कम करें**

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

एक बार में एक टुकड़े के साथ शुरू करें जब जांच 403s. अन्य कार्यकर्ता प्रक्रियाएं अभी भी अपने स्वयं के समकक्ष अनुरोधों को जोड़ती हैं.

> **संग्रह में एक विशेष कार्य है**
> यह सफलतापूर्वक डाउनलोड के बाद extractor/video आईडी रिकॉर्ड करता है। यह आउटपुट सेटिंग्स का एक कैटलॉग या एक चेक नहीं है कि एक फ़ाइल अभी भी मौजूद है। ऑडियो, वीडियो और क्लिप नीतियों के लिए अलग-अलग संग्रह रखें, और --force-write-archive के साथ असफल कार्य पूरा न करें।

- [पुन: उपयोग करने योग्य कॉन्फ़िगरेशन और पुनर्प्राप्ति प्रक्रिया](https://flashdata.dev/hi/docs/guides/how-to-use-yt-dlp/reference.md#repeatable)

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

## फ़ाइल नाम और फ़ाइल नाम


**केवल अपनी स्पष्ट संग्रह कॉन्फ़िग लोड करें**

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

स्पष्ट रूप से नामित कॉन्फ़िग भी --ignore-config के साथ लोड किया जाता है. योजनाबद्ध नौकरियों के लिए पूर्ण मार्गों का उपयोग करें.

**स्थिर पहचान के साथ पढ़ने योग्य नाम**

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

शीर्षक इस टेम्पलेट में 150 बाइट्स में ट्रिगर किया जाता है. आईडी दोहराए गए या बदलते शीर्षकों को अलग करते हैं.

**एक अलग अस्थायी निर्देशिका का उपयोग करें**

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

यह सुनिश्चित करें कि दोनों निर्देशिकाओं में पर्याप्त स्थान है; अलग-अलग फ़ाइल सिस्टम को एक प्रतिलिपि की आवश्यकता हो सकती है।

लंबे समय तक रहने वाले संग्रहों के लिए, यह तय करें कि फ़ाइल नाम मानव-पढ़ने योग्य या स्थिर अनुप्रयोग कुंजी होना चाहिए। चैनल के नाम और शीर्षक बदल सकते हैं। Channel/video आईडी डिडाप्लिकेशन के लिए बेहतर कुंजी हैं, जिसमें विवरण फ़ील्ड मेटाडेटा में रखा गया है।

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

## कुकीज़ और चलने के समय के मार्ग


**ब्राउज़र प्रोफ़ाइल का उपयोग करें जिसके पास पहुंच है**

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

प्रोफ़ाइल 1 को अपने वास्तविक ब्राउज़र प्रोफ़ाइल के साथ प्रतिस्थापित करें. केवल जब आवश्यक हो तो सत्र कुकीज़ का उपयोग करें, और उन्हें गोपनीय रखें.

**एक मौजूदा निजी कुकी फ़ाइल पढ़ें**

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

Netscape कुकी फ़ाइल प्रारूप की आवश्यकता होती है. एक JSON निर्यात बराबर नहीं है.

**एक डेनो को कार्यकर्ता के पैच के बाहर निष्पादित करें**

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

अपने कार्यकर्ता के लिए स्थापित दनो बाइनरी के साथ मार्ग को बदल दें।

- [कुकीज़ लोड, समाप्त और बॉट चेक](https://flashdata.dev/hi/docs/guides/yt-dlp-sign-in-not-a-bot/reference.md)

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

## निदान और जांच


**एक साफ निष्कर्षण की जांच करें**

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

यह अंतर्निहित कॉन्फ़िगर को हटा देता है और कोई मीडिया नहीं बचाता है. यह अभी भी निकालने के अनुरोधों को बनाता है और एक स्थानांतरण सफल होने का सबूत नहीं देता है.

**एक निजी डायबिटीज रिकॉर्ड लेना**

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

रीडिट को बदलता है. cookie/header मूल्यों, प्रॉक्सी क्रेडिट और साझा करने से पहले हस्ताक्षर किए गए URL को संपादित करें.

**बचाए गए प्रवाह और अवधि की जांच करें**

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

अंतिम मार्ग का उपयोग करें, प्रसंस्करण के बाद. ffprobe शीर्षक पढ़ता है; यह हर फ्रेम को अनगिनत नहीं करता है।

**एक आउटपुट बनाने के बिना बचाए गए फ़ाइल को अनगिनत करें**

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

एक गहरी जांच जो पूरे फ़ाइल को पढ़ती है. बाहर निकलने की स्थिति और संदेशों की जांच करें.

**Python पैकेज को अपडेट करें और इसके संस्करण की जांच करें**

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

- [चरण-दर-चरण निदान 403](https://flashdata.dev/hi/docs/guides/yt-dlp-403-forbidden/reference.md)
- [429: मेटाडेटा और नोट अनुरोध सीमा](https://flashdata.dev/hi/docs/guides/yt-dlp-429-too-many-requests/reference.md)
- [एक बॉट-चेक प्रतिक्रिया का पता लगाएं](https://flashdata.dev/hi/docs/guides/yt-dlp-sign-in-not-a-bot/reference.md)
- [Upstream Option संदर्भ](https://github.com/yt-dlp/yt-dlp#usage-and-options)
