ข้ามไปยังเนื้อหา
TH
รับคีย์ API
เรียกดูเอกสาร

คู่มือ

API Python ของ yt-dlp

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

ในหน้านี้

ติดตั้งห้องสมุด Python

ในสภาพแวดล้อม Python 3.11+ ของคุณ
python -m pip install -U --pre "yt-dlp[default,curl-cffi]"

นอกจากนี้ยังติดตั้ง Deno, FFmpeg และ ffprobe. ตัวอย่างเหล่านี้ทํางานในท้องถิ่นบน Linux, macOS หรือ Windows และไม่จําเป็นต้องใช้คีย์ API. ปกป้องตัวดําเนินการใน PATH ของพนักงาน

ดาวน์โหลดวิดีโอแรกของคุณ

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

อ่านข้อมูลโดยไม่มีสื่อ

การส่งออกบันทึกข้อมูลขนาดเล็ก
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 ของสื่อที่ลงชื่อจากข้อมูลโลหะไม่ได้เป็นการแทนที่ที่ที่ทนทานสําหรับแหล่งข้อมูลเดิม

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

งานPython ตัวเลือกรายละเอียด
ใบสมัครและชื่อไฟล์"outtmpl": "downloads/%(id)s.%(ext)s"ปรับการเก็บรหัสแหล่งข้อมูลและขยายแบบไดนามิก
ฮาร์ดคอร์ 1080p ตาข่าย"format": "bv*[height<=1080]+ba/b[height<=1080]"ช่วยให้รหัสแหล่งและล้มเหลวถ้าไม่มีการเข้ากันกับข้อ จํากัด
โมทเดต SideCare"writeinfojson": TrueKeeps เต็ม 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 ตัวเลือกการแปลง
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; มันไม่ปรับปรุงคุณภาพเดิมของแหล่งข้อมูล

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

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

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

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

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

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

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

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

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

เก็บสิ่งนี้เป็น download_video.py มันยอมรับ ID วิดีโอหรือ URL watch/Shorts/live/embed และปฏิเสธ playlist/channel input. การเรียกเก็บข้อมูลแต่ละครั้งใช้ตัวอย่าง YoutubeDL, การดาวน์โหลดที่ จํากัด และไฟล์เก็บข้อมูลในสถานที่ ไฟล์ที่สมบูรณ์แบบที่ซ้ํากันจะถูกส่งกลับโดยไม่ให้การคิดว่าไฟล์ใหม่ถูกสร้างขึ้น

download_video.py
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 งาน
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

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

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

download_batch.py
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 ที่เสร็จสมบูรณ์ผ่านการทํางาน
การทํางานหรือรีไซเคิลชุดเดียวกัน
python download_batch.py urls.txt --output collection

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

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

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

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

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

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

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

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

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

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