yt-dlp बतौर API: embed करना, self-host REST wrapper, या hosted service

लेखक Tunelio टीम·प्रकाशित 7 सित॰ 2026

yt-dlp का कोई official REST API नहीं है — yt-dlp एक library और CLI है। इसे HTTP पर बुलाने के लिए या तो अपने service में embed करें, community wrapper में से कोई deploy करें, या ऐसा hosted API लें जो extraction fleet आपके लिए चलाए। यह गाइड न्यूनतम self-hosted wrapper दिखाती है, बड़े पैमाने पर उसकी असली लागत (CPU, IP reputation, टूटना, bandwidth), और build बनाम buy का ईमानदार नियम।

विकल्प 1: yt-dlp को अपने code में embed करें

आपका application Python में है तो yt_dlp import करके extract_info सीधे बुलाएँ — कोई HTTP hop नहीं, कोई दूसरा service नहीं। Python गाइड options, hooks, error handling और async के पेंच cover करती है। script, internal tools और single-tenant app के लिए यही सही जवाब है।

विकल्प 2: self-host REST wrapper

wrapper yt-dlp को non-Python code, bot और अन्य services के लिए खोलता है। न्यूनतम काम करने वाला version कुछ दर्जन लाइनें है:

# app.py — न्यूनतम yt-dlp REST wrapper (FastAPI)
import asyncio, yt_dlp
from fastapi import FastAPI, HTTPException, Query

app = FastAPI()
SEM = asyncio.Semaphore(4)                 # हर extraction ≈ 1 s CPU; सीमित रखें

def extract(url: str, fmt: str) -> dict:
    opts = {"quiet": True, "skip_download": True, "format": fmt, "noplaylist": True,
            "source_address": "0.0.0.0"}   # IPv4
    with yt_dlp.YoutubeDL(opts) as ydl:
        return ydl.extract_info(url, download=False)

@app.get("/info")
async def info(url: str = Query(...)):
    try:
        async with SEM:
            i = await asyncio.to_thread(extract, url, "b")
    except yt_dlp.utils.DownloadError as e:
        raise HTTPException(status_code=502, detail=str(e)[:200])
    return {"id": i["id"], "title": i["title"], "duration": i["duration"],
            "formats": [{"id": f["format_id"], "height": f.get("height"), "ext": f["ext"]}
                        for f in i["formats"] if f.get("vcodec") != "none" and f.get("acodec") != "none"]}

@app.get("/url")
async def direct_url(url: str, quality: int = 720):
    async with SEM:
        i = await asyncio.to_thread(extract, url, f"b[height<={quality}]")
    return {"url": i["url"], "expires_in_hours": 6}   # इसी सर्वर के IP के लिए signed

इसे Python गाइड वाले Docker image (yt-dlp + ffmpeg + Deno) में nginx के पीछे uvicorn से चलाएँ। yt-dlp-web-ui, MeTube और तरह-तरह के “yt-dlp server” image जैसे community project UI और queue के साथ यही करते हैं; वे नीचे की हर सीमा विरासत में लेते हैं।

wrapper क्या हल नहीं करता

लौटाया URL आपके सर्वर से बंधा है

googlevideo link request करने वाले IP और client के लिए signed हैं और लगभग छह घंटे में expire होते हैं। दूसरे network पर end users को देने से 403 मिलता है; असली design media को अपने सर्वर से stream करना (bandwidth ×2) या download करके फिर serve करना (disk + bandwidth) है। hosted API इसी हिस्से को “tunnel” कहते हैं।

merge और audio को हर request पर ffmpeg चाहिए

720p से ऊपर सब कुछ अलग video और audio stream है; MP3 transcode है। दोनों हर download पर आपकी मशीन का ffmpeg CPU हैं (ffmpeg गाइड)।

प्रति extraction CPU

हमारे fleet पर एक YouTube extraction लगभग 1.2–1.3 सेकंड CPU लेता है, ज़्यादातर player JavaScript evaluate करने में, और यह हर request पर देना पड़ता है। दस request प्रति सेकंड यानी media का एक byte भी serve करने से पहले दर्जन भर core। bursts झेलने के लिए extraction results को प्रति वीडियो कुछ घंटे cache करें।

IP reputation असली छत है

एक datacenter पते से रोज़ सैकड़ों वीडियो निकालने वाला सर्वर “Sign in to confirm you’re not a bot” और media 403 से टकराता है — हमारे माप में लगभग हर चौथा नया datacenter exit पहले संपर्क में challenge पाता है, और IPv6 इसे बदतर करता है। online रहने का मतलब residential proxy, sticky session, PO-token minting और cookie rotation है (proxy, cookies और 403 गाइड)। यही वह operational लागत है जिसे लोग सबसे ज़्यादा कम आँकते हैं।

टूटना

YouTube हर कुछ हफ़्तों में कुछ बदलता है; हर बदलाव yt-dlp अपडेट और redeploy है, आमतौर पर outage से पता चलता है (update गाइड)। on-call का budget रखें।

विकल्प 3: hosted YouTube download API

curl "https://tunelio.dev/create?url=https://youtu.be/dQw4w9WgXcQ&quality=720p" \
  -H "Authorization: Bearer tnl_your_api_key"
# → { "url": "https://…/tunnel?id=…&sig=…", "file_size_str": "28.52 MB", "status": "ok" }

hosted API = ऊपर का wrapper + fleet + tunnel: एक request signed download URL लौटाता है जिसे आप सीधे user, bot या S3 upload को दे सकते हैं, और extraction, ffmpeg, IP rotation व YouTube के बदलाव सर्वर-साइड संभलते हैं। Tunelio हमारी अपनी सेवा है, तुलना इसी ध्यान से पढ़ें; आँकड़े वही हैं जिनके साथ हम जीते हैं।

Build बनाम buy — ईमानदार तालिका

• एक मशीन से रोज़ ~50 वीडियो से कम, निजी या internal उपयोग → embed या self-host; free tools काफ़ी हैं और आप stack सीखते हैं।
• product feature (bot, SaaS, pipeline) ऐसे users के साथ जिन्हें आप control नहीं करते → आमतौर पर hosted API जीतता है: अकेला proxy बिल अक्सर API बिल से ज़्यादा होता है, और on-call आपका नहीं।
• सख़्त data-residency या air-gapped ज़रूरतें → self-host, पर residential exit और एक maintainer की योजना बनाएँ।
• YouTube के अलावा साइटें → yt-dlp की पहुँच बेजोड़ है; hosted API आमतौर पर YouTube-first होते हैं।
• एक ही contract से transcript, metadata और media चाहिए → hosted (Tunelio एक key पर /info, /create और /transcript देता है)।

क़ीमत की sanity check

self-hosting तब तक free दिखता है जब तक हिस्से न जोड़ें: कुछ core वाला VPS, per GB बिल वाला residential proxy plan (वीडियो का हर byte उससे गुज़रता है), सुबह 3 बजे yt-dlp अपडेट करने वाला कोई, और outage में खोए users। hosted क़ीमत प्रति request है: Tunelio /info या /transcript के 6 credits और /create के 10 credits लेता है, signup पर 100 free credits, paid plan $9 प्रति माह से 100,000 credits के साथ। चुनने से पहले अपने volume पर हिसाब लगाएँ।

स्रोत

• yt-dlp README — “Embedding yt-dlp”, network और format options।
• community wrapper — reference implementation के लिए yt-dlp-web-ui, MeTube (GitHub)।
• हमारे अपने माप (Tunelio extraction fleet, 2026): प्रति extraction CPU, datacenter IP पर पहले संपर्क की challenge दर, प्रति extraction proxy bytes।