# yt-dlp की Python API

डाउनलोड, मेटाडेटा, AI डेटासेट और दोबारा शुरू किए जा सकने वाले कामों के लिए चलने योग्य Python उदाहरण।

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

- [Python से शुरू करें](https://flashdata.dev/hi/docs/guides/yt-dlp-python-api/reference.md#first-call) — एक कॉल करें और एक कॉल करें
- [अंतिम फ़ाइल खोजें](https://flashdata.dev/hi/docs/guides/yt-dlp-python-api/reference.md#completion) — स्थानांतरण और प्रसंस्करण के बाद
- [कार्यकर्ता को मिलता है](https://flashdata.dev/hi/docs/guides/yt-dlp-python-api/reference.md#worker) — डाउनलोड करें .py
- [एक संग्रह का संचालन](https://flashdata.dev/hi/docs/guides/yt-dlp-python-api/reference.md#batch) — स्रोत के अनुसार परिणाम और वसूली

<a id="setup"></a>

## Python लाइब्रेरी स्थापित करें


**अपने Python 3.11+ पर्यावरण में**

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

**इसके अलावा Deno, FFmpeg और ffprobe स्थापित करें.** ये उदाहरण लिनक्स, macOS या विंडोज पर स्थानीय रूप से चलते हैं और एपीआई कुंजी की आवश्यकता नहीं है. कार्यकर्ता के PATH पर निष्पादन को बनाए रखें.

- [बाहरी निर्भरताओं का निर्माण](https://flashdata.dev/hi/docs/guides/how-to-use-yt-dlp/reference.md#install)
- [Upstream संदर्भ](https://github.com/yt-dlp/yt-dlp#embedding-yt-dlp)

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

## अपना पहला वीडियो डाउनलोड करें


**एक वीडियो डाउनलोड करें**

```python
from yt_dlp import YoutubeDL
from yt_dlp.networking.impersonate import ImpersonateTarget

options = {
    "js_runtimes": {"deno": {}},
    "impersonate": ImpersonateTarget(),
    "concurrent_fragment_downloads": 1,
    "noplaylist": True,
    "outtmpl": "downloads/%(id)s.%(ext)s",
    "format": "bv*[height<=1080]+ba/b[height<=1080]",
}
with YoutubeDL(options) as downloader:
    downloader.download(["https://www.youtube.com/watch?v=jNQXAC9IVRw"])
```

यह स्थानीय मीडिया को 1080p तक लिखता है और अलग-अलग प्रवाहों को जोड़ सकता है. आउटपुट कंटेनर चुने हुए स्रोत प्रारूपों पर निर्भर करता है.

**CLI सेटिंग्स विरासत में नहीं हैं.** Python विकल्पों में Deno, Impersonality और Pacing सेट करें, भले ही आपका टर्मिनल कमांड पहले से ही उनका उपयोग कर रहा हो।

download() URLs की एक सूची लेता है और एक स्थिति कोड वापस करता है. extract_info(URL, download=True) निकालने की जानकारी वापस करता है, साथ ही डाउनलोड करने के लिए भी। एक संदर्भ प्रबंधक का उपयोग करके उदाहरण को साफ-सुथरे रूप से बंद करें, और स्वतंत्र नौकरी के लिए एक ताजा उदाहरण बनाएं, बजाय तारों के माध्यम से परिवर्तनीय स्थिति साझा करें।

> **Python विकल्पों के लिए यांत्रिक अनुवाद नहीं हैं**
> --write-info-json maps to writeinfojson; --no-playlist maps to noplaylist। ऑडियो रूपांतरण एक पोस्टप्रोसेसर सूची का उपयोग करता है। YoutubeDL के पैरामीटर दस्तावेज या विकल्प नामों की कल्पना करने के बजाय उन्नत cli_to_api.py सहायक से परामर्श करें।

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

## मीडिया के बिना मेटाडेटा पढ़ें


**एक छोटे से मेटाडेटा रिकॉर्ड का निर्यात करें**

```python
import json
from yt_dlp import YoutubeDL
from yt_dlp.networking.impersonate import ImpersonateTarget

url = "https://www.youtube.com/watch?v=jNQXAC9IVRw"
options = {
    "js_runtimes": {"deno": {}},
    "impersonate": ImpersonateTarget(),
    "noplaylist": True,
    "sleep_interval_requests": 3,
}
with YoutubeDL(options) as downloader:
    info = downloader.sanitize_info(downloader.extract_info(url, download=False))

record = {key: info.get(key) for key in (
    "id", "webpage_url", "title", "channel_id", "duration", "upload_date"
)}
print(json.dumps(record, ensure_ascii=False, indent=2))
```

डाउनलोड=False अभी भी नेटवर्क अनुरोधों को पूरा करता है. sanitize_info परिणाम JSON-संबंधित बनाता है; यह रहस्यों को संपादित नहीं करता है या इन क्षेत्रों में परिणाम को कम नहीं करता है.

निकाले गए क्षेत्र अनुपस्थित या शून्य हो सकते हैं। विकल्प के लिए get() का उपयोग करें, और प्रत्येक स्रोत में एक अवधि, चैनल आईडी या पूर्ण प्रारूप सूची नहीं है। एक फ्लैट प्लेलिस्ट सूची भी एक पूरी तरह से हल वीडियो से अलग है। एक सार्वजनिक प्रतिक्रिया के लिए, केवल उन क्षेत्रों को प्रोजेक्ट करें जिन्हें आप प्रदर्शित करने का इरादा रखते हैं।

प्रत्येक स्रोत के लिए एक समान डाउनलोड निकालने के साथ तुरंत एक मेटाडेटा निकालने से बचें, जब तक कि आपके अनुप्रयोग को अतिरिक्त योजना चरण की आवश्यकता नहीं है। यह स्रोत अनुरोधों को दोहराता है। यदि आपको एक स्थायी नौकरी की आवश्यकता है, तो स्रोत आईडी और आउटपुट नीति संग्रहीत करें; मेटाडेटा से एक हस्ताक्षरित मीडिया URL मूल स्रोत के लिए एक स्थायी प्रतिस्थापन नहीं है।

<a id="options"></a>

## Python विकल्प संदर्भ


| कार्य | Python विकल्प | विवरण |
| --- | --- | --- |
| फ़ाइल नाम और फ़ाइल नाम | "outtmpl": "downloads/%(id)s.%(ext)s" | स्रोत आईडी और गतिशील विस्तार रखें। |
| कठिन 1080p छत | "format": "bv*[height<=1080]+ba/b[height<=1080]" | स्रोत कोडेक की अनुमति देता है और विफल होता है यदि कोई सीमा से मेल नहीं खाता है। |
| साइड डेटा | "writeinfojson": True | मीडिया के अलावा पूर्ण निष्कर्षण मेटाडेटा का कवर करता है। |
| चेक पॉइंट चेक पॉइंट | "download_archive": "archive.txt" | एक आउटपुट नीति के लिए एक संग्रह; एक चेकस्यूम आंकड़ा नहीं। |
| कठोर गलतियां | "ignoreerrors": False | कॉलर की गलतियों को सफलता के रूप में प्रसंस्करण के बाद समस्याओं को संबोधित करने के बजाय रिकॉर्ड करें। |
| डेंगू रनटाइम | "js_runtimes": {"deno": {}} | डेनो को कार्यकर्ता में स्थापित करें और PATH पर इसके बाइनरी को दिखाई दें। |
| ब्राउज़र इम्प्लाइड | "impersonate": ImpersonateTarget() | Python --impersonate="; लक्ष्य वर्ग आयात करें और curl-cffi स्थापित करें। |
| मौजूदा कुकी फ़ाइल | "cookiefile": "private/youtube-cookies.txt" | निजी सत्र क्रेडिट का उपयोग केवल जब पहुंच के लिए आवश्यक हो। |

**MP3 परिवर्तन विकल्प**

```python
audio_options = {
    "format": "ba",
    "outtmpl": "audio/%(id)s.%(ext)s",
    "postprocessors": [{
        "key": "FFmpegExtractAudio",
        "preferredcodec": "mp3",
        "preferredquality": "192",
    }],
}
```

audio_options को YoutubeDL में स्थानांतरित करें FFmpeg पोस्ट-प्रोसेसर 192 kbps की एक लक्ष्य बिट रेट में परिवर्तित करता है; यह स्रोत की मूल गुणवत्ता में सुधार नहीं करता है।

- [Python Parameters के बारे में जानकारी](https://github.com/yt-dlp/yt-dlp/blob/master/yt_dlp/YoutubeDL.py)
- [CLI विकल्पों को Python विकल्पों में परिवर्तित करें](https://github.com/yt-dlp/yt-dlp/blob/master/devscripts/cli_to_api.py)

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

## वीडियो + ऑडियो + कैप्शन एक एआई डेटासेट के लिए


इस आउटपुट नीति का उपयोग करें जब लक्ष्य प्रशिक्षण डेटासेट है, न कि कार्यकर्ता के उदाहरण के 1080p संग्रह. यह सर्वश्रेष्ठ वीडियो और bestaudio की आवश्यकता होती है, FFmpeg को MP4 में जोड़ने की अनुमति देता है, और मीडिया के बगल में उपलब्ध अंग्रेजी कब्जे और मेटाडेटा को बचाता है.

**Python में डेटा सेट आइटम**

```python
from yt_dlp import YoutubeDL
from yt_dlp.networking.impersonate import ImpersonateTarget

url = "https://www.youtube.com/watch?v=jNQXAC9IVRw"
options = {
    "js_runtimes": {"deno": {}},
    "impersonate": ImpersonateTarget(),
    "noplaylist": True,
    "format": "bestvideo+bestaudio/best",
    "merge_output_format": "mp4",
    "postprocessors": [{
        "key": "FFmpegVideoRemuxer",
        "preferedformat": "mp4",
    }],
    "outtmpl": "dataset/%(id)s/%(id)s.%(ext)s",
    "writeinfojson": True,
    "writesubtitles": True,
    "writeautomaticsub": True,
    "subtitleslangs": ["en"],
    "subtitlesformat": "vtt/best",
    "sleep_interval_requests": 2,
    "sleep_interval_subtitles": 5,
    "sleep_interval": 5,
    "max_sleep_interval": 10,
    "concurrent_fragment_downloads": 1,
    "retries": 3,
    "fragment_retries": 3,
}
with YoutubeDL(options) as downloader:
    downloader.download([url])
```

यह FFmpeg/ffprobe, Deno और रात के [डिफ़ॉल्ट,curl-cffi] स्थापना की आवश्यकता होती है. रीमूक्सर के पसंदीदा प्रारूप पैरामीटर को yt-dlp के एपीआई में इस तरह से प्रदर्शित किया जाता है.

ImpersonateTarget() किसी भी उपलब्ध ब्राउज़र लक्ष्य का चयन करता है, जो --impersonate="" के अनुरूप होता है। वस्तु को पार करें, सीएलआई सिंटाक्स से कॉपी किए गए एक खाली श्रृंखला नहीं. curl-cffi इस पायथन वातावरण में स्थापित किया जाना चाहिए. Deno अभी भी JavaScript समाधान करता है; Impersonality इसे प्रतिस्थापित नहीं करता है।

MP4 आउटपुट कंटेनर है; चुना गया वीडियो अभी भी AV1 या VP9 हो सकता है। यदि आपके प्रशिक्षण डिकोडर को H.264/AAC की आवश्यकता होती है, तो एक अलग FFmpeg ट्रांसकोड को जोड़ने या रिकॉर्ड करने से पहले एक स्पष्ट कोडेक नीति लागू करें। उपलब्ध उपनाम प्राप्त किए जाते हैं, भाषण से उत्पन्न नहीं होते हैं।

| मीडिया खत्म होने के बाद | डेटाबेस रिकॉर्ड के लिए क्या जरूरी है |
| --- | --- |
| MP4 के साथ अंतिम ffprobe की जांच करें | Video/audio कोडेक, अवधि, आयाम, फ़ाइल मार्ग और बाइट गिनती। |
| चेक-टैप साइड-एक्सटेंशन अलग से | भाषा, supplied/automatic ट्रैक, टाइमस्टैम्प और क्या फ़ाइल वास्तव में मौजूद है। |
| कोई फिट कैप्शन उपलब्ध नहीं है | मीडिया को बनाए रखें और पाठ को याद रखें; यदि आवश्यक हो तो अपने ट्रांसमिशन चरण में ऑडियो भेजें। |
| कब्ज हिट 429 | एक IP को ठंडा करने के बाद रिट्री रिकॉर्ड रिट्री; अंतर्निहित मीडिया को पुनः डाउनलोड न करें। |

एक बैच के लिए, इस डेटासेट नीति के लिए एक अलग संग्रह का उपयोग करें और आवश्यक साइड इफेक्ट्स के लिए एक भंडार रखें। एक पूर्व 1080p या मीडिया-केवल संग्रह का पुन: उपयोग न करें: यह उनके नए आवश्यक कब्जे इकट्ठा होने से पहले वीडियो को छोड़ सकता है। मीडिया तैयारता के लिए after_move का उपयोग करें, फिर एक पूर्ण डेटासेट आइटम प्रकाशित करने से पहले पाठ और मेटाडेटा की पुष्टि करें।

- [CLI रीसेट और डेटासेट आंकड़ा](https://flashdata.dev/hi/docs/guides/how-to-use-yt-dlp/reference.md#dataset)
- [Pace Python मेटाडेटा और कैप्शन](https://flashdata.dev/hi/docs/guides/yt-dlp-429-too-many-requests/reference.md#python)

<a id="completion"></a>

## जब अंतिम फ़ाइल तैयार है पता करें


एक प्रगति हॉक रिपोर्टिंग स्थिति = समाप्त का मतलब है एक स्थानांतरण समाप्त हो गया है। FFmpeg अभी भी वीडियो और ऑडियो को मिश्रित करने, एक ऑडियो फ़ाइल को परिवर्तित करने या आउटपुट को स्थानांतरित करने की आवश्यकता हो सकती है। एक वीडियो-केवल स्ट्रीम पहुंच 100% पूरा होने की घटना नहीं है आपका आवेदन प्रकाशित करना चाहिए।

| स्टेज | क्या आप जानते हैं | अनुप्रयोग राज्य |
| --- | --- | --- |
| डाउनलोड | मीडिया के कुछ बाइट्स आ रहे हैं। | दौड़ने |
| हवाई अड्डे: समाप्त | यह स्थानांतरण समाप्त हो गया है; प्रसंस्करण अभी भी जारी किया जा सकता है। | प्रसंस्करण |
| after_move प्रसंस्करण के बाद | फ़ाइल को कॉन्फ़िगर किए गए पोस्ट-प्रसंस्करण और अंतिम कदम से गुजर गया है। | स्थानीय फाइल तैयार |
| अपलोड और अखंडता चेक | आपके डिलीवरी में वस्तु और रिकॉर्ड की पुष्टि है। | वितरित |

नीचे दिए गए पूर्ण उदाहरण में after_move पर एक कस्टम पोस्टप्रोसेसर रिकॉर्ड किया जाता है और वहां info["filepath"] पढ़ा जाता है। यह जांचता है कि फ़ाइल मौजूद है और अनौपचारिक है। यह prepare_filename() के साथ अंतिम विस्तार का अनुमान लगाने से बचता है, जो एक पूर्व-परिवर्तन नाम को संदर्भित कर सकता है।

> **एक पूरा स्थानीय डाउनलोड एक पूरा क्लाउड डिलीवरी नहीं है**
> यदि अगले चरण फ़ाइल अपलोड करता है, तो एक अपलोड स्थिति को अलग से रखें. एक डाउनलोड संग्रह अगले चरण में एक स्रोत को छोड़ सकता है, भले ही पिछले अपलोड विफल हो. स्थानीय फ़ाइल और नौकरी रिकॉर्ड से अपलोड को वापस लें.

<a id="worker"></a>

## पूर्ण स्क्रिप्ट: एकल वीडियो कार्यकर्ता


इस बात को सुनिश्चित करें कि download_video.py यह वीडियो आईडी या watch/Shorts/live/embed URL को स्वीकार करता है और playlist/channel इनपुट को अस्वीकार करता है। प्रत्येक कॉल में एक YoutubeDL उदाहरण, सीमित डाउनलोडर रिट्री और एक संग्रह-स्थानीय संग्रह का उपयोग किया जाता है। एक बार फिर से पूरा स्रोत वापसी एक नया फ़ाइल बनाया गया था के बजाय कल्पना करने के बजाय छोड़ दिया गया है।

- [डाउनलोड करें download_video.py](https://flashdata.dev/examples/yt-dlp/download_video.py)

**download_video.py**

```python
import argparse
import json
import re
from pathlib import Path
from urllib.parse import parse_qs, urlparse

from yt_dlp import YoutubeDL
from yt_dlp.networking.impersonate import ImpersonateTarget
from yt_dlp.postprocessor.common import PostProcessor
from yt_dlp.utils import DownloadError, PostProcessingError


def watch_url(value):
    """Accept a video ID or a single YouTube video URL, never a playlist."""
    video_id = value
    if not re.fullmatch(r"[A-Za-z0-9_-]{11}", value):
        parsed = urlparse(value)
        parts = parsed.path.strip("/").split("/")
        host = (parsed.hostname or "").lower()
        if parsed.scheme not in {"http", "https"}:
            raise ValueError("Use a YouTube watch URL or 11-character video ID")
        if host in {"youtu.be", "www.youtu.be"}:
            video_id = parts[0]
        elif host in {"youtube.com", "www.youtube.com", "m.youtube.com"}:
            if parsed.path == "/watch":
                video_id = parse_qs(parsed.query).get("v", [""])[0]
            elif len(parts) == 2 and parts[0] in {"shorts", "live", "embed"}:
                video_id = parts[1]
            else:
                video_id = ""
        else:
            video_id = ""
    if not re.fullmatch(r"[A-Za-z0-9_-]{11}", video_id):
        raise ValueError("Expected one YouTube video, not a channel or playlist")
    return "https://www.youtube.com/watch?v=" + video_id


class FinalFile(PostProcessor):
    def __init__(self):
        super().__init__()
        self.result = None

    def run(self, info):
        path = Path(info["filepath"]).resolve()
        if not path.is_file() or path.stat().st_size == 0:
            raise PostProcessingError("Final media file is missing or empty")
        self.result = {
            "status": "completed", "video_id": info["id"],
            "title": info.get("title"), "duration": info.get("duration"),
            "path": str(path), "bytes": path.stat().st_size,
        }
        return [], info


def download_video(source, output="downloads"):
    url = watch_url(source)
    folder = Path(output).resolve()
    folder.mkdir(parents=True, exist_ok=True)
    final_file = FinalFile()
    options = {
        "js_runtimes": {"deno": {}},
        "impersonate": ImpersonateTarget(),
        "concurrent_fragment_downloads": 1,
        "noplaylist": True,
        "format": "bv*[height<=1080]+ba/b[height<=1080]",
        "outtmpl": str(folder / "%(id)s.%(ext)s"),
        "download_archive": str(folder / "archive.txt"),
        "writeinfojson": True,
        "ignoreerrors": False,
        "retries": 3, "fragment_retries": 3, "socket_timeout": 30,
        "sleep_interval_requests": 1,
        "sleep_interval": 5, "max_sleep_interval": 10,
    }
    with YoutubeDL(options) as downloader:
        downloader.add_post_processor(final_file, when="after_move")
        downloader.extract_info(url, download=True)
    if final_file.result is None:
        return {"status": "skipped", "source": url,
                "reason": "No new file recorded; check the archive"}
    return {**final_file.result, "source": url}


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("source", help="YouTube video URL or ID")
    parser.add_argument("--output", default="downloads")
    args = parser.parse_args()
    try:
        result = download_video(args.source, args.output)
    except (DownloadError, ValueError, OSError) as error:
        raise SystemExit(f"Job failed: {error}") from error
    print(json.dumps(result, ensure_ascii=False, indent=2))
```

यह केवल स्थानीय आउटपुट का स्वामित्व करता है; अपने अनुप्रयोग के अगले चरण में डिकोडिंग चेक और अपलोड रिकॉर्ड जोड़ें।

**एक काम चलाएं**

```bash
python download_video.py "https://www.youtube.com/watch?v=jNQXAC9IVRw" --output downloads
```

पूरा रिकॉर्ड में कैननिक स्रोत URL, वीडियो आईडी, अंतिम मार्ग और बाइट आकार शामिल हैं। एक स्काइप रिकॉर्ड का मतलब है कि कोई नया अंतिम फ़ाइल कॉलबैक नहीं चला; यदि आपको यह साबित करने की आवश्यकता है कि फ़ाइल अभी भी मौजूद है तो इसे संग्रह और मौजूदा रिकॉर्ड के खिलाफ संरेखित करें। अकेले संग्रह यह जांच नहीं करता है कि क्या एक उपयोगकर्ता बाद में मीडिया को हटा दिया या स्थानांतरित किया गया है।

extractor/download/post-processing विफलताओं के लिए DownloadError, अस्वीकार किए गए इनपुट के लिए ValueError और स्थानीय फ़ाइल सिस्टम विफलताओं के लिए OSError को पकड़ो। इन को अपने आवेदन लॉग में अलग-अलग वर्गों के रूप में संबोधित करें। त्रुटि संदेश उपयोगी निदान हैं, लेकिन उनका पाठ किसी भी यूट्यूब विफलता का एक स्थिर संरचित टैक्सोनी नहीं है।

<a id="batch"></a>

## पूर्ण स्क्रिप्ट: पुनरावृत्ति बैच कार्यकर्ता


download_batch.py के बगल में download_video.py रखें। एक यूटीएफ-8 urls.txt बनाएं जिसमें एक वीडियो यूआरएल या आईडी प्रति लाइन है। यह जानबूझकर लगातार चलता है, इसलिए एक प्रक्रिया संग्रह और आउटपुट निर्देशिका के स्वामित्व में है। यह प्रत्येक प्रयास के लिए एक पूरा, स्काइप या असफल परिणाम लिखता है और किसी भी आइटम को असफल होने पर गैर शून्य आउटपुट और आउटपुट।

- [डाउनलोड करें download_batch.py](https://flashdata.dev/examples/yt-dlp/download_batch.py)

**download_batch.py**

```python
import argparse
import json
from datetime import datetime, timezone
from pathlib import Path

from yt_dlp.utils import DownloadError
from download_video import download_video


def run_batch(manifest, output):
    folder = Path(output).resolve()
    folder.mkdir(parents=True, exist_ok=True)
    sources = list(dict.fromkeys(
        line.strip()
        for line in Path(manifest).read_text(encoding="utf-8-sig").splitlines()
        if line.strip() and not line.lstrip().startswith("#")
    ))
    counts = {"completed": 0, "skipped": 0, "failed": 0}
    with (folder / "attempts.jsonl").open("a", encoding="utf-8") as log:
        for source in sources:
            try:
                result = download_video(source, folder)
            except (DownloadError, ValueError, OSError) as error:
                result = {"source": source, "status": "failed",
                          "error_type": type(error).__name__, "error": str(error)}
            result["recorded_at"] = datetime.now(timezone.utc).isoformat()
            log.write(json.dumps(result, ensure_ascii=False) + "\n")
            log.flush()
            counts[result["status"]] += 1
    return counts


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("manifest", help="UTF-8 file, one video URL or ID per line")
    parser.add_argument("--output", default="collection")
    args = parser.parse_args()
    counts = run_batch(args.manifest, args.output)
    print(json.dumps(counts, indent=2))
    raise SystemExit(1 if counts["failed"] else 0)
```

एप्लिकेशन-केवल attempts.jsonl अलग-अलग प्रयासों के रूप में रिट्री रखता है. एक मैनीज के भीतर डुप्लिकेट लाइनों को हटा दिया जाता है; डाउनलोड संग्रह को चलाने के दौरान पूरा आईडी प्रबंधित करता है.

**एक ही बैच चलाएं या फिर से करें**

```bash
python download_batch.py urls.txt --output collection
```

प्रत्येक रिकॉर्ड के बाद फ्लेश करें ताकि एक रुकावट हर परिणाम को अंत तक बफेर नहीं छोड़ सके। पुस्तकालय के संग्रह के बीच अभी भी एक छोटा खिड़की है और आपके अनुप्रयोग ने एक प्रयास रिकॉर्ड लिखा है। यदि कोई दुर्घटना वहां उतरती है, तो अगले दौर को छोड़ दिया जा सकता है। एक सेवा के लिए, इस पाठ फ़ाइल उदाहरण का दावा करने के बजाय एक स्थायी नौकरी डेटाबेस के साथ filesystem/archive को संरेखित करना व्यावसायिक है।

attempts.jsonl गोपनीय रखें: त्रुटियों में स्रोत और अनुरोध विवरण शामिल हो सकते हैं. स्थिति के अनुसार कुल रिपोर्ट करें, विफल वस्तुओं की जांच करें, और एक साझा पर्यावरण समस्या को हल करने के बाद एक ही प्रदर्शन को फिर से खेलें. सफलता संग्रह में हर विफल आईडी जोड़ने न दें.

<a id="service"></a>

## उत्पादन: क्यूई, समय सीमा और भंडारण


YoutubeDL सिंक्रनाइज़ेशन है। इसे सीधे एक असेंक वेब ट्रेनर ब्लॉक के अंदर चलाना है कि ट्रेनर की घटना लूप; यहां तक कि एक तार अपलोड भी एक ब्राउज़र अनुरोध को एक बड़े डाउनलोड के लिए एक उचित जीवनकाल नहीं बनाता है। नौकरी स्वीकार करें, अपने source/options को जारी रखें, और एक श्रमिकों को अंतिम परिणाम देने दें।

- प्रदर्शन से पहले एक स्थायी नौकरी आईडी बनाएं. वीडियो आईडी, आउटपुट नीति, प्रयास संख्या और गंतव्य को संग्रहीत करें.
- नौकरी के लिए कार्य निर्देशिकाओं और एक सीमित श्रमिकों के पूल का उपयोग करें. एक YoutubeDL उदाहरण को समकक्ष नौकरियों के बीच साझा न करें.
- जब आपको एक कठिन दीवार घड़ी समय सीमा या रद्द करने की आवश्यकता होती है तो एक अलग प्रक्रिया का उपयोग करें; socket_timeout पूरे काम के बजाय व्यक्तिगत नेटवर्क संचालन को सीमित करता है।
- यदि HTTP के माध्यम से उपयोगकर्ता इनपुट को प्रदर्शित करते हैं, तो स्वाभाविक URL, आउटपुट मार्ग, एक्सट्रैक्टर तर्क या शेल स्नैपेट्स के बजाय समर्थित YouTube वीडियो पहचानकर्ताओं को स्वीकार करें।
- स्थानीय फ़ाइल तैयारता और क्लाउड अपलोड पूरा करने के लिए अलग-अलग रिकॉर्ड; एक अपलोड को फिर से डाउनलोड किए बिना वापस लेने के लिए पर्याप्त स्थिति रखें।
- अपने डिप्लोमा के साथ FFmpeg, चलने का समय, yt-dlp और प्लगइन संस्करण रखें. एक श्रमिकों की छवि को बदलने से पहले एक छोटे से ज्ञात कार्य भार का अभ्यास करें.

एक साधारण श्रमिकों के पूल की तुलना में बेहतर प्रारंभिक बिंदु है unlimited asyncio.gather कई डाउनलोड के आसपास कॉल करता है। प्रक्रियाओं के माध्यम से कुल काम को समन्वित करें; प्रत्येक डाउनलोडर की नींद सेटिंग्स पूरे सेवा को विनियमित नहीं करती हैं। नौकरी की कोशिशों के लिए एक अलग रिट्री बजट रखें ताकि आवेदन रिट्री डाउनलोडर की खुद की रिट्री गिनती को बहुतायत न करें।

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

## Python कार्यकर्ता को परेशान करें


| समस्या | चेक |
| --- | --- |
| CLI में काम, Python में विफलता | YoutubeDL स्वचालित रूप से आपके CLI कॉन्फ़िगरेशन फ़ाइल को लोड नहीं करता है। |
| प्रगति कहती है खत्म, फ़ाइल गायब | after_move सीमा का उपयोग करें और प्रसंस्करण के बाद त्रुटियों की जांच करें। |
| पुनरावृत्ति की वापसी की खबरें | संग्रह संग्रह को पढ़ें; उत्पादन नीतियों को बदलने के लिए एक अलग संग्रह का उपयोग करें। |
| श्रमिकों को लंबे समय तक लटकाया जाता है socket_timeout | एक नौकरी कई operations/retries. कर सकती है यदि आवश्यक हो तो प्रक्रिया स्तर की समय सीमा जोड़ें। |
| 403 या बोट सर्वर पर जांच करता है | रात में अपडेट करें, Deno की जांच करें, प्रतिस्पर्धा को कम करें और जब रास्ता अस्वीकार कर दिया जाता है तो एक प्रतिस्थापन आउटपुट आईपी का परीक्षण करें। |
| 429 में मेटाडेटा / ट्रांसक्रिप्ट नौकरियां | प्रभावित आईपी, गति extraction/subtitle अनुरोधों को रोकें और मेटाडेटा-केवल नौकरियों के बीच देरी जोड़ें। |

- [403 कार्यप्रवाह का निदान](https://flashdata.dev/hi/docs/guides/yt-dlp-403-forbidden/reference.md)
- [Session और bot-check workflow](https://flashdata.dev/hi/docs/guides/yt-dlp-sign-in-not-a-bot/reference.md)
- [429 पुनर्प्राप्ति और Python पैकिंग](https://flashdata.dev/hi/docs/guides/yt-dlp-429-too-many-requests/reference.md)
- [बचाए गए मीडिया की जांच करें](https://flashdata.dev/hi/docs/guides/how-to-use-yt-dlp/reference.md#verify)

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

## जब उत्पादन एक क्लाउड पाइपलाइन में आता है


यदि आप डाउनलोडर का स्वामित्व करना चाहते हैं, तो उपरोक्त कार्यप्रवाह आपको फ़ाइलों, प्रारूपों और प्रसंस्करण पर नियंत्रण प्रदान करते हैं। यदि आपके एप्लिकेशन को भंडारण के लिए वितरित पूर्ण मीडिया की आवश्यकता होती है, तो FlashData ट्रैक किए गए YouTube डाउनलोड नौकरियों, बॉट प्रबंधन, प्रॉक्सी रूटिंग और रिट्री प्रदान करता है। आपका आवेदन स्रोत और आउटपुट सेटिंग्स को प्रस्तुत करता है, फिर नौकरी आईडी और वितरण रिकॉर्ड रखता है।

- [दो ऑपरेटिंग मॉडल की तुलना करें](https://flashdata.dev/hi/docs/guides/flashdata-vs-yt-dlp/reference.md)
- [YouTube वीडियो बल्क डाउनलोड](https://flashdata.dev/hi/products/youtube-download#bulk-downloads)
- [डाउनलोड डेमो का प्रयोग करें](https://flashdata.dev/hi/products/youtube-download#playground)
- [डाउनलोड एपीआई संदर्भ](https://flashdata.dev/hi/docs/sources/youtube_download/reference.md)
