# API Python yt-dlp

Contoh Python yang boleh dijalankan untuk muat turun, metadata, set data AI dan tugasan yang boleh disambung.

Referensi boonical: https://flashdata.dev/ms/docs/guides/yt-dlp-python-api
Diulas: 2026-11-13 oleh FlashData

- [Mulakan dengan Python](https://flashdata.dev/ms/docs/guides/yt-dlp-python-api/reference.md#first-call) — Menerapkan dan membuat satu panggilan
- [Cari fail akhir](https://flashdata.dev/ms/docs/guides/yt-dlp-python-api/reference.md#completion) — Selepas pemindahan dan pemprosesan
- [Dapatkan Pekerja](https://flashdata.dev/ms/docs/guides/yt-dlp-python-api/reference.md#worker) — Perkhidmatan .py download
- [Menguruskan satu koleksi](https://flashdata.dev/ms/docs/guides/yt-dlp-python-api/reference.md#batch) — Per sumber hasil dan pemulihan

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

## Menerapkan perpustakaan Python


**Dalam persekitaran Python 3.11+ anda**

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

**Tetapi anda juga boleh memasang Deno, FFmpeg dan ffprobe.** Contoh-contoh ini berjalan secara tempatan pada Linux, macOS atau Windows dan tidak memerlukan kunci API.

- [Menetapkan ketergantungan luaran](https://flashdata.dev/ms/docs/guides/how-to-use-yt-dlp/reference.md#install)
- [Upstream merujuk kepada](https://github.com/yt-dlp/yt-dlp#embedding-yt-dlp)

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

## Download video pertama anda


**Download 1 video**

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

Ini menulis media tempatan sehingga 1080p dan boleh menggabungkan aliran berasingan. bekas output bergantung kepada format sumber yang dipilih.

**Set CLI tidak diwarisi.** Set Deno, impersonasi dan pacing dalam pilihan Python, walaupun perintah terminal anda sudah menggunakannya.

download() mengambil senarai URL dan mengembalikan kod status. extract_info(url, download=True) mengembalikan maklumat pengekstrakan serta menjalankan muat turun. Gunakan pengurus konteks untuk menutup contoh dengan bersih, dan mewujudkan contoh baru untuk pekerjaan bebas daripada berkongsi keadaan yang berubah-ubah di seluruh tali.

> **Pilihan Python bukan terjemahan mekanikal bendera**
> --write-info-json peta untuk menulis infojson; --no-playlist peta untuk noplaylist. Audio Conversion menggunakan senarai postprocessor. Lihat dokumen parameter YoutubeDL atau pembantu upstream cli_to_api.py daripada meneka nama opsyen.

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

## Membaca Metadata Tanpa Media


**Mengeksport rekod metadata kecil**

```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 masih menjalankan permintaan rangkaian. sanitize_info menjadikan hasil JSON-kompatibel; ia tidak menulis rahsia atau mengurangkan hasil kepada medan ini.

Lapangan yang dikeluarkan boleh tidak ada atau nol. Gunakan get() untuk metadata pilihan, dan jangan menganggap setiap sumber mempunyai tempoh, ID saluran atau senarai format lengkap. Senarai senarai main rata juga berbeza daripada video yang diselesaikan sepenuhnya. Untuk jawapan awam, projek hanya medan yang anda berhasrat untuk mendedahkan.

Elakkan pengekstrakan metadata dengan serta-merta diikuti oleh pengekstrakan muat turun yang sama untuk setiap sumber kecuali aplikasi anda memerlukan langkah perancangan tambahan. Ia menggandakan permintaan sumber. Jika anda memerlukan pekerjaan yang berterusan, simpan ID sumber dan dasar output; URL media yang ditandatangani daripada metadata tidak merupakan pengganti yang berterusan untuk sumber asal.

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

## Python Pilihan Perbincangan


| Tugasan | Pilihan Python | Detail |
| --- | --- | --- |
| Pengeluaran direktori dan nama filen | "outtmpl": "downloads/%(id)s.%(ext)s" | Simpan ID sumber dan ekstensi dinamik. |
| Reka bentuk 1080p | "format": "bv*[height<=1080]+ba/b[height<=1080]" | Membolehkan kodek sumber dan gagal jika tiada yang sepadan dengan had. |
| Metadata sidecar | "writeinfojson": True | Mengikat metadata pengekstrakan penuh di samping media. |
| Titik pemeriksaan ID lengkap | "download_archive": "archive.txt" | Satu arkib per dasar pengeluaran; bukan inventori cek. |
| Kesilapan yang ketat | "ignoreerrors": False | Biarkan panggilan rekod kegagalan daripada merawat masalah selepas pemprosesan sebagai kejayaan. |
| Perbincangan Runtime | "js_runtimes": {"deno": {}} | Pemasang Deno dalam pekerja dan membuat binari yang kelihatan pada PATH. |
| Pengenalan kepada browser | "impersonate": ImpersonateTarget() | Python setara dengan --impersonate=""; import kelas sasaran dan memasang curl-cffi. |
| fail cookie yang sedia ada | "cookiefile": "private/youtube-cookies.txt" | Gunakan pengesahan sesi peribadi hanya apabila diperlukan untuk akses. |

**MP3 Pilihan Konversi**

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

audio_options masuk ke YoutubeDL. FFmpeg post-processor menukar kepada bit tarikan 192 kbps; ia tidak meningkatkan kualiti asal sumber.

- [Perbezaan parameter Python](https://github.com/yt-dlp/yt-dlp/blob/master/yt_dlp/YoutubeDL.py)
- [Menukar pilihan CLI kepada pilihan Python](https://github.com/yt-dlp/yt-dlp/blob/master/devscripts/cli_to_api.py)

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

## Video + audio + captions untuk set data AI


Gunakan dasar output ini apabila matlamatnya ialah set data latihan daripada koleksi contoh pekerja 1080p. ia memerlukan bestvideo dan bestaudio, membolehkan FFmpeg menggabungkan mereka ke dalam MP4, dan menyimpan captions Bahasa Inggeris dan metadata yang tersedia di samping media.

**Satu item set data dalam 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])
```

Ia memerlukan FFmpeg/ffprobe, Deno dan pemasangan malam [default,curl-cffi] parameter format kegemaran remuxer dipaparkan dengan cara itu dalam API yt-dlp.

ImpersonateTarget() memilih mana-mana sasaran pelayar yang tersedia, yang sepadan dengan --impersonate="". Lulus objek, bukan string kosong yang disalin daripada sintax CLI. curl-cffi mesti dipasang dalam persekitaran Python ini. Deno masih menjalankan penyelesaian JavaScript; impersonasi tidak menggantikannya.

MP4 ialah bekas output; video yang dipilih masih boleh menjadi AV1 atau VP9. Jika dekoder latihan anda memerlukan H.264/AAC, gunakan dasar kodek yang jelas sebelum menggabungkan atau mencatat transcode FFmpeg yang berasingan. Subtitle yang tersedia diambil, tidak dihasilkan daripada ucapan.

| Selepas media selesai | Apa yang diperlukan rekod data |
| --- | --- |
| Lihatlah yang terakhir MP4 dengan ffprobe | Video/audio kodek, tempoh, dimensi, laluan fail dan bilangan byte. |
| Periksa rakaman sampingan secara berasingan | Bahasa, supplied/automatic trek, jam dan sama ada fail itu sebenarnya wujud. |
| Tiada captions yang sesuai tersedia | Simpan media dan menandakan teks hilang; hantar audio ke peringkat transcription anda jika perlu. |
| Perbincangan:Kejadian yang berlaku 429 | Retry caption retrieval selepas IP sejuk dengan subtitle pacing; jangan muat turun semula media yang selesai. |

Untuk satu set, gunakan arkib berasingan untuk dasar set data ini dan simpan inventori untuk halaman yang diperlukan. Jangan gunakan semula 1080p atau media-hanya arkib: ia boleh melumpuhkan video sebelum capsi yang baru dikehendaki mereka dikumpulkan. Gunakan after_move untuk kesediaan media, kemudian mengesahkan teks dan metadata sebelum menerbitkan item set data lengkap.

- [CLI Resipi dan Data Set Inventory](https://flashdata.dev/ms/docs/guides/how-to-use-yt-dlp/reference.md#dataset)
- [Pace Python Metadata dan Captions](https://flashdata.dev/ms/docs/guides/yt-dlp-429-too-many-requests/reference.md#python)

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

## Ketahui bila fail akhir telah siap


Status = selesai bermakna pemindahan selesai. FFmpeg masih boleh perlu untuk menggabungkan video dan audio, menukar fail audio, atau memindahkan output. Sebuah video-hanya streaming mencapai 100% bukan peristiwa penyelesaian yang permohonan anda perlu menerbitkan.

| Tahapan | Apa yang anda tahu | Negara Permohonan |
| --- | --- | --- |
| Download | Sebahagian daripada media bajet telah tiba. | Berlari |
| Penghantaran HOK : selesai | Pemindahan ini telah selesai; pemprosesan masih boleh diikuti. | Pemprosesan |
| after_move Pengurusan Post-Prosessor | Fail telah lulus langkah selepas pemprosesan yang dikonfigurasi dan akhir. | fail tempatan siap |
| Upload dan Integrity Check | Destinasi anda mempunyai objek dan pengesahan yang direkodkan. | diserahkan |

Contoh lengkap di bawah mencatat PostProcessor tersuai pada after_move dan membaca info["filepath"] di sana. Ia memeriksa bahawa fail itu wujud dan tidak terhingga. Ini mengelakkan meneka perpanjangan akhir dengan prepare_filename(), yang boleh merujuk kepada nama pra-konversi.

> **Sebuah muat turun tempatan yang selesai bukanlah penghantaran awan yang selesai**
> Jika langkah seterusnya memuat naik fail, simpan status muat naik secara berasingan. arkib muat turun boleh melarikan diri daripada sumber pada laluan seterusnya walaupun apabila muat naik terdahulu gagal.

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

## Skenario lengkap: pekerja video tunggal


Simpan ini sebagai download_video.py. Ia menerima ID video atau watch/Shorts/live/embed URL dan menolak input playlist/channel. Setiap panggilan menggunakan satu contoh YoutubeDL, retries download terhad dan arkib koleksi-lokal. Kembali sumber yang berulang-ulang selesai dikembalikan terlepas daripada berpura-pura fail baru telah dicipta.

- [Download untuk 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))
```

Skrip penuh juga boleh didapati dari pautan muat turun di atas. ia hanya mempunyai output tempatan; menambah pemeriksaan decoding dan rekod muat naik pada peringkat seterusnya dalam aplikasi anda.

**Berjalan satu kerja**

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

Rekod yang disiapkan mengandungi URL sumber kanonik, ID video, laluan akhir dan saiz byte. Rekod yang terlepas bermakna tiada panggilan balik fail akhir baru berjalan; menyelaraskannya terhadap arkib dan inventori sedia ada jika anda memerlukan bukti fail masih hadir. Arkib itu sendiri tidak memeriksa sama ada pengguna kemudian memadam atau memindahkan media.

Catch DownloadError untuk kegagalan extractor/download/post-processing, ValueError untuk input yang ditolak dan OSError untuk kegagalan sistem fail tempatan. Memperlakukan ini sebagai kelas yang berbeza dalam log permohonan anda. Mesej ralat adalah diagnosis yang berguna, tetapi teks mereka tidak merupakan taksonomi yang berstruktur yang stabil bagi setiap kegagalan YouTube.

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

## Skenario lengkap: Pekerja batch yang boleh dikembalikan


Masukkan download_batch.py di sebelah download_video.py. Mencipta UTF-8 urls.txt dengan satu URL video atau ID per baris. Ini sengaja berjalan secara berurutan, jadi satu proses dimiliki oleh direktori arkib dan output. Ia menulis hasil yang selesai, terlepas atau gagal untuk setiap percubaan input dan outs nonzero apabila mana-mana item gagal.

- [Muat turun 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)
```

Lampiran-hanya attempts.jsonl mengekalkan retries sebagai percubaan berasingan. garis duplikat dalam manifest dihapuskan; arkib muat turun mengendalikan ID selesai melalui lintasan.

**Berjalan atau mengembalikan batch yang sama**

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

Flush selepas setiap rekod supaya satu gangguan tidak meninggalkan setiap hasil buffer sehingga akhir. Terdapat tetingkap kecil antara perpustakaan yang merekodkan arkibnya dan aplikasi anda menulis rekod percubaan. Sekiranya kemalangan melanda di sana, pusingan seterusnya boleh melaporkan terlepas. Untuk perkhidmatan, menyelaraskan filesystem/archive dengan pangkalan kerja yang berterusan daripada menuntut contoh fail teks ini adalah transaksional.

Tetap attempts.jsonl peribadi: kesilapan boleh termasuk sumber dan permintaan butiran. melaporkan jumlah mengikut status, memeriksa item yang gagal, dan memainkan semula manifest yang sama selepas menyelesaikan masalah persekitaran yang dikongsi. Jangan menambah setiap ID yang gagal ke arkib kejayaan.

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

## Pengeluaran: kue, tarikh dan penyimpanan


YoutubeDl boleh disegerakkan. Melancarkannya secara langsung di dalam blok pengedar web async yang menghalang peristiwa pengedar; walaupun thread offload tidak membuat permintaan pelayar seumur hidup yang sesuai untuk muat turun besar. Mengambil pekerjaan, berterusan source/options, dan membiarkan pekerja menghasilkan hasil akhir.

- Mencipta ID kerja yang tahan lama sebelum pelaksanaan. menyimpan ID video kanonik, dasar output, nombor percubaan dan destinasi.
- Gunakan direktori kerja per pekerjaan dan kolam pekerja terhad.Jangan berkongsi contoh YoutubeDL di antara pekerjaan yang sama.
- Gunakan proses yang berasingan apabila anda memerlukan tarikh akhir jam dinding keras atau pembatalan; socket_timeout mengehadkan operasi rangkaian individu, bukan keseluruhan kerja.
- Jika anda mendedahkan input pengguna di atas HTTP, menerima pengenalpastian video YouTube yang disokong daripada URL arbitrary, laluan output, argumen ekstraktor atau snippets shell.
- Mencatat kesediaan fail tempatan dan penyelesaian muat naik awan secara berasingan; mengekalkan keadaan yang mencukupi untuk menarik balik muat naik tanpa muat turun lagi.
- Simpan FFmpeg, masa berjalan, yt-dlp dan versi plugin dengan pelancaran anda. Latihan beban kerja kecil yang diketahui sebelum menggantikan imej pekerja.

Sebuah kolam pekerja yang mudah adalah titik permulaan yang lebih baik daripada asyncio.gather panggilan tanpa had di sekitar banyak muat turun. Mengkoordinasi kerja keseluruhan di seluruh proses; tetapan tidur setiap pemutar tidak mengawal keseluruhan perkhidmatan. Tetapkan bajet penarikan berasingan untuk percubaan kerja supaya penarikan permohonan tidak berkali-kali jumlah penarikan sendiri pemuat turun.

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

## Menyelesaikan masalah pekerja Python


| Masalah | Periksa |
| --- | --- |
| Kegagalan dalam CLI, kegagalan dalam Python | Bandingkan pilihan sebenar. YoutubeDL tidak secara automatik memuat naik fail konfigurasi CLI anda. |
| Perkembangan kata selesai, fail hilang | Gunakan sempadan after_move dan semak kesilapan selepas pemprosesan. |
| Kembali Kembali Kembali Kembali Kembali Kembali | Baca arkib koleksi; gunakan arkib yang berbeza apabila mengubah dasar output. |
| Pekerja tergantung lebih lama daripada socket_timeout | Satu kerja boleh melakukan banyak operations/retries. Tambah tempoh tahap proses jika perlu. |
| 403 atau bot memeriksa pada pelayan | Update malam, semak Deno, mengurangkan persaingan dan menguji IP output pengganti apabila laluan masih ditolak. |
| 429 dalam kerja-kerja metadata / transcript | Berhenti IP yang terjejas, permintaan kelajuan extraction/subtitle dan menambah keterlambatan antara metadata-hanya pekerjaan. |

- [403 Diagnosis aliran kerja](https://flashdata.dev/ms/docs/guides/yt-dlp-403-forbidden/reference.md)
- [Sesi dan aliran kerja bot-check](https://flashdata.dev/ms/docs/guides/yt-dlp-sign-in-not-a-bot/reference.md)
- [429 pemulihan dan Python pacing](https://flashdata.dev/ms/docs/guides/yt-dlp-429-too-many-requests/reference.md)
- [Periksa media yang diselamatkan](https://flashdata.dev/ms/docs/guides/how-to-use-yt-dlp/reference.md#verify)

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

## Apabila pengeluaran tergolong dalam saluran awan


Jika anda ingin mempunyai pemuat turun, aliran kerja di atas memberi anda kawalan fail, format dan pemprosesan. Jika aplikasi anda memerlukan media lengkap yang disimpan, FlashData menyediakan pekerjaan muat turun YouTube yang dipantau, pengendalian bot, routing proxy dan penarikan. Permohonan anda mengemukakan tetapan sumber dan output, kemudian menyimpan ID pekerjaan dan rekod penghantaran.

- [Perbandingan kedua-dua model operasi](https://flashdata.dev/ms/docs/guides/flashdata-vs-yt-dlp/reference.md)
- [Muat turun video YouTube secara pukal](https://flashdata.dev/ms/products/youtube-download#bulk-downloads)
- [Cuba download demo](https://flashdata.dev/ms/products/youtube-download#playground)
- [Download rujukan API](https://flashdata.dev/ms/docs/sources/youtube_download/reference.md)
