सीधे सामग्री पर जाएँ
HI
API कुंजी प्राप्त करें
दस्तावेज़ देखें

API संदर्भ

Bulk प्रोसेसिंग API

फ़ाइल-आधारित YouTube नौकरियों को बनाएं और नियंत्रित करें, फिर अपने प्रकटन और परिणाम भागों को पुनः प्राप्त करें।

इस पेज पर

API प्लेग्राउंड

एक स्रोत चुनें और एक पूर्ण Python या Bash वर्कफ़्लो, एक एकल अनुरोध, या नमूना प्रतिक्रिया की प्रतिलिपि बनाएँ। खेल का मैदान पूर्वावलोकन कोड; यह एक नौकरी जमा नहीं करता है। पूर्ण कार्यप्रवाह हर परिणाम भाग के अपलोड, स्टेटस चेक और पुनर्प्राप्ति को संभालते हैं।

स्रोत पैरामीटर

Bulk वर्कफ़्लो बनाएँ

स्थानीय UTF-8 फ़ाइल, एक YouTube ID प्रति लाइन, 2 GiB तक। सम्पर्क करने का विवरण.

एन-ऑर्गिज़ की कोशिश करने के लिए खाली छोड़ दें, फिर एन, और एक ट्रैक वापस लौटें। या एक कोड दर्ज करें या कमाओ द्वारा अलग किए गए 10 विशिष्ट कोड तक।

कैप्शन ट्रैक auto

परिणाम वितरण

इसे बंद करें परिणाम FlashData API के माध्यम से प्राप्त करें।

Bulk पूरा होने वाला वेबहुकमैनिफेस्ट-कॉम्पलेशन अधिसूचना और सत्यापन
POSThttps://api.flashdata.dev/v2/bulk-jobs
Python 3 · standard library
import gzip
import json
import os
from pathlib import Path
import random
import re
import shutil
import time
import urllib.error
import urllib.parse
import urllib.request

api_key = "YOUR_API_KEY"
api_url = "https://api.flashdata.dev/v2"
input_file = Path("video-ids.txt")
output_dir = Path("bulk-results")
bulk_id = ""  # Paste a saved Bulk ID to monitor/retrieve it without submitting again.
poll_timeout_seconds = 1800
payload = {
    "source": "youtube_captions",
    "options": {
        "auto": False,
    },
}

class NoRedirect(urllib.request.HTTPRedirectHandler):
    def redirect_request(self, req, fp, code, msg, headers, newurl):
        return None

opener = urllib.request.build_opener(NoRedirect())
os.umask(0o077)

def api(path, method="GET", body=None):
    data = None if body is None else json.dumps(body).encode("utf-8")
    headers = {"X-API-Key": api_key, "Content-Type": "application/json"}
    for attempt in range(5):
        try:
            request = urllib.request.Request(api_url + path, data=data, headers=headers, method=method)
            with opener.open(request, timeout=60) as response:
                return json.load(response)
        except urllib.error.HTTPError as error:
            if method != "GET" or error.code not in (429, 502, 503, 504) or attempt == 4:
                raise
            retry_after = error.headers.get("Retry-After", "")
            delay = min(120, int(retry_after)) if retry_after.isdigit() else 2 ** attempt
            time.sleep(delay + random.random())

def result_location(path):
    request = urllib.request.Request(api_url + path, headers={"X-API-Key": api_key})
    try:
        with opener.open(request, timeout=60):
            raise RuntimeError("Expected a 302 result redirect")
    except urllib.error.HTTPError as error:
        if error.code != 302:
            raise
        location = error.headers.get("Location", "")
    parsed = urllib.parse.urlsplit(location)
    if parsed.scheme != urllib.parse.urlsplit(api_url).scheme or not parsed.hostname or parsed.username or parsed.password:
        raise RuntimeError("Invalid signed storage URL")
    return location

if not bulk_id:
    if not input_file.is_file() or not 1 <= input_file.stat().st_size <= 2147483648:
        raise ValueError("Use a nonempty UTF-8 ID file up to 2 GiB")
    created = api("/bulk-jobs", "POST", payload)
    bulk_id = created["job"]["id"]
    if not re.fullmatch(r"bulk_[A-Za-z0-9_-]{8,}", bulk_id):
        raise RuntimeError("Invalid Bulk ID")
    work = output_dir / bulk_id
    work.mkdir(parents=True, exist_ok=True)
    (work / "created.json").write_text(json.dumps(created, indent=2))
    print("Saved Bulk ID:", bulk_id, flush=True)
    upload = created["upload"]
    upload_url = urllib.parse.urlsplit(upload["href"])
    if upload["method"] != "PUT" or upload_url.scheme != urllib.parse.urlsplit(api_url).scheme or not upload_url.hostname or upload_url.username or upload_url.password:
        raise RuntimeError("Invalid signed upload URL")
    with input_file.open("rb") as file:
        request = urllib.request.Request(upload["href"], data=file, method="PUT", headers={
            "Content-Type": upload["contentType"], "Content-Length": str(input_file.stat().st_size)
        })
        with opener.open(request, timeout=120) as response:
            response.read()
    api("/bulk-jobs/" + bulk_id + "/start", "POST")

if not re.fullmatch(r"bulk_[A-Za-z0-9_-]{8,}", bulk_id):
    raise ValueError("Invalid Bulk ID")
work = output_dir / bulk_id
work.mkdir(parents=True, exist_ok=True)
deadline = time.monotonic() + poll_timeout_seconds
while True:
    job = api("/bulk-jobs/" + bulk_id)["job"]
    (work / "status.json").write_text(json.dumps(job, indent=2))
    print(job["status"], job["input"], job["counts"], flush=True)
    if job["status"] == "completed":
        break
    if job["status"] in ("paused", "failed", "cancelled", "awaiting_upload"):
        raise RuntimeError(json.dumps({"id": bulk_id, "status": job["status"], "pauseReason": job.get("pauseReason"), "error": job.get("error")}))
    if time.monotonic() >= deadline:
        raise TimeoutError("Job still running. Set bulk_id to " + bulk_id + " and rerun to continue monitoring.")
    time.sleep(10 + random.random())

manifest_url = result_location("/bulk-jobs/" + bulk_id + "/results")
with opener.open(manifest_url, timeout=60) as response:  # No API key sent to storage.
    manifest = json.load(response)
(work / "manifest.json").write_text(json.dumps(manifest, indent=2))
for part in manifest["parts"]:
    number = part["number"]
    if type(number) is not int or number < 1:
        raise RuntimeError("Invalid part number")
    path = "/bulk-jobs/" + bulk_id + "/results/" + str(number)
    if part["href"] != api_url + path:
        raise RuntimeError("Unexpected part API URL")
    storage_url = result_location(path)
    compressed = work / ("part-" + str(number) + ".jsonl.gz")
    with opener.open(storage_url, timeout=120) as response, compressed.open("wb") as file:
        shutil.copyfileobj(response, file, 1024 * 1024)
    with compressed.open("rb") as file:
        gzipped = file.read(2) == b"\x1f\x8b"
    reader = gzip.open(compressed, "rb") if gzipped else compressed.open("rb")
    with reader, (work / ("part-" + str(number) + ".jsonl")).open("wb") as file:
        shutil.copyfileobj(reader, file, 1024 * 1024)
print("Saved manifest and decoded NDJSON parts in", work)
सभी भागों को बनाएं, अपलोड करें, शुरू करें, मॉनिटर करें और पुनर्प्राप्त करेंX-API-Key प्रमाणीकरण

समापन बिंदु

सभी समापन बिंदुओं का उपयोग https://api.flashdata.dev/v2. एक नौकरी बनाएं → एक वीडियो-ID फ़ाइल अपलोड करें → शुरू → मॉनिटर → प्रकट होने और हर परिणाम का हिस्सा पुनर्प्राप्त करें।

विधिपथकार्रवाई
POST/v2/bulk-jobsएक Bulk नौकरी बनाएँ
POST/v2/bulk-jobs/{bulkId}/startअपलोड और शुरू
GET/v2/bulk-jobs/{bulkId}नौकरी की स्थिति प्राप्त करें
GET/v2/bulk-jobsसूची नौकरियां
POST/v2/bulk-jobs/{bulkId}/pauseएक नौकरी
PATCH/v2/bulk-jobs/{bulkId}नौकरी के विकल्प अद्यतन करें
POST/v2/bulk-jobs/{bulkId}/resumeनौकरी फिर से शुरू करें
DELETE/v2/bulk-jobs/{bulkId}नौकरी रद्द करना
GET/v2/bulk-jobs/{bulkId}/resultsपरिणाम प्रकट हो जाओ
GET/v2/bulk-jobs/{bulkId}/results/{partNumber}परिणाम भागों डाउनलोड करें

प्रमाणीकरण और इनपुट

चयनित स्रोत तक पहुंच के साथ एक कुंजी के लिए FLASHDATA_API_KEY सेट करें। निर्माण, नियंत्रण और परिणाम के लिए उसी कुंजी और खाते का पुन: उपयोग करें। प्रसंस्करण खाते के संतुलन और सामान्य प्रति स्रोत मूल्य निर्धारण का उपयोग करता है। YouTube Download को मालिक पहुँच और options.storage की आवश्यकता होती है।

एक काम करने वाले फ़ोल्डर को बल्क-api नाम से बनाया गया है और इससे इन उदाहरणों को चलाते हैं। खेल का मैदान का पूरा Python वर्कफ़्लो Python 3.10 + मानक पुस्तकालय का उपयोग करता है; व्यक्तिगत Python समापन बिंदु उदाहरण नीचे अनुरोध की आवश्यकता है; cURL उदाहरण Bash, cURL 7.76+, jq और gzip का उपयोग करते हैं। प्रत्येक क्रिया के लिए एक भाषा चुनें ताकि आप डुप्लिकेट कार्य नहीं बना सकें या शुरू कर सकें।

इनपुट एक UTF-8 फ़ाइल है जिसमें एक 11-character YouTube ID प्रति लाइन है, 2 GiB तक। IDs का प्रयोग करें, URLs नहीं। अपलोड करने से पहले डुप्लिकेट IDs निकालें; दोहराया IDs को अलग से संसाधित किया जाता है।

स्रोतसाझा विकल्प
youtube_metadatainclude_formats, include_chapters
youtube_transcriptभाषा, ऑटो
youtube_captionsभाषा, ऑटो
youtube_trainabilityकोई विकल्प नहीं
youtube_downloadमीडिया विकल्प और भंडारण गंतव्य
Python निर्भरता
python -m pip install requests

अनुरोध फ़ील्ड बनाएं

फील्डप्रकारप्रयोग
sourcestringआवश्यक है। प्रत्येक इनपुट ID के लिए एक समर्थित स्रोत।
optionsobjectसाझा स्रोत विकल्प। डेटा स्रोत result_storage सेट कर सकते हैं; YouTube Download को भंडारण की आवश्यकता होती है।
callback_urlstringवैकल्पिक सार्वजनिक HTTPS समापन कॉलबैक। प्रकाशन के बाद भेजा गया।

एक Bulk नौकरी बनाएँ

एक नौकरी बनाएँ, एक UTF-8 टेक्स्ट फ़ाइल को एक 11-character YouTube वीडियो ID प्रति लाइन upload.href पर अपलोड करें, फिर कॉल शुरू करें। अकेले नौकरी बनाना प्रसंस्करण शुरू नहीं होता है।

यह उदाहरण video-ids.txt लिखते हैं और 201 रसीद को bulk-created.json को बचाता है। उसके बाद के अनुरोध के लिए उस रसीद को निजी रखें और job.id का पुन: उपयोग करें। एक नौकरी बनाना इसे awaiting_upload में छोड़ देता है; अपलोड URL 15 मिनट के बाद समाप्त हो जाता है।

समापन बिंदु
POST https://api.flashdata.dev/v2/bulk-jobs
X-API-Key: YOUR_API_KEY

bulk_create.py को थोक-api में / bulk-created.json के बगल में सहेजें। पूरा स्क्रिप्ट कॉपी करें, फिर इसके नीचे कमांड चलाएं।

bulk_create.py
import json
import os
from pathlib import Path

import requests

os.umask(0o077)
Path("video-ids.txt").write_bytes(b"jNQXAC9IVRw\ndQw4w9WgXcQ\n")
response = requests.post(
    "https://api.flashdata.dev/v2/bulk-jobs",
    headers={"X-API-Key": os.environ["FLASHDATA_API_KEY"]},
    json={"source": "youtube_metadata", "options": {"include_formats": False}},
    timeout=30, allow_redirects=False,
)
response.raise_for_status()
receipt = response.json()
Path("bulk-created.json").write_text(json.dumps(receipt, indent=2), encoding="utf-8")
print(json.dumps(receipt["job"], indent=2))
थोक-api से भागो/
python bulk_create.py

प्रतिक्रियाएं और अनुरोध स्कीमा

HTTP स्थितिअर्थ
201Bulk नौकरी एक 15-मिनट डायरेक्ट अपलोड URL के साथ बनाई गई
401प्रमाणीकरण की आवश्यकता या अवैध
422अनुरोध सत्यापन विफल
503एक आवश्यक निर्भरता या सूची अस्थायी रूप से अनुपलब्ध है
अनुरोध का मुख्य भाग
{
  "$ref": "#/components/schemas/CreateBulkJobRequest"
}
201 · application/json
{
  "$ref": "#/components/schemas/BulkJobCreated"
}

अपलोड और शुरू

अपलोड किए गए UTF-8 वीडियो ID फ़ाइल को संसाधित करना शुरू करें, 2 GiB (2147483648 बाइट्स) तक। शुरू होने के बाद फ़ाइल को अपरिवर्तित रखें।

पहला PUT video-ids.txt रसीद के upload.href के साथ upload.contentType के साथ X-API-Key के साथ। उदाहरण के लिए कॉल केवल अपलोड होने के बाद शुरू होता है। अपलोड की गई फ़ाइल को बाद में अपरिवर्तित रखें।

पैरामीटरस्थानआवश्यकता
bulkIdpathज़रूरी · {"type":"string","pattern":"^bulk_[A-Za-z0-9_-]{8,}$"}
समापन बिंदु
POST https://api.flashdata.dev/v2/bulk-jobs/{bulkId}/start
X-API-Key: YOUR_API_KEY

bulk_start.py को थोक-api में / bulk-created.json के बगल में सहेजें। पूरा स्क्रिप्ट कॉपी करें, फिर इसके नीचे कमांड चलाएं।

bulk_start.py
import json
import os
from pathlib import Path

import requests

receipt = json.loads(Path("bulk-created.json").read_text(encoding="utf-8"))
upload = receipt["upload"]
if upload["method"] != "PUT" or not upload["href"].startswith("https://"):
    raise ValueError("Expected an HTTPS PUT upload URL")
# Stream the file to storage without the FlashData key.
with open("video-ids.txt", "rb") as file:
    response = requests.put(
        upload["href"], data=file,
        headers={"Content-Type": upload["contentType"]},
        timeout=300, allow_redirects=False,
    )
    response.raise_for_status()
    if not 200 <= response.status_code < 300:
        raise RuntimeError("Upload did not complete; do not start the job yet")

bulk_id = receipt["job"]["id"]
response = requests.post(
    f"https://api.flashdata.dev/v2/bulk-jobs/{bulk_id}/start",
    headers={"X-API-Key": os.environ["FLASHDATA_API_KEY"]},
    timeout=30, allow_redirects=False,
)
response.raise_for_status()
print(json.dumps(response.json()["job"], indent=2))
थोक-api से भागो/
python bulk_start.py

जवाब

HTTP स्थितिअर्थ
200Bulk नौकरी शुरू हुई या इसकी वर्तमान idempotent राज्य
401प्रमाणीकरण की आवश्यकता या अवैध
404संसाधन नहीं मिला है या नहीं के स्वामित्व में कॉलर
409संसाधन राज्य या विषमता संघर्ष
422अनुरोध सत्यापन विफल
503एक आवश्यक निर्भरता या सूची अस्थायी रूप से अनुपलब्ध है
200 · application/json
{
  "$ref": "#/components/schemas/BulkJobResponse"
}

नौकरी की स्थिति प्राप्त करें

job.status, इनपुट, गिनती, pauseReason और त्रुटि पढ़ें। एक देरी के साथ उसी ID को फिर से जांचें; पूरा मतलब है कि प्रकट होने को प्रकाशित किया गया है, नहीं कि हर वीडियो सफल हो गया।

पैरामीटरस्थानआवश्यकता
bulkIdpathज़रूरी · {"type":"string","pattern":"^bulk_[A-Za-z0-9_-]{8,}$"}
समापन बिंदु
GET https://api.flashdata.dev/v2/bulk-jobs/{bulkId}
X-API-Key: YOUR_API_KEY

bulk_status.py को थोक-api में / bulk-created.json के बगल में सहेजें। पूरा स्क्रिप्ट कॉपी करें, फिर इसके नीचे कमांड चलाएं।

bulk_status.py
import json
import os
from pathlib import Path

import requests

bulk_id = json.loads(Path("bulk-created.json").read_text(encoding="utf-8"))["job"]["id"]
response = requests.get(
    f"https://api.flashdata.dev/v2/bulk-jobs/{bulk_id}",
    headers={"X-API-Key": os.environ["FLASHDATA_API_KEY"]},
    timeout=30, allow_redirects=False,
)
response.raise_for_status()
Path("bulk-job.json").write_text(json.dumps(response.json(), indent=2), encoding="utf-8")
print(json.dumps(response.json()["job"], indent=2))
थोक-api से भागो/
python bulk_status.py

जवाब

HTTP स्थितिअर्थ
200Bulk रोजगार राज्य
401प्रमाणीकरण की आवश्यकता या अवैध
404संसाधन नहीं मिला है या नहीं के स्वामित्व में कॉलर
200 · application/json
{
  "$ref": "#/components/schemas/BulkJobResponse"
}

सूची नौकरियां

जवाब में डेटा और patgination शामिल है। अगले अनुरोध के कर्सर क्वेरी पैरामीटर के रूप में पास pagination.nextCursor जब तक कि यह null है। 1 से 50 तक की सीमा का उपयोग करें; डिफ़ॉल्ट 20 है।

पैरामीटरस्थानआवश्यकता
cursorqueryवैकल्पिक · {"type":"string","maxLength":512}
limitqueryवैकल्पिक · {"type":"integer","minimum":1,"maximum":50,"default":20}
समापन बिंदु
GET https://api.flashdata.dev/v2/bulk-jobs
X-API-Key: YOUR_API_KEY

list_bulk_jobs.py को थोक-api में / bulk-created.json के बगल में सहेजें। पूरा स्क्रिप्ट कॉपी करें, फिर इसके नीचे कमांड चलाएं।

list_bulk_jobs.py
import json
import os
from pathlib import Path

import requests

response = requests.get(
    "https://api.flashdata.dev/v2/bulk-jobs?limit=20",
    headers={"X-API-Key": os.environ["FLASHDATA_API_KEY"]},
    timeout=30, allow_redirects=False,
)
response.raise_for_status()
print(json.dumps(response.json(), indent=2))
थोक-api से भागो/
python list_bulk_jobs.py

जवाब

HTTP स्थितिअर्थ
200Bulk कार्य पृष्ठ
401प्रमाणीकरण की आवश्यकता या अवैध
200 · application/json
{
  "$ref": "#/components/schemas/BulkJobPage"
}

एक नौकरी

नए प्रस्तुतियों और परिणाम पैकेजिंग का भुगतान करें। मौजूदा नौकरियों को उनकी मूल सेटिंग्स और शुल्क के साथ जारी रखा गया है। तैयार होने पर नौकरी फिर से शुरू करें।

पैरामीटरस्थानआवश्यकता
bulkIdpathज़रूरी · {"type":"string","pattern":"^bulk_[A-Za-z0-9_-]{8,}$"}
समापन बिंदु
POST https://api.flashdata.dev/v2/bulk-jobs/{bulkId}/pause
X-API-Key: YOUR_API_KEY

pause_bulk_job.py को थोक-api में / bulk-created.json के बगल में सहेजें। पूरा स्क्रिप्ट कॉपी करें, फिर इसके नीचे कमांड चलाएं।

pause_bulk_job.py
import json
import os
from pathlib import Path

import requests

bulk_id = json.loads(Path("bulk-created.json").read_text(encoding="utf-8"))["job"]["id"]
response = requests.post(
    f"https://api.flashdata.dev/v2/bulk-jobs/{bulk_id}/pause",
    headers={"X-API-Key": os.environ["FLASHDATA_API_KEY"]},
    timeout=30, allow_redirects=False,
)
response.raise_for_status()
print(json.dumps(response.json(), indent=2))
थोक-api से भागो/
python pause_bulk_job.py

जवाब

HTTP स्थितिअर्थ
200Pause थोक नौकरी या इसके वर्तमान idempotent राज्य
401प्रमाणीकरण की आवश्यकता या अवैध
404संसाधन नहीं मिला है या नहीं के स्वामित्व में कॉलर
200 · application/json
{
  "$ref": "#/components/schemas/BulkJobResponse"
}

नौकरी के विकल्प अद्यतन करें

अपलोड की प्रतीक्षा करते समय अद्यतन विकल्प, या जबकि सभी इनपुट पढ़ने से पहले भुगतान किया गया है। मौजूदा नौकरियों में उनकी सेटिंग रहती है। यदि भुगतान अभी भी प्रगति पर है, तो एक 409 प्रतिक्रिया का इंतजार और पुनः प्रयास करें। सभी इनपुट पढ़ने के बाद, केवल डिलीवरी क्रेडेंशियल को अपडेट किया जा सकता है। इसे हटाने के लिए callback_url को null सेट करें।

यह उदाहरण पूर्ण कॉलबैक को हटा देता है। स्रोत विकल्प बदलने के लिए, इसके बजाय एक विकल्प ऑब्जेक्ट भेजें। पहले रोकें और रोकें के लिए इंतजार करने के लिए प्रभाव; एक 409 मतलब अद्यतन अभी तक लागू नहीं किया जा सकता है। मौजूदा बच्चे की नौकरी उनके मूल विकल्प को रखती है।

पैरामीटरस्थानआवश्यकता
bulkIdpathज़रूरी · {"type":"string","pattern":"^bulk_[A-Za-z0-9_-]{8,}$"}
समापन बिंदु
PATCH https://api.flashdata.dev/v2/bulk-jobs/{bulkId}
X-API-Key: YOUR_API_KEY

update_bulk_job.py को थोक-api में / bulk-created.json के बगल में सहेजें। पूरा स्क्रिप्ट कॉपी करें, फिर इसके नीचे कमांड चलाएं।

update_bulk_job.py
import json
import os
from pathlib import Path

import requests

bulk_id = json.loads(Path("bulk-created.json").read_text(encoding="utf-8"))["job"]["id"]
response = requests.patch(
    f"https://api.flashdata.dev/v2/bulk-jobs/{bulk_id}",
    headers={"X-API-Key": os.environ["FLASHDATA_API_KEY"]},
    json={"callback_url": None},
    timeout=30, allow_redirects=False,
)
response.raise_for_status()
print(json.dumps(response.json(), indent=2))
थोक-api से भागो/
python update_bulk_job.py

प्रतिक्रियाएं और अनुरोध स्कीमा

HTTP स्थितिअर्थ
200अद्यतन थोक नौकरी की स्थिति
401प्रमाणीकरण की आवश्यकता या अवैध
404संसाधन नहीं मिला है या नहीं के स्वामित्व में कॉलर
409संसाधन राज्य या विषमता संघर्ष
422अनुरोध सत्यापन विफल
अनुरोध का मुख्य भाग
{
  "$ref": "#/components/schemas/UpdateBulkJobRequest"
}
200 · application/json
{
  "$ref": "#/components/schemas/BulkJobResponse"
}

नौकरी फिर से शुरू करें

पहले pauseReason को ठीक करें, जैसे क्रेडिट जोड़ने या स्टोरेज क्रेडेंशियल को अद्यतन करने, फिर उसी Bulk ID को फिर से शुरू करें।

पैरामीटरस्थानआवश्यकता
bulkIdpathज़रूरी · {"type":"string","pattern":"^bulk_[A-Za-z0-9_-]{8,}$"}
समापन बिंदु
POST https://api.flashdata.dev/v2/bulk-jobs/{bulkId}/resume
X-API-Key: YOUR_API_KEY

resume_bulk_job.py को थोक-api में / bulk-created.json के बगल में सहेजें। पूरा स्क्रिप्ट कॉपी करें, फिर इसके नीचे कमांड चलाएं।

resume_bulk_job.py
import json
import os
from pathlib import Path

import requests

bulk_id = json.loads(Path("bulk-created.json").read_text(encoding="utf-8"))["job"]["id"]
response = requests.post(
    f"https://api.flashdata.dev/v2/bulk-jobs/{bulk_id}/resume",
    headers={"X-API-Key": os.environ["FLASHDATA_API_KEY"]},
    timeout=30, allow_redirects=False,
)
response.raise_for_status()
print(json.dumps(response.json(), indent=2))
थोक-api से भागो/
python resume_bulk_job.py

जवाब

HTTP स्थितिअर्थ
200वर्तमान में थोक नौकरी की स्थिति
401प्रमाणीकरण की आवश्यकता या अवैध
404संसाधन नहीं मिला है या नहीं के स्वामित्व में कॉलर
200 · application/json
{
  "$ref": "#/components/schemas/BulkJobResponse"
}

नौकरी रद्द करना

नए प्रस्तुतियों को बंद करें। मौजूदा नौकरियों में अभी भी finish हो सकता है और उनके सामान्य शुल्कों का अधिग्रहण कर सकता है। एक रद्द नौकरी एक अंतिम प्रकटन प्रकाशित नहीं करती है।

पैरामीटरस्थानआवश्यकता
bulkIdpathज़रूरी · {"type":"string","pattern":"^bulk_[A-Za-z0-9_-]{8,}$"}
समापन बिंदु
DELETE https://api.flashdata.dev/v2/bulk-jobs/{bulkId}
X-API-Key: YOUR_API_KEY

cancel_bulk_job.py को थोक-api में / bulk-created.json के बगल में सहेजें। पूरा स्क्रिप्ट कॉपी करें, फिर इसके नीचे कमांड चलाएं।

cancel_bulk_job.py
import json
import os
from pathlib import Path

import requests

bulk_id = json.loads(Path("bulk-created.json").read_text(encoding="utf-8"))["job"]["id"]
response = requests.delete(
    f"https://api.flashdata.dev/v2/bulk-jobs/{bulk_id}",
    headers={"X-API-Key": os.environ["FLASHDATA_API_KEY"]},
    timeout=30, allow_redirects=False,
)
response.raise_for_status()
print(json.dumps(response.json(), indent=2))
थोक-api से भागो/
python cancel_bulk_job.py

जवाब

HTTP स्थितिअर्थ
200वर्तमान में थोक नौकरी की स्थिति
401प्रमाणीकरण की आवश्यकता या अवैध
404संसाधन नहीं मिला है या नहीं के स्वामित्व में कॉलर
200 · application/json
{
  "$ref": "#/components/schemas/BulkJobResponse"
}

परिणाम प्रकट हो जाओ

JSON को डाउनलोड करने के लिए पुनर्निर्देश का पालन करें प्रकट और परिणाम फ़ाइलों को पुनर्प्राप्त करने के लिए इसके लिंक का उपयोग करें। अपने API कुंजी के बिना Fetch हस्ताक्षरित भंडारण URLs। परिणाम पूरे Bulk नौकरी पूरा होने के बाद 24 घंटों के लिए उपलब्ध रहते हैं।

प्रमाणित API अनुरोध एक स्थान शीर्षलेख के साथ 302 लौटाता है। Fetch कि HTTPS भंडारण URL बिना एक अलग अनुरोध में X-API-Key. उदाहरण manifest.json बचाता है। एक 409 का मतलब है कि परिणाम तैयार नहीं हैं; 410 का मतलब है कि वे समाप्त हो गए हैं।

पैरामीटरस्थानआवश्यकता
bulkIdpathज़रूरी · {"type":"string","pattern":"^bulk_[A-Za-z0-9_-]{8,}$"}
समापन बिंदु
GET https://api.flashdata.dev/v2/bulk-jobs/{bulkId}/results
X-API-Key: YOUR_API_KEY

bulk_manifest.py को थोक-api में / bulk-created.json के बगल में सहेजें। पूरा स्क्रिप्ट कॉपी करें, फिर इसके नीचे कमांड चलाएं।

bulk_manifest.py
import json
import os
from pathlib import Path

import requests

bulk_id = json.loads(Path("bulk-created.json").read_text(encoding="utf-8"))["job"]["id"]
response = requests.get(
    f"https://api.flashdata.dev/v2/bulk-jobs/{bulk_id}/results",
    headers={"X-API-Key": os.environ["FLASHDATA_API_KEY"]},
    timeout=30, allow_redirects=False,
)
response.raise_for_status()
if response.status_code != 302:
    raise RuntimeError(f"Expected a manifest redirect, got {response.status_code}")
url = response.headers["Location"]
if not url.startswith("https://"):
    raise ValueError("Expected an HTTPS storage URL")

manifest = requests.get(url, timeout=120)  # No FlashData API key.
manifest.raise_for_status()
Path("manifest.json").write_text(json.dumps(manifest.json(), indent=2), encoding="utf-8")
print(json.dumps(manifest.json(), indent=2))
थोक-api से भागो/
python bulk_manifest.py

जवाब

HTTP स्थितिअर्थ
200Redirect के बाद JSON प्रकटन डाउनलोड किया गया
302शॉर्ट-लाइव्ड प्राइवेट R2 URL पर रीडायरेक्ट करें; API क्रेडेंशियल को अग्रेषित नहीं किया जाना चाहिए · Location
401प्रमाणीकरण की आवश्यकता या अवैध
404संसाधन नहीं मिला है या नहीं के स्वामित्व में कॉलर
409संसाधन राज्य या विषमता संघर्ष
410बनाए रखा परिणाम समाप्त हो गया है
200 · application/json
{
  "type": "object",
  "additionalProperties": true
}

परिणाम भागों डाउनलोड करें

manifest.json से प्रत्येक parts[].number का उपयोग करें। प्रत्येक समापन बिंदु एक 302 को एक gzip NDJSON फ़ाइल में लौटा देता है; API कुंजी के बिना डाउनलोड करें, डिकंप्रेस करें, फिर प्रति पंक्ति एक JSON ऑब्जेक्ट को पार करें। शून्य आधारित सूचकांक से जुड़ना। उदाहरण सभी भागों को पुनर्प्राप्त करता है और दोनों .ndjson.gz और .ndjson फ़ाइलों को रखता है।

पैरामीटरस्थानआवश्यकता
bulkIdpathज़रूरी · {"type":"string","pattern":"^bulk_[A-Za-z0-9_-]{8,}$"}
partNumberpathज़रूरी · {"type":"integer","minimum":0}
समापन बिंदु
GET https://api.flashdata.dev/v2/bulk-jobs/{bulkId}/results/{partNumber}
X-API-Key: YOUR_API_KEY

bulk_parts.py को थोक-api में / bulk-created.json के बगल में सहेजें। पूरा स्क्रिप्ट कॉपी करें, फिर इसके नीचे कमांड चलाएं।

bulk_parts.py
import json
import os
from pathlib import Path

import requests
import gzip
import shutil

bulk_id = json.loads(Path("bulk-created.json").read_text(encoding="utf-8"))["job"]["id"]
manifest = json.loads(Path("manifest.json").read_text(encoding="utf-8"))
for part in manifest["parts"]:
    number = part["number"]
    response = requests.get(
        f"https://api.flashdata.dev/v2/bulk-jobs/{bulk_id}/results/{number}",
        headers={"X-API-Key": os.environ["FLASHDATA_API_KEY"]},
        timeout=30, allow_redirects=False,
    )
    response.raise_for_status()
    if response.status_code != 302:
        raise RuntimeError(f"Expected a part redirect, got {response.status_code}")
    url = response.headers["Location"]
    if not url.startswith("https://"):
        raise ValueError("Expected an HTTPS storage URL")

    # Save the original gzip bytes; do not decompress twice.
    with requests.get(url, stream=True, timeout=120) as download:
        download.raise_for_status()
        with open(f"part-{number}.ndjson.gz", "wb") as file:
            download.raw.decode_content = False
            shutil.copyfileobj(download.raw, file)
    with gzip.open(f"part-{number}.ndjson.gz", "rt", encoding="utf-8") as rows:
        with open(f"part-{number}.ndjson", "w", encoding="utf-8") as file:
            for line in rows:
                file.write(line)
                print(json.dumps(json.loads(line)))
थोक-api से भागो/
python bulk_parts.py

जवाब

HTTP स्थितिअर्थ
200Gzip-compressed NDJSON redirect के बाद डाउनलोड किया गया
302शॉर्ट-लाइव्ड प्राइवेट R2 URL पर रीडायरेक्ट करें; API क्रेडेंशियल को अग्रेषित नहीं किया जाना चाहिए · Location
401प्रमाणीकरण की आवश्यकता या अवैध
404संसाधन नहीं मिला है या नहीं के स्वामित्व में कॉलर
409संसाधन राज्य या विषमता संघर्ष
410बनाए रखा परिणाम समाप्त हो गया है
200 · application/x-ndjson
{
  "type": "string"
}

नौकरी की स्थिति और अवधारण

परिणाम पूरे Bulk नौकरी पूरा होने के बाद 24 घंटों के लिए उपलब्ध रहते हैं। उन्हें expiresAt से पहले सहेजें। आपके गंतव्य में मीडिया आपकी बाल्टी की अवधारण नीति का पालन करता है। एक पूर्ण नौकरी में असफल वीडियो शामिल हो सकते हैं; counts.invalid रिकॉर्ड ने इनपुट लाइनों को अस्वीकार कर दिया।

राज्यअगली कार्रवाई
awaiting_uploadफ़ाइल अपलोड करें और कॉल शुरू करें।
runningबैकऑफ के साथ उसी ID को Poll; input.complete से पता चलता है कि क्या स्कैनिंग समाप्त हो गई है।
pausedpauseReason पढ़ें, इसे ठीक करें, फिर से शुरू करें।
finalizingपरिणाम पैकेजिंग और प्रकट प्रकाशन के लिए प्रतीक्षा करें।
completedप्रत्येक भाग को प्रदर्शित करता है। प्रत्येक पंक्ति की स्थिति और त्रुटि का निरीक्षण करें।
failed / cancelledत्रुटि और बचाया राज्य का निरीक्षण करें। कोई अंतिम प्रकटन प्रकाशित नहीं किया गया है।

भंडारण वितरण

एक प्रदाता को कॉन्फ़िगर करने और सटीक अनुरोध फ़ील्ड का पूर्वावलोकन करने के लिए खेल का मैदान का उपयोग करें। ग्राहक भंडारण क्रेडेंशियल चुनी गई स्टोरेज ऑब्जेक्ट में हैं; X-API-Key केवल FlashData API अनुरोधों को प्रमाणित करता है।

स्रोतअनुरोध फ़ील्ड बनाएंडिलिवरी
मेटाडाटा, ट्रांसक्रिप्ट, कैप्शन, लाइसेंस चेकoptions.result_storageवैकल्पिक। Copies NDJSON परिणाम भागों और अपनी बाल्टी के लिए एक प्रकट होता है।
youtube_downloadoptions.storageआवश्यक है। मीडिया को अपनी बाल्टी में वितरित करें; result_storage और browser_delivery स्वीकार नहीं किए जाते हैं।

वितरित फ़ाइलों का पता लगाएं

डेटा प्रकट अंतिम लिखा गया है और ऑब्जेक्ट कुंजी, आकार और SHA-256 चेकसम सूचीबद्ध करता है। यह FlashData प्रकटन से भिन्न है, जो API href मानों को सूचीबद्ध करता है। डेटा पथ में YYYMMDD यूटीसी Bulk निर्माण तिथि का उपयोग करता है; मीडिया पथ में यह प्रत्येक वीडियो की UTC अपलोड तिथि का उपयोग करता है। Bulk OSS डेटा डिलीवरी के लिए एक aliyuncs.com समापन बिंदु की आवश्यकता होती है।

निजी मीडिया file_url मानों को उस प्रदाता से अपने भंडारण SDK या एक हस्ताक्षरित URL की आवश्यकता होती है। एक FlashData कुंजी बाल्टी तक पहुंच प्रदान नहीं करती है। वैकल्पिक मेटाडाटा साथी फ़ाइलों को मीडिया के बगल में संग्रहीत किया जाता है। डिलिवरी रिट्रीज़ delivery.retryCount में दिखाई देते हैं।

डेटा ऑब्जेक्ट लेआउट
<prefix>/<source>/<bulkId>/results/part-NNNNNNNN.jsonl.gz
<prefix>/<source>/<bulkId>/manifest.json

पूरा होने वाला वेबहुक प्राप्त करें

एक सार्वजनिक HTTPS callback_url को विकल्प के बाहर रखें। Bulk केवल प्रकट होने को प्रकाशित करने के बाद ही पूरा हो जाता है; यह प्रति-वीडियो घटनाओं को नहीं भेजता है और असफल या रद्द नौकरियों के लिए कोई पूरा कार्यक्रम नहीं होता है। स्टेटस मतदान को एक गिरावट के रूप में रखें।

  1. Persist और deduplicate delivery_id, फिर तुरंत 2xx वापस लौटें। डिलीवरी बैकऑफ के साथ आठ बार तक की जाती है।
  2. घटनाओं को त्याग नहीं दिया जाता है। अपने सहेजे गए रसीद को आईडी और स्रोत से मिलान करें; पुनर्प्राप्ति को समाप्त करने से पहले प्रमाणित प्रबंधन API के माध्यम से पूरा किया गया सत्यापित करें। एक एकीकृत घटना से URLs को अनदेखा करें।
कॉलबैक के साथ अनुरोध करें
{
  "source": "youtube_metadata",
  "options": {
    "include_formats": false,
    "include_chapters": false
  },
  "callback_url": "https://your-app.example/webhooks/flashdata"
}
Completion event · illustrative
{
  "delivery_id": "bulk-completion:bulk_EXAMPLE123",
  "id": "bulk_EXAMPLE123",
  "source": "youtube_metadata",
  "status": "completed",
  "links": [
    {
      "rel": "self",
      "href": "https://api.flashdata.dev/v2/bulk-jobs/bulk_EXAMPLE123",
      "method": "GET"
    },
    {
      "rel": "results",
      "href": "https://api.flashdata.dev/v2/bulk-jobs/bulk_EXAMPLE123/results",
      "method": "GET"
    }
  ]
}

स्कीमा परिभाषा

BulkJobCreated

BulkJobCreated
{
  "type": "object",
  "additionalProperties": false,
  "required": [
    "job",
    "upload"
  ],
  "properties": {
    "job": {
      "$ref": "#/components/schemas/BulkJob"
    },
    "upload": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "href",
        "method",
        "expiresAt",
        "contentType"
      ],
      "properties": {
        "href": {
          "type": "string",
          "format": "uri"
        },
        "method": {
          "type": "string",
          "const": "PUT"
        },
        "expiresAt": {
          "type": "string",
          "format": "date-time"
        },
        "contentType": {
          "type": "string",
          "const": "text/plain; charset=utf-8"
        }
      }
    }
  }
}

BulkJob

BulkJob
{
  "type": "object",
  "additionalProperties": false,
  "required": [
    "id",
    "source",
    "status",
    "input",
    "counts",
    "delivery",
    "pauseReason",
    "error",
    "createdAt",
    "startedAt",
    "completedAt",
    "expiresAt",
    "links"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^bulk_[A-Za-z0-9_-]{8,}$"
    },
    "source": {
      "type": "string",
      "enum": [
        "youtube_metadata",
        "youtube_transcript",
        "youtube_captions",
        "youtube_trainability",
        "youtube_download"
      ]
    },
    "status": {
      "type": "string",
      "enum": [
        "awaiting_upload",
        "running",
        "paused",
        "finalizing",
        "completed",
        "failed",
        "cancelled"
      ]
    },
    "input": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "bytes",
        "complete",
        "scannedBytes",
        "scannedLines"
      ],
      "properties": {
        "bytes": {
          "type": "integer",
          "minimum": 0
        },
        "complete": {
          "type": "boolean"
        },
        "scannedBytes": {
          "type": "integer",
          "minimum": 0
        },
        "scannedLines": {
          "type": "integer",
          "minimum": 0
        }
      }
    },
    "counts": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "accepted",
        "completed",
        "failed",
        "invalid",
        "results"
      ],
      "properties": {
        "accepted": {
          "type": "integer",
          "minimum": 0
        },
        "completed": {
          "type": "integer",
          "minimum": 0
        },
        "failed": {
          "type": "integer",
          "minimum": 0
        },
        "invalid": {
          "type": "integer",
          "minimum": 0
        },
        "results": {
          "type": "integer",
          "minimum": 0
        }
      }
    },
    "pauseReason": {
      "type": [
        "string",
        "null"
      ]
    },
    "delivery": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "customerStorage",
        "storageType",
        "uploadedParts",
        "retryCount"
      ],
      "properties": {
        "customerStorage": {
          "type": "boolean"
        },
        "storageType": {
          "type": [
            "string",
            "null"
          ],
          "enum": [
            "s3",
            "s3_compatible",
            "oss",
            "gcs",
            "azure",
            "cos",
            "bos",
            "tos",
            null
          ]
        },
        "uploadedParts": {
          "type": "integer",
          "minimum": 0
        },
        "retryCount": {
          "type": "integer",
          "minimum": 0
        }
      }
    },
    "error": {
      "oneOf": [
        {
          "type": "null"
        },
        {
          "type": "object",
          "additionalProperties": false,
          "required": [
            "code",
            "detail"
          ],
          "properties": {
            "code": {
              "type": "string"
            },
            "detail": {
              "type": [
                "string",
                "null"
              ]
            }
          }
        }
      ]
    },
    "createdAt": {
      "type": "string",
      "format": "date-time"
    },
    "startedAt": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time"
    },
    "completedAt": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time"
    },
    "expiresAt": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time"
    },
    "links": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/JobLink"
      }
    }
  }
}

BulkJobPage

BulkJobPage
{
  "type": "object",
  "additionalProperties": false,
  "required": [
    "data",
    "pagination"
  ],
  "properties": {
    "data": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/BulkJob"
      }
    },
    "pagination": {
      "$ref": "#/components/schemas/Pagination"
    }
  }
}

BulkJobResponse

BulkJobResponse
{
  "type": "object",
  "additionalProperties": false,
  "required": [
    "job"
  ],
  "properties": {
    "job": {
      "$ref": "#/components/schemas/BulkJob"
    }
  }
}

CreateBulkJobRequest

CreateBulkJobRequest
{
  "type": "object",
  "additionalProperties": false,
  "required": [
    "source"
  ],
  "properties": {
    "source": {
      "type": "string",
      "enum": [
        "youtube_metadata",
        "youtube_transcript",
        "youtube_captions",
        "youtube_trainability",
        "youtube_download"
      ]
    },
    "options": {
      "type": "object",
      "additionalProperties": true,
      "description": "Reused for every ID. Metadata accepts include_formats and include_chapters. Transcript and captions accept language (one code or an array of 1–10 distinct codes) and auto (applies to all requested languages). Omit language to prefer en-orig, fall back to en, and return one track. With auto=true, each requested code tries its -orig track first, then the plain code. Explicit -orig codes and auto=false stay exact. languageCode identifies the selected track; requestedLanguageCode is included when it differs from the requested code. A language array returns tracks and per-language errors for each video with at least one retrieved track. If no track is retrieved, the video job fails and its reserved credits are refunded. Bulk exports use one JSONL record per video. Trainability accepts no source options. These four data sources optionally accept result_storage. Supported storage_type values are s3, s3_compatible, oss, gcs, azure, cos, bos, and tos. storage_url is the bucket name (Azure container name); object_prefix is optional. S3, S3-compatible, OSS, COS, BOS, and TOS use access_key and secret_key. S3-compatible and OSS also require a public HTTPS endpoint_url. COS, BOS, and TOS require region and use fixed provider endpoints. COS bucket names include the APPID. BOS S3-compatible HTTPS delivery supports bj, su, and hkg. GCS requires service_account with project_id, client_email, and private_key. Azure requires account_name and a container SAS sas_token with write permission. Default object_prefix is YYYYMMDD, frozen to the UTC bulk creation date. Files are written to <prefix>/<source>/<bulkId>/results/part-NNNNNNNN.jsonl.gz; manifest.json in the same bulk directory is written last. Each JSONL row includes its input index and completed, failed, or invalid status. Internal R2 results remain available through the result links for 24 hours. Download accepts the normal YouTube download parameters, requires customer storage, and does not permit browser_delivery. Download storage supports the same eight provider types and credential shapes listed above under the storage field. Download storage may include object_prefix; YYYYMMDD tokens resolve to the UTC upload date, while literal prefixes are unchanged."
    },
    "callback_url": {
      "type": "string",
      "format": "uri",
      "maxLength": 2048,
      "description": "Optional public HTTPS endpoint notified once after manifest publication."
    }
  }
}

JobLink

JobLink
{
  "type": "object",
  "additionalProperties": false,
  "required": [
    "rel",
    "href",
    "method"
  ],
  "properties": {
    "rel": {
      "type": "string",
      "enum": [
        "self",
        "results",
        "content",
        "download"
      ]
    },
    "href": {
      "type": "string",
      "format": "uri"
    },
    "method": {
      "type": "string",
      "const": "GET"
    },
    "expires_at": {
      "type": "string",
      "format": "date-time"
    },
    "filename": {
      "type": "string"
    },
    "content_type": {
      "type": "string"
    },
    "size_bytes": {
      "type": "integer",
      "minimum": 1
    }
  }
}

Pagination

Pagination
{
  "type": "object",
  "additionalProperties": false,
  "required": [
    "hasMore",
    "limit"
  ],
  "properties": {
    "nextCursor": {
      "type": [
        "string",
        "null"
      ]
    },
    "previousCursor": {
      "type": [
        "string",
        "null"
      ]
    },
    "hasMore": {
      "type": "boolean"
    },
    "limit": {
      "type": "integer",
      "minimum": 1,
      "maximum": 100
    }
  }
}

Problem

Problem
{
  "type": "object",
  "additionalProperties": false,
  "required": [
    "type",
    "title",
    "status",
    "code",
    "requestId"
  ],
  "properties": {
    "type": {
      "type": "string",
      "format": "uri-reference"
    },
    "title": {
      "type": "string"
    },
    "status": {
      "type": "integer",
      "minimum": 400,
      "maximum": 599
    },
    "code": {
      "type": "string",
      "pattern": "^[a-z0-9_]+$"
    },
    "detail": {
      "type": "string"
    },
    "requestId": {
      "type": "string",
      "pattern": "^req_"
    },
    "fieldErrors": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/FieldError"
      }
    }
  }
}

FieldError

FieldError
{
  "type": "object",
  "additionalProperties": false,
  "required": [
    "field",
    "code",
    "message"
  ],
  "properties": {
    "field": {
      "type": "string"
    },
    "code": {
      "type": "string"
    },
    "message": {
      "type": "string"
    }
  }
}

UpdateBulkJobRequest

UpdateBulkJobRequest
{
  "type": "object",
  "additionalProperties": false,
  "minProperties": 1,
  "properties": {
    "options": {
      "type": "object",
      "additionalProperties": true,
      "description": "Partial option update. Nested storage fields are merged so unchanged credentials do not need to be resent. Data result_storage fields are merged the same way. After all IDs have been scanned, a paused data bulk job accepts credential updates only: access_key and secret_key, GCS service_account, or Azure sas_token, depending on the storage type. The complete merged configuration is validated before it is stored."
    },
    "callback_url": {
      "type": [
        "string",
        "null"
      ],
      "format": "uri",
      "maxLength": 2048,
      "description": "Replacement completion callback, or null to remove the callback."
    }
  }
}
Markdown