เรียกดูเอกสาร
คู่มือ
ตัวอย่าง Python ที่รันได้สำหรับการดาวน์โหลด เมทาดาทา ชุดข้อมูล AI และงานที่ทำต่อได้หลังหยุดชะงัก
ในหน้านี้
ติดตั้งห้องสมุด Python
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"])การตั้งค่า 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))
ตารางที่สกัดอาจไม่มีหรือไม่มี ใช้ Get() สําหรับข้อมูล metadata ตัวเลือกและไม่คิดว่าแหล่งแต่ละแหล่งมีระยะเวลา ID ช่องหรือรายการรูปแบบที่สมบูรณ์ รายการรายการรายการแบบแบนยังแตกต่างจากวิดีโอที่ละเอียดเต็ม สําหรับการตอบสนองสาธารณะโปรเจคเพียงฟิลด์ที่คุณวางแผนที่จะแสดง
หลีกเลี่ยงการสกัดข้อมูลโดยตรงตามการสกัดดาวน์โหลดที่เหมือนกันสําหรับแต่ละแหล่งข้อมูลหากแอพของคุณไม่ต้องการขั้นตอนการวางแผนเพิ่มเติม มัน duplicates คําขอแหล่งข้อมูล หากคุณต้องการงานที่ทนทานให้เก็บรหัสแหล่งข้อมูลและนโยบายการออก; URL ของสื่อที่ลงชื่อจากข้อมูลโลหะไม่ได้เป็นการแทนที่ที่ที่ทนทานสําหรับแหล่งข้อมูลเดิม
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" | ใช้ใบรับรองการประชุมส่วนตัวเท่านั้นเมื่อจําเป็นสําหรับการเข้าถึง |
audio_options = {
"format": "ba",
"outtmpl": "audio/%(id)s.%(ext)s",
"postprocessors": [{
"key": "FFmpegExtractAudio",
"preferredcodec": "mp3",
"preferredquality": "192",
}],
}วิดีโอ + เสียง + captions สําหรับ AI ไฟล์
ใช้นโยบายการออกนี้เมื่อเป้าหมายคือชุดข้อมูลการฝึกอบรมแทนที่จะเก็บรวบรวมตัวอย่างของ 1080p มันต้องการ bestvideo และ bestaudio ให้ FFmpeg ผสมพวกเขาใน MP4 และบันทึก captions และ metadata อังกฤษที่มีอยู่นอกเหนือจากสื่อ
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])
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 สําหรับการเตรียมสื่อแล้วยืนยันข้อความและข้อมูลโลหะก่อนที่จะเผยแพร่รายการชุดข้อมูลเต็ม
เรียนรู้เมื่อไฟล์สุดท้ายพร้อม
โครงการรายงานโหมด = สิ้นสุดหมายความการถ่ายโอนเสร็จสิ้น FFmpeg อาจยังคงต้องผสมวิดีโอและเสียงแปลงไฟล์เสียงหรือย้ายผลผลิต การส่งผ่านวิดีโอเพียงแค่ 100% ไม่เป็นเหตุการณ์การเสร็จสิ้นที่แอพพลิเคชันของคุณควรเผยแพร่
| เวที | สิ่งที่คุณรู้ | ใบสมัครรัฐ |
|---|---|---|
| ดาวน์โหลด | บางไบต์สื่อมาถึง | การทํางาน |
| โพสต์: หมดอายุ | การถ่ายโอนนี้เสร็จสิ้นการประมวลผลยังคงสามารถดําเนินการได้ | การประมวลผล |
| after_move โพสต์โปรเซสเซอร์ | ไฟล์ได้ผ่านการกําหนดค่าหลังการประมวลผลและขั้นตอนสุดท้าย | ไฟล์ในท้องถิ่นพร้อม |
| การตรวจสอบอัปโหลดและความสมบูรณ์ | จุดหมายปลายทางของคุณมีวัตถุและการตรวจสอบที่บันทึกไว้ | จัดส่ง |
ตัวอย่างที่สมบูรณ์ด้านล่างบันทึก PostProcessor ที่กําหนดเองใน after_move และอ่าน info["filepath"] ที่นี่ ตรวจสอบว่าไฟล์นั้นมีอยู่และไม่มีการเปิดใช้งาน นี่จะหลีกเลี่ยงการคาดการณ์การขยายตัวสุดท้ายด้วย prepare_filename(), ซึ่งสามารถอ้างถึงชื่อก่อนการแปลง
สภาพยนตร์เต็มรูปแบบ: คนงานวิดีโอเดียว
เก็บสิ่งนี้เป็น download_video.py มันยอมรับ ID วิดีโอหรือ URL watch/Shorts/live/embed และปฏิเสธ playlist/channel input. การเรียกเก็บข้อมูลแต่ละครั้งใช้ตัวอย่าง YoutubeDL, การดาวน์โหลดที่ จํากัด และไฟล์เก็บข้อมูลในสถานที่ ไฟล์ที่สมบูรณ์แบบที่ซ้ํากันจะถูกส่งกลับโดยไม่ให้การคิดว่าไฟล์ใหม่ถูกสร้างขึ้น
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))
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 เมื่อรายการใด ๆ ไม่ได้ล้มเหลว
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)
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 การสมัครของคุณส่งการตั้งค่าแหล่งและผลผลิตแล้วเก็บรหัสการทํางานและบันทึกการจัดส่ง