# API Python ของ yt-dlp

ตัวอย่าง Python ที่รันได้สำหรับการดาวน์โหลด เมทาดาทา ชุดข้อมูล AI และงานที่ทำต่อได้หลังหยุดชะงัก

อ้างอิงทางคลอง: https://flashdata.dev/th/docs/guides/yt-dlp-python-api
Recorder: 2026-11-13 โดย FlashData

- [เริ่มต้นด้วย Python](https://flashdata.dev/th/docs/guides/yt-dlp-python-api/reference.md#first-call) — ติดตั้งและทําโทรศัพท์
- [ค้นหาไฟล์สุดท้าย](https://flashdata.dev/th/docs/guides/yt-dlp-python-api/reference.md#completion) — หลังจากถ่ายโอนและประมวลผล
- [รับพนักงาน](https://flashdata.dev/th/docs/guides/yt-dlp-python-api/reference.md#worker) — ดาวน์โหลด .py
- [การประมวลผลการเก็บรวบรวม](https://flashdata.dev/th/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.** ตัวอย่างเหล่านี้ทํางานในท้องถิ่นบน Linux, macOS หรือ Windows และไม่จําเป็นต้องใช้คีย์ API. ปกป้องตัวดําเนินการใน PATH ของพนักงาน

- [การติดตั้งความสัมพันธ์ภายนอก](https://flashdata.dev/th/docs/guides/how-to-use-yt-dlp/reference.md#install)
- [การแนะนําการรวมตัว](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 ไม่ได้เป็นพันธุกรรม** การตั้งค่า Deno, การกําหนดเองและแพคเกจในตัวเลือก Python แม้ว่าคําสั่งปลายทางของคุณจะใช้พวกเขาแล้ว

download() ใช้รายการ URL และส่งคืนรหัสสถานะ extract_info(url, download=True) ส่งคืนข้อมูลการสกัดเช่นเดียวกับการดําเนินการดาวน์โหลด ใช้ผู้จัดการแบริ่งเพื่อปิดตัวอย่างอย่างสะอาดและสร้างตัวอย่างใหม่สําหรับงานที่อิสระแทนที่จะแบ่งปันสถานะที่เปลี่ยนแปลงผ่านสาย

> **ตัวเลือก Python ไม่ใช่การแปลกลของป้าย**
> --write-info-json แผนที่เพื่อเขียนinfojson; --no-playlist แผนที่เพื่อ noplaylist. การแปลงเสียงใช้รายการของ Postprocessors ดูเอกสารตัวเลขของ YoutubeDL หรือผู้ช่วย upstream 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))
```

download=False ยังคงดําเนินการคําขอเครือข่าย sanitize_info ทําให้ผลลัพธ์ JSON-เข้ากันได้; มันไม่เขียนความลับหรือลดผลลัพธ์ไปยังฟิลด์เหล่านี้.

ตารางที่สกัดอาจไม่มีหรือไม่มี ใช้ Get() สําหรับข้อมูล metadata ตัวเลือกและไม่คิดว่าแหล่งแต่ละแหล่งมีระยะเวลา ID ช่องหรือรายการรูปแบบที่สมบูรณ์ รายการรายการรายการแบบแบนยังแตกต่างจากวิดีโอที่ละเอียดเต็ม สําหรับการตอบสนองสาธารณะโปรเจคเพียงฟิลด์ที่คุณวางแผนที่จะแสดง

หลีกเลี่ยงการสกัดข้อมูลโดยตรงตามการสกัดดาวน์โหลดที่เหมือนกันสําหรับแต่ละแหล่งข้อมูลหากแอพของคุณไม่ต้องการขั้นตอนการวางแผนเพิ่มเติม มัน duplicates คําขอแหล่งข้อมูล หากคุณต้องการงานที่ทนทานให้เก็บรหัสแหล่งข้อมูลและนโยบายการออก; URL ของสื่อที่ลงชื่อจากข้อมูลโลหะไม่ได้เป็นการแทนที่ที่ที่ทนทานสําหรับแหล่งข้อมูลเดิม

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

## Python ตัวเลือกการอ้างอิง


| งาน | Python ตัวเลือก | รายละเอียด |
| --- | --- | --- |
| ใบสมัครและชื่อไฟล์ | "outtmpl": "downloads/%(id)s.%(ext)s" | ปรับการเก็บรหัสแหล่งข้อมูลและขยายแบบไดนามิก |
| ฮาร์ดคอร์ 1080p ตาข่าย | "format": "bv*[height<=1080]+ba/b[height<=1080]" | ช่วยให้รหัสแหล่งและล้มเหลวถ้าไม่มีการเข้ากันกับข้อ จํากัด |
| โมทเดต SideCare | "writeinfojson": True | Keeps เต็ม extraction metadata ขึ้นอยู่กับสื่อ |
| หมายเลขที่กําหนดเอง | "download_archive": "archive.txt" | หนึ่งไฟล์ต่อการผลิตนโยบาย; ไม่เป็นรายการตรวจสอบ |
| ข้อผิดพลาดที่เข้มงวด | "ignoreerrors": False | ให้โทรศัพท์บันทึกความล้มเหลวแทนที่จะจัดการปัญหาหลังการประมวลผลเป็นความสําเร็จ |
| ระยะเวลา Runtime | "js_runtimes": {"deno": {}} | ติดตั้ง 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",
    }],
}
```

Pass audio_options to YoutubeDL. The FFmpeg post-processor converts to a target bitrate of 192 kbps; มันไม่ปรับปรุงคุณภาพเดิมของแหล่งข้อมูล

- [พารามิเตอร์ Python](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>

## วิดีโอ + เสียง + captions สําหรับ AI ไฟล์


ใช้นโยบายการออกนี้เมื่อเป้าหมายคือชุดข้อมูลการฝึกอบรมแทนที่จะเก็บรวบรวมตัวอย่างของ 1080p มันต้องการ bestvideo และ bestaudio ให้ FFmpeg ผสมพวกเขาใน MP4 และบันทึก captions และ metadata อังกฤษที่มีอยู่นอกเหนือจากสื่อ

**รายการชุดข้อมูลใน 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] พารามิเตอร์รูปแบบที่ต้องการของ remuxer จะแสดงใน API ของ yt-dlp

ImpersonateTarget() เลือกเป้าหมายเบราว์เซอร์ใด ๆ ที่พร้อมใช้งานซึ่งตรงกับ --impersonate="". ผ่านวัตถุไม่ใช่เส้นผ่าศูนย์กลางที่ว่างเปล่าที่คัดลอกจาก CLI syntax curl-cffi จะต้องติดตั้งในสภาพแวดล้อม Python นี้ Deno ยังคงดําเนินการแก้ปัญหา JavaScript; การกําหนดเองไม่แทนที่มัน

MP4 เป็นภาชนะออก; วิดีโอที่เลือกยังสามารถ AV1 หรือ VP9 หากการฝึกอบรมของคุณต้องการ H.264/AAC ใช้นโยบายการเข้ารหัสที่ชัดเจนก่อนที่จะรวมหรือบันทึกรหัสผ่านที่แยกต่างหาก FFmpeg คําอธิบายที่ได้รับจะถูกนํามาใช้ไม่ได้รับการแสดงออก

| หลังจากสื่อเสร็จสิ้น | สิ่งที่บันทึกข้อมูลชุดต้องการ |
| --- | --- |
| ดูสุดท้าย MP4 กับ ffprobe | Video/audio คิดโค้ดระยะเวลาขนาดเส้นทางไฟล์และบิต |
| ตรวจสอบ caption ตารางด้านข้างแยก | ภาษา supplied/automatic สารสถิติเวลาและว่าไฟล์นั้นมีอยู่หรือไม่ |
| ไม่มีการจับคู่ที่พร้อมใช้งาน | ปกป้องสื่อและระบุข้อความที่หายไป ส่งเสียงไปยังขั้นตอนการแปลของคุณหากจําเป็น |
| คำขอคำบรรยายพบข้อผิดพลาด 429 | Retry caption retrieval หลังจาก IP cooldown ด้วย subtitle pacing; ไม่ดาวน์โหลดใหม่ media ที่เสร็จสิ้น |

สําหรับชุดใช้ไฟล์ที่แยกต่างหากสําหรับนโยบายชุดข้อมูลนี้และเก็บข้อมูลสําหรับหน้าเว็บที่ต้องการ อย่าใช้ใหม่ไฟล์ 1080p หรือไฟล์ media-only: มันอาจลบวิดีโอก่อนที่ไฟล์ที่ต้องการใหม่จะถูกเก็บรวบรวม ใช้ after_move สําหรับการเตรียมสื่อแล้วยืนยันข้อความและข้อมูลโลหะก่อนที่จะเผยแพร่รายการชุดข้อมูลเต็ม

- [CLI สูตรและข้อมูลชุดสํารองข้อมูล](https://flashdata.dev/th/docs/guides/how-to-use-yt-dlp/reference.md#dataset)
- [Pace Python metadata และ captions](https://flashdata.dev/th/docs/guides/yt-dlp-429-too-many-requests/reference.md#python)

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

## เรียนรู้เมื่อไฟล์สุดท้ายพร้อม


โครงการรายงานโหมด = สิ้นสุดหมายความการถ่ายโอนเสร็จสิ้น FFmpeg อาจยังคงต้องผสมวิดีโอและเสียงแปลงไฟล์เสียงหรือย้ายผลผลิต การส่งผ่านวิดีโอเพียงแค่ 100% ไม่เป็นเหตุการณ์การเสร็จสิ้นที่แอพพลิเคชันของคุณควรเผยแพร่

| เวที | สิ่งที่คุณรู้ | ใบสมัครรัฐ |
| --- | --- | --- |
| ดาวน์โหลด | บางไบต์สื่อมาถึง | การทํางาน |
| โพสต์: หมดอายุ | การถ่ายโอนนี้เสร็จสิ้นการประมวลผลยังคงสามารถดําเนินการได้ | การประมวลผล |
| after_move โพสต์โปรเซสเซอร์ | ไฟล์ได้ผ่านการกําหนดค่าหลังการประมวลผลและขั้นตอนสุดท้าย | ไฟล์ในท้องถิ่นพร้อม |
| การตรวจสอบอัปโหลดและความสมบูรณ์ | จุดหมายปลายทางของคุณมีวัตถุและการตรวจสอบที่บันทึกไว้ | จัดส่ง |

ตัวอย่างที่สมบูรณ์ด้านล่างบันทึก PostProcessor ที่กําหนดเองใน after_move และอ่าน info["filepath"] ที่นี่ ตรวจสอบว่าไฟล์นั้นมีอยู่และไม่มีการเปิดใช้งาน นี่จะหลีกเลี่ยงการคาดการณ์การขยายตัวสุดท้ายด้วย prepare_filename(), ซึ่งสามารถอ้างถึงชื่อก่อนการแปลง

> **การดาวน์โหลดในท้องถิ่นเสร็จสิ้นไม่ใช่การจัดส่งในคลาวด์เสร็จสิ้น**
> หากขั้นตอนต่อไปจะอัพโหลดไฟล์ให้保持สถานะอัพโหลดแยกต่างหาก ไฟล์ดาวน์โหลดสามารถล้มเหลวแหล่งในขั้นตอนต่อไปแม้ว่าการอัพโหลดก่อนหน้านี้ได้ล้มเหลว ไฟล์ที่บันทึกไว้ในท้องถิ่นและบันทึกงาน

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

## สภาพยนตร์เต็มรูปแบบ: คนงานวิดีโอเดียว


เก็บสิ่งนี้เป็น download_video.py มันยอมรับ ID วิดีโอหรือ URL watch/Shorts/live/embed และปฏิเสธ playlist/channel input. การเรียกเก็บข้อมูลแต่ละครั้งใช้ตัวอย่าง 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))
```

สคริปต์เต็มรูปแบบยังสามารถใช้ได้จากลิงค์ดาวน์โหลดด้านบน มันเป็นเจ้าของการออกในท้องถิ่นเท่านั้น เพิ่มการตรวจสอบการลบและบันทึกอัพโหลดในขั้นตอนต่อไปของแอพของคุณ

**ทํางาน 1 งาน**

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

บันทึกที่เสร็จสิ้นมี URL ที่มาของช่อง, ID วิดีโอ, เส้นทางสุดท้ายและขนาดไบต์ ไฟล์ที่ถูกลบหมายความว่าไม่มีการเรียกคืนไฟล์สุดท้ายใหม่; เชื่อมต่อกับไฟล์และข้อมูลที่มีอยู่ถ้าคุณต้องการรับรองไฟล์ยังคงมี เท่านั้นไฟล์ไม่ตรวจสอบว่าผู้ใช้ได้ลบหรือย้ายสื่อในภายหลัง

Catch DownloadError for extractor/download/post-processing failures, ValueError for rejected input และ OSError for local file system failures. การจัดการเหล่านี้เป็นชั้นที่แตกต่างกันในบันทึกการใช้งานของคุณ ข้อความข้อผิดพลาดเป็นการวินิจฉัยที่เป็นประโยชน์ แต่ข้อความของพวกเขาไม่ได้เป็นค่าธรรมเนียมที่กําหนดเองที่มั่นคงของทุกข้อผิดพลาดของ YouTube

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

## สภาพยนตร์เต็มรูปแบบ: พัฒนาการบิตชาร์จ


ใส่ download_batch.py ด้านข้าง download_video.py สร้าง UTF-8 urls.txt ด้วย URL วิดีโอเดียวหรือ ID ต่อเส้น นี้จะทํางานอย่างตั้งใจอย่างต่อเนื่องดังนั้นกระบวนการหนึ่งเป็นเจ้าของเอกสารและแผนที่การส่งออก มันเขียนผลที่เสร็จสิ้น, เก็บหรือล้มเหลวสําหรับแต่ละการพยายามเข้าและออก nonzero เมื่อรายการใด ๆ ไม่ได้ล้มเหลว

- [ดาวน์โหลด 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 ช่วยให้การคืนเงินเป็นความพยายามแยกต่างหาก สายคู่ภายในแถบจะถูกลบ; การดาวน์โหลดไฟล์จัดการ ID ที่เสร็จสมบูรณ์ผ่านการทํางาน

**การทํางานหรือรีไซเคิลชุดเดียวกัน**

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

พลัสหลังจากแต่ละบันทึกเพื่อให้การหยุดไม่ปล่อยให้ผลทั้งหมดจะกลายเป็นบ่อจนถึงจุดสิ้นสุด ยังคงมีหน้าต่างเล็ก ๆ ระหว่างห้องสมุดบันทึกไฟล์และแอพของคุณเขียนบันทึกการพยายาม หากเกิดความเสียหายที่อยู่แล้วการแข่งขันต่อไปสามารถรายงานได้ สําหรับบริการ, เชื่อมต่อ filesystem/archive กับฐานข้อมูลงานที่ทนทานแทนที่จะเรียกร้องตัวอย่างไฟล์ข้อความนี้เป็นธุรกรรม

ปกป้อง attempts.jsonl ส่วนตัว: ข้อผิดพลาดอาจรวมถึงข้อมูลแหล่งและคําขอ รายงานทั้งหมดตามสถานะตรวจสอบรายการที่ขาดหายไปและเล่นใหม่ที่ปรากฏเดียวกันหลังจากแก้ปัญหาสภาพแวดล้อมที่แบ่งปัน อย่าเพิ่ม ID ที่ขาดหายไปแต่ละรายเข้าสู่ไฟล์ความสําเร็จ

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

## การผลิต: รอบ, เวลาและจัดเก็บ


YoutubeDL เป็น synchronous การทํางานโดยตรงภายในบล็อกเว็บแฮนด์แฮนด์ที่แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮนด์แฮ การยอมรับงานให้ต่อเนื่อง source/options และให้ผู้ทํางานผลิตผลสุดท้าย

- สร้าง ID งานที่ทนทานก่อนการดําเนินการ บันทึก ID วิดีโอแบบ Canonical, นโยบายการออกกําลังกาย, หมายเลขการพยายามและจุดหมายปลายทาง
- ใช้ไดเรกทอรีงานต่องานและสระว่ายน้ํางานที่ จํากัด อย่าแบ่งปันตัวอย่าง YoutubeDL ในงานที่เกิดขึ้น
- ใช้กระบวนการที่แยกต่างหากเมื่อคุณต้องการระยะเวลาหรือการยกเลิกของผนังที่ยาก socket_timeout จํากัด การดําเนินงานเครือข่ายแต่ละบุคคลและไม่ทํางานทั้งหมด
- หากคุณแสดงผลเข้าถึงผู้ใช้มากกว่า HTTP จะยอมรับการระบุวิดีโอ YouTube ที่ได้รับการสนับสนุนแทนที่ URL ที่ตั้งค่าเส้นทางออก สัญญาสกัดหรือ Snippets Shell
- บันทึกการเตรียมไฟล์ในท้องถิ่นและเสร็จสิ้นการอัพโหลดคลาวด์แยกต่างหาก; ปกป้องสถานะเพียงพอเพื่อรับส่งการอัพโหลดโดยไม่ต้องดาวน์โหลดอีกครั้ง
- ปกป้อง FFmpeg, runtime, yt-dlp และเวอร์ชันปลั๊กอินพร้อมกับการใช้งานของคุณ การทํางานของโหลดงานที่รู้จักเล็กน้อยก่อนที่จะเปลี่ยนภาพของผู้ทํางาน

สระว่ายน้ําผู้ทํางานที่เรียบง่ายเป็นจุดเริ่มต้นที่ดีกว่า asyncio.gather ที่ไม่มีข้อ จํากัด คลิกรอบการดาวน์โหลดจํานวนมาก การปรับการทํางานทั้งหมดผ่านกระบวนการ การตั้งค่านอนของแต่ละดาวน์โหลดไม่ปรับบริการทั้งหมด ปกป้องเงินทุนการเดินทางที่แยกต่างหากสําหรับการพยายามทํางานเพื่อให้การเดินทางในการสมัครไม่เพิ่มจํานวนการเดินทางของตัวดาวน์โหลดเอง

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

## ปรับปรุงความผิดพลาดของผู้ทํางาน Python


| ปัญหา | ตรวจสอบ |
| --- | --- |
| งานใน CLI, ความล้มเหลวใน Python | คัดลอกตัวเลือกจริง YoutubeDL ไม่โหลดไฟล์การกําหนดค่า CLI ของคุณโดยอัตโนมัติ |
| การพัฒนาบอกว่าเสร็จสิ้นไฟล์หายไป | ใช้ after_move ป้ายและตรวจสอบข้อผิดพลาดหลังการประมวลผล |
| หลักสูตรการคืนเงินที่ซ้ํากัน | อ่านไฟล์เก็บรวบรวม; ใช้ไฟล์ที่แตกต่างกันเมื่อเปลี่ยนนโยบายการส่งออก |
| คนทํางานยึดนานกว่า socket_timeout | งานสามารถทําได้หลาย operations/retries. เพิ่มระยะเวลาระดับกระบวนการถ้าจําเป็น |
| 403 หรือบ็อตตรวจสอบบนเซิร์ฟเวอร์ | ปรับปรุงคืนตรวจสอบ Deno ลดการแข่งขันและทดสอบ IP การออกทางแทนเมื่อเส้นทางยังคงถูกปฏิเสธ |
| 429 ในข้อมูล / การทํางานที่ผ่านการเขียน | ปิด IP ที่ได้รับผลกระทบ ความเร็ว extraction/subtitle คําขอและเพิ่มการล่าช้าระหว่างงาน metadata-เพียง |

- [403 การวินิจฉัยการไหลของงาน](https://flashdata.dev/th/docs/guides/yt-dlp-403-forbidden/reference.md)
- [การประชุมและกระแสการทํางานของบ็อตตรวจสอบ](https://flashdata.dev/th/docs/guides/yt-dlp-sign-in-not-a-bot/reference.md)
- [429 การกู้คืนและ Python pacing](https://flashdata.dev/th/docs/guides/yt-dlp-429-too-many-requests/reference.md)
- [ตรวจสอบสื่อที่บันทึกไว้](https://flashdata.dev/th/docs/guides/how-to-use-yt-dlp/reference.md#verify)

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

## เมื่อการผลิตอยู่ในท่อคลาวด์


หากคุณต้องการเป็นเจ้าของดาวน์โหลดแล้วการทํางานที่ด้านบนจะช่วยให้คุณสามารถควบคุมไฟล์รูปแบบและประมวลผลได้ หากแอพของคุณต้องการสื่อที่เสร็จสิ้นที่ส่งไปยังจัดเก็บ FlashData ให้การติดตาม YouTube ดาวน์โหลดงานการจัดการ bot, การนําทางโปรกซี่และ retries การสมัครของคุณส่งการตั้งค่าแหล่งและผลผลิตแล้วเก็บรหัสการทํางานและบันทึกการจัดส่ง

- [การเปรียบเทียบสองรูปแบบการดําเนินงาน](https://flashdata.dev/th/docs/guides/flashdata-vs-yt-dlp/reference.md)
- [ดาวน์โหลดวิดีโอ YouTube จำนวนมาก](https://flashdata.dev/th/products/youtube-download#bulk-downloads)
- [ลองดาวน์โหลด demo](https://flashdata.dev/th/products/youtube-download#playground)
- [ดาวน์โหลด API](https://flashdata.dev/th/docs/sources/youtube_download/reference.md)
