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

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

कैनोनिकल संदर्भ: https://flashdata.dev/hi/docs/reference/bulk-processing
समीक्षित: 2026-11-05 द्वारा FlashData

<a id="playground"></a>

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

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

- [प्रमाणीकरण और फ़ाइल आवश्यकताओं](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#prepare)
- [समापन बिंदुओं को ब्राउज़ करें](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#endpoints)
- [Batch या Bulk?](https://flashdata.dev/hi/docs/reference/batch-and-bulk/reference.md)

<a id="endpoints"></a>

## समापन बिंदु

सभी समापन बिंदुओं का उपयोग 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} | परिणाम भागों डाउनलोड करें |

- [Batch या Bulk?](https://flashdata.dev/hi/docs/reference/batch-and-bulk/reference.md)
- [अंतिम Bulk गाइड](https://flashdata.dev/hi/docs/guides/bulk/reference.md)
- [OpenAPI विनिर्देश](https://flashdata.dev/docs/openapi.json)

<a id="prepare"></a>

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

चयनित स्रोत तक पहुंच के साथ एक कुंजी के लिए 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_metadata | include_formats, include_chapters |
| youtube_transcript | भाषा, ऑटो |
| youtube_captions | भाषा, ऑटो |
| youtube_trainability | कोई विकल्प नहीं |
| youtube_download | मीडिया विकल्प और भंडारण गंतव्य |

### Python निर्भरता

```bash
python -m pip install requests
```

- [API कुंजी और हेडर](https://flashdata.dev/hi/docs/guides/headers-and-authentication/reference.md)
- [भंडारण क्षेत्र](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#storage)

<a id="request-body"></a>

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

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

- [पूर्ण अनुरोध स्कीमा](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-CreateBulkJobRequest)
- [वेबहुक हैंडलिंग](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#webhooks)

<a id="createBulkJob"></a>

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

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

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

### समापन बिंदु

```http
POST https://api.flashdata.dev/v2/bulk-jobs
X-API-Key: YOUR_API_KEY
```

### Python

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

#### bulk_create.py

```python
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 से भागो/

```bash
python bulk_create.py
```


### cURL / Bash

#### थोक-api से भागो/

```bash
umask 077
printf '%s\n' 'jNQXAC9IVRw' 'dQw4w9WgXcQ' > video-ids.txt
curl --fail-with-body --silent --show-error \
  'https://api.flashdata.dev/v2/bulk-jobs' \
  --header "X-API-Key: ${FLASHDATA_API_KEY:?Set FLASHDATA_API_KEY}" \
  --header 'Content-Type: application/json' \
  --data '{"source":"youtube_metadata","options":{"include_formats":false}}' \
  --output bulk-created.json &&
jq '.job | {id, source, status}' bulk-created.json
```


- [CreateBulkJobRequest](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-CreateBulkJobRequest)
- [BulkJobCreated](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-BulkJobCreated)
- [Problem](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-Problem)

<a id="createBulkJob-responses"></a>

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

| HTTP स्थिति | अर्थ |
| --- | --- |
| 201 | Bulk नौकरी एक 15-मिनट डायरेक्ट अपलोड URL के साथ बनाई गई |
| 401 | प्रमाणीकरण की आवश्यकता या अवैध |
| 422 | अनुरोध सत्यापन विफल |
| 503 | एक आवश्यक निर्भरता या सूची अस्थायी रूप से अनुपलब्ध है |

#### अनुरोध का मुख्य भाग

```json
{
  "$ref": "#/components/schemas/CreateBulkJobRequest"
}
```

#### 201 · application/json

```json
{
  "$ref": "#/components/schemas/BulkJobCreated"
}
```


<a id="startBulkJob"></a>

## अपलोड और शुरू

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

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

| पैरामीटर | स्थान | आवश्यकता |
| --- | --- | --- |
| bulkId | path | ज़रूरी · {"type":"string","pattern":"^bulk_[A-Za-z0-9_-]{8,}$"} |

### समापन बिंदु

```http
POST https://api.flashdata.dev/v2/bulk-jobs/{bulkId}/start
X-API-Key: YOUR_API_KEY
```

### Python

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

#### bulk_start.py

```python
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 से भागो/

```bash
python bulk_start.py
```


### cURL / Bash

#### थोक-api से भागो/

```bash
BULK_ID=$(jq -er '.job.id' bulk-created.json)
UPLOAD_URL=$(jq -er '.upload.href' bulk-created.json)
CONTENT_TYPE=$(jq -er '.upload.contentType' bulk-created.json)
curl --fail-with-body --silent --show-error --proto '=https' \
  --header "Content-Type: $CONTENT_TYPE" \
  --upload-file video-ids.txt "$UPLOAD_URL" &&
curl --fail-with-body --silent --show-error --request POST \
  "https://api.flashdata.dev/v2/bulk-jobs/$BULK_ID/start" \
  --header "X-API-Key: ${FLASHDATA_API_KEY:?Set FLASHDATA_API_KEY}"
```


- [BulkJobResponse](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-BulkJobResponse)
- [Problem](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-Problem)

<a id="startBulkJob-responses"></a>

### जवाब

| HTTP स्थिति | अर्थ |
| --- | --- |
| 200 | Bulk नौकरी शुरू हुई या इसकी वर्तमान idempotent राज्य |
| 401 | प्रमाणीकरण की आवश्यकता या अवैध |
| 404 | संसाधन नहीं मिला है या नहीं के स्वामित्व में कॉलर |
| 409 | संसाधन राज्य या विषमता संघर्ष |
| 422 | अनुरोध सत्यापन विफल |
| 503 | एक आवश्यक निर्भरता या सूची अस्थायी रूप से अनुपलब्ध है |

#### 200 · application/json

```json
{
  "$ref": "#/components/schemas/BulkJobResponse"
}
```


<a id="getBulkJob"></a>

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

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

| पैरामीटर | स्थान | आवश्यकता |
| --- | --- | --- |
| bulkId | path | ज़रूरी · {"type":"string","pattern":"^bulk_[A-Za-z0-9_-]{8,}$"} |

### समापन बिंदु

```http
GET https://api.flashdata.dev/v2/bulk-jobs/{bulkId}
X-API-Key: YOUR_API_KEY
```

### Python

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

#### bulk_status.py

```python
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 से भागो/

```bash
python bulk_status.py
```


### cURL / Bash

#### थोक-api से भागो/

```bash
BULK_ID=$(jq -er '.job.id' bulk-created.json)
curl --fail-with-body --silent --show-error \
  "https://api.flashdata.dev/v2/bulk-jobs/$BULK_ID" \
  --header "X-API-Key: ${FLASHDATA_API_KEY:?Set FLASHDATA_API_KEY}" \
  --output bulk-job.json &&
jq '.job | {id, status, counts, pauseReason, error, expiresAt}' bulk-job.json
```


- [BulkJobResponse](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-BulkJobResponse)
- [Problem](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-Problem)

<a id="getBulkJob-responses"></a>

### जवाब

| HTTP स्थिति | अर्थ |
| --- | --- |
| 200 | Bulk रोजगार राज्य |
| 401 | प्रमाणीकरण की आवश्यकता या अवैध |
| 404 | संसाधन नहीं मिला है या नहीं के स्वामित्व में कॉलर |

#### 200 · application/json

```json
{
  "$ref": "#/components/schemas/BulkJobResponse"
}
```


<a id="listBulkJobs"></a>

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

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

| पैरामीटर | स्थान | आवश्यकता |
| --- | --- | --- |
| cursor | query | वैकल्पिक · {"type":"string","maxLength":512} |
| limit | query | वैकल्पिक · {"type":"integer","minimum":1,"maximum":50,"default":20} |

### समापन बिंदु

```http
GET https://api.flashdata.dev/v2/bulk-jobs
X-API-Key: YOUR_API_KEY
```

### Python

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

#### list_bulk_jobs.py

```python
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 से भागो/

```bash
python list_bulk_jobs.py
```


### cURL / Bash

#### थोक-api से भागो/

```bash
curl --fail-with-body --silent --show-error --max-time 30 \
  --request GET \
  --header "X-API-Key: ${FLASHDATA_API_KEY:?Set FLASHDATA_API_KEY}" \
  "https://api.flashdata.dev/v2/bulk-jobs?limit=20"
```


- [BulkJobPage](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-BulkJobPage)
- [Problem](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-Problem)

<a id="listBulkJobs-responses"></a>

### जवाब

| HTTP स्थिति | अर्थ |
| --- | --- |
| 200 | Bulk कार्य पृष्ठ |
| 401 | प्रमाणीकरण की आवश्यकता या अवैध |

#### 200 · application/json

```json
{
  "$ref": "#/components/schemas/BulkJobPage"
}
```


<a id="pauseBulkJob"></a>

## एक नौकरी

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

| पैरामीटर | स्थान | आवश्यकता |
| --- | --- | --- |
| bulkId | path | ज़रूरी · {"type":"string","pattern":"^bulk_[A-Za-z0-9_-]{8,}$"} |

### समापन बिंदु

```http
POST https://api.flashdata.dev/v2/bulk-jobs/{bulkId}/pause
X-API-Key: YOUR_API_KEY
```

### Python

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

#### pause_bulk_job.py

```python
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 से भागो/

```bash
python pause_bulk_job.py
```


### cURL / Bash

#### थोक-api से भागो/

```bash
BULK_ID=$(jq -er '.job.id' bulk-created.json)
curl --fail-with-body --silent --show-error --max-time 30 \
  --request POST \
  --header "X-API-Key: ${FLASHDATA_API_KEY:?Set FLASHDATA_API_KEY}" \
  "https://api.flashdata.dev/v2/bulk-jobs/$BULK_ID/pause"
```


- [BulkJobResponse](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-BulkJobResponse)
- [Problem](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-Problem)

<a id="pauseBulkJob-responses"></a>

### जवाब

| HTTP स्थिति | अर्थ |
| --- | --- |
| 200 | Pause थोक नौकरी या इसके वर्तमान idempotent राज्य |
| 401 | प्रमाणीकरण की आवश्यकता या अवैध |
| 404 | संसाधन नहीं मिला है या नहीं के स्वामित्व में कॉलर |

#### 200 · application/json

```json
{
  "$ref": "#/components/schemas/BulkJobResponse"
}
```


<a id="updateBulkJob"></a>

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

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

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

| पैरामीटर | स्थान | आवश्यकता |
| --- | --- | --- |
| bulkId | path | ज़रूरी · {"type":"string","pattern":"^bulk_[A-Za-z0-9_-]{8,}$"} |

### समापन बिंदु

```http
PATCH https://api.flashdata.dev/v2/bulk-jobs/{bulkId}
X-API-Key: YOUR_API_KEY
```

### Python

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

#### update_bulk_job.py

```python
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 से भागो/

```bash
python update_bulk_job.py
```


### cURL / Bash

#### थोक-api से भागो/

```bash
BULK_ID=$(jq -er '.job.id' bulk-created.json)
curl --fail-with-body --silent --show-error --max-time 30 \
  --request PATCH \
  --header "X-API-Key: ${FLASHDATA_API_KEY:?Set FLASHDATA_API_KEY}" \
  --header 'Content-Type: application/json' --data '{"callback_url":null}' \
  "https://api.flashdata.dev/v2/bulk-jobs/$BULK_ID"
```


- [UpdateBulkJobRequest](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-UpdateBulkJobRequest)
- [BulkJobResponse](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-BulkJobResponse)
- [Problem](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-Problem)

<a id="updateBulkJob-responses"></a>

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

| HTTP स्थिति | अर्थ |
| --- | --- |
| 200 | अद्यतन थोक नौकरी की स्थिति |
| 401 | प्रमाणीकरण की आवश्यकता या अवैध |
| 404 | संसाधन नहीं मिला है या नहीं के स्वामित्व में कॉलर |
| 409 | संसाधन राज्य या विषमता संघर्ष |
| 422 | अनुरोध सत्यापन विफल |

#### अनुरोध का मुख्य भाग

```json
{
  "$ref": "#/components/schemas/UpdateBulkJobRequest"
}
```

#### 200 · application/json

```json
{
  "$ref": "#/components/schemas/BulkJobResponse"
}
```


<a id="resumeBulkJob"></a>

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

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

| पैरामीटर | स्थान | आवश्यकता |
| --- | --- | --- |
| bulkId | path | ज़रूरी · {"type":"string","pattern":"^bulk_[A-Za-z0-9_-]{8,}$"} |

### समापन बिंदु

```http
POST https://api.flashdata.dev/v2/bulk-jobs/{bulkId}/resume
X-API-Key: YOUR_API_KEY
```

### Python

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

#### resume_bulk_job.py

```python
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 से भागो/

```bash
python resume_bulk_job.py
```


### cURL / Bash

#### थोक-api से भागो/

```bash
BULK_ID=$(jq -er '.job.id' bulk-created.json)
curl --fail-with-body --silent --show-error --max-time 30 \
  --request POST \
  --header "X-API-Key: ${FLASHDATA_API_KEY:?Set FLASHDATA_API_KEY}" \
  "https://api.flashdata.dev/v2/bulk-jobs/$BULK_ID/resume"
```


- [BulkJobResponse](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-BulkJobResponse)
- [Problem](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-Problem)

<a id="resumeBulkJob-responses"></a>

### जवाब

| HTTP स्थिति | अर्थ |
| --- | --- |
| 200 | वर्तमान में थोक नौकरी की स्थिति |
| 401 | प्रमाणीकरण की आवश्यकता या अवैध |
| 404 | संसाधन नहीं मिला है या नहीं के स्वामित्व में कॉलर |

#### 200 · application/json

```json
{
  "$ref": "#/components/schemas/BulkJobResponse"
}
```


<a id="cancelBulkJob"></a>

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

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

| पैरामीटर | स्थान | आवश्यकता |
| --- | --- | --- |
| bulkId | path | ज़रूरी · {"type":"string","pattern":"^bulk_[A-Za-z0-9_-]{8,}$"} |

### समापन बिंदु

```http
DELETE https://api.flashdata.dev/v2/bulk-jobs/{bulkId}
X-API-Key: YOUR_API_KEY
```

### Python

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

#### cancel_bulk_job.py

```python
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 से भागो/

```bash
python cancel_bulk_job.py
```


### cURL / Bash

#### थोक-api से भागो/

```bash
BULK_ID=$(jq -er '.job.id' bulk-created.json)
curl --fail-with-body --silent --show-error --max-time 30 \
  --request DELETE \
  --header "X-API-Key: ${FLASHDATA_API_KEY:?Set FLASHDATA_API_KEY}" \
  "https://api.flashdata.dev/v2/bulk-jobs/$BULK_ID"
```


- [BulkJobResponse](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-BulkJobResponse)
- [Problem](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-Problem)

<a id="cancelBulkJob-responses"></a>

### जवाब

| HTTP स्थिति | अर्थ |
| --- | --- |
| 200 | वर्तमान में थोक नौकरी की स्थिति |
| 401 | प्रमाणीकरण की आवश्यकता या अवैध |
| 404 | संसाधन नहीं मिला है या नहीं के स्वामित्व में कॉलर |

#### 200 · application/json

```json
{
  "$ref": "#/components/schemas/BulkJobResponse"
}
```


<a id="downloadBulkJobManifest"></a>

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

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

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

| पैरामीटर | स्थान | आवश्यकता |
| --- | --- | --- |
| bulkId | path | ज़रूरी · {"type":"string","pattern":"^bulk_[A-Za-z0-9_-]{8,}$"} |

### समापन बिंदु

```http
GET https://api.flashdata.dev/v2/bulk-jobs/{bulkId}/results
X-API-Key: YOUR_API_KEY
```

### Python

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

#### bulk_manifest.py

```python
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 से भागो/

```bash
python bulk_manifest.py
```


### cURL / Bash

#### थोक-api से भागो/

```bash
BULK_ID=$(jq -er '.job.id' bulk-created.json)
# Only send the API key to FlashData; fetch storage URLs separately.
fetch_bulk_result() {
  local storage_url
  storage_url=$(curl --fail-with-body --silent --show-error \
    "https://api.flashdata.dev/v2/bulk-jobs/$BULK_ID/results$1" \
    --header "X-API-Key: ${FLASHDATA_API_KEY:?Set FLASHDATA_API_KEY}" \
    --output /dev/null --write-out '%{redirect_url}') || return
  curl --fail-with-body --silent --show-error --proto '=https' \
    "${storage_url:?Expected a signed result URL}" --output "$2"
}
fetch_bulk_result '' manifest.json &&
jq '{status, counts, parts, expires_at}' manifest.json
```


- [Problem](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-Problem)

<a id="downloadBulkJobManifest-responses"></a>

### जवाब

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

#### 200 · application/json

```json
{
  "type": "object",
  "additionalProperties": true
}
```


<a id="downloadBulkJobPart"></a>

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

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

| पैरामीटर | स्थान | आवश्यकता |
| --- | --- | --- |
| bulkId | path | ज़रूरी · {"type":"string","pattern":"^bulk_[A-Za-z0-9_-]{8,}$"} |
| partNumber | path | ज़रूरी · {"type":"integer","minimum":0} |

### समापन बिंदु

```http
GET https://api.flashdata.dev/v2/bulk-jobs/{bulkId}/results/{partNumber}
X-API-Key: YOUR_API_KEY
```

### Python

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

#### bulk_parts.py

```python
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 से भागो/

```bash
python bulk_parts.py
```


### cURL / Bash

#### थोक-api से भागो/

```bash
BULK_ID=$(jq -er '.job.id' bulk-created.json)
# Only send the API key to FlashData; fetch storage URLs separately.
fetch_bulk_result() {
  local storage_url
  storage_url=$(curl --fail-with-body --silent --show-error \
    "https://api.flashdata.dev/v2/bulk-jobs/$BULK_ID/results$1" \
    --header "X-API-Key: ${FLASHDATA_API_KEY:?Set FLASHDATA_API_KEY}" \
    --output /dev/null --write-out '%{redirect_url}') || return
  curl --fail-with-body --silent --show-error --proto '=https' \
    "${storage_url:?Expected a signed result URL}" --output "$2"
}
fetch_bulk_result '' manifest.json &&
jq '{status, counts, parts, expires_at}' manifest.json

# Run in the same Bash session as fetch_bulk_result.
jq -r '.parts[].number' manifest.json | while IFS= read -r PART; do
  fetch_bulk_result "/$PART" "part-$PART.ndjson.gz" || exit
  gzip -dc "part-$PART.ndjson.gz" > "part-$PART.ndjson" || exit
  jq -c '{index, video_id, status, results, error}' "part-$PART.ndjson"
done
```


- [Problem](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-Problem)

<a id="downloadBulkJobPart-responses"></a>

### जवाब

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

#### 200 · application/x-ndjson

```json
{
  "type": "string"
}
```


<a id="states"></a>

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

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

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

- [त्रुटियाँ और स्टेटस कोड](https://flashdata.dev/hi/docs/errors/reference.md)
- [एक pause Bulk नौकरी को पुनर्प्राप्त करें](https://flashdata.dev/hi/docs/guides/bulk/reference.md#controls)

<a id="storage"></a>

## भंडारण वितरण

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

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

- [प्रदाता क्रेडेंशियल फ़ील्ड](https://flashdata.dev/hi/docs/sources/youtube_download/reference.md#storage)
- [एक भंडारण गंतव्य को कॉन्फ़िगर करें](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#playground)

<a id="storage-layout"></a>

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

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

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

#### डेटा ऑब्जेक्ट लेआउट

```text
<prefix>/<source>/<bulkId>/results/part-NNNNNNNN.jsonl.gz
<prefix>/<source>/<bulkId>/manifest.json
```


<a id="webhooks"></a>

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

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

1. Persist और deduplicate delivery_id, फिर तुरंत 2xx वापस लौटें। डिलीवरी बैकऑफ के साथ आठ बार तक की जाती है।
2. घटनाओं को त्याग नहीं दिया जाता है। अपने सहेजे गए रसीद को आईडी और स्रोत से मिलान करें; पुनर्प्राप्ति को समाप्त करने से पहले प्रमाणित प्रबंधन API के माध्यम से पूरा किया गया सत्यापित करें। एक एकीकृत घटना से URLs को अनदेखा करें।

### कॉलबैक के साथ अनुरोध करें

```json
{
  "source": "youtube_metadata",
  "options": {
    "include_formats": false,
    "include_chapters": false
  },
  "callback_url": "https://your-app.example/webhooks/flashdata"
}
```

### Completion event · illustrative

```json
{
  "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"
    }
  ]
}
```

- [एक नोड वेबहुक रिसीवर उत्पन्न करें](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#playground)

<a id="schemas"></a>

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

- [BulkJobCreated](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-BulkJobCreated)
- [BulkJob](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-BulkJob)
- [BulkJobPage](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-BulkJobPage)
- [BulkJobResponse](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-BulkJobResponse)
- [CreateBulkJobRequest](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-CreateBulkJobRequest)
- [JobLink](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-JobLink)
- [Pagination](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-Pagination)
- [Problem](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-Problem)
- [FieldError](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-FieldError)
- [UpdateBulkJobRequest](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-UpdateBulkJobRequest)

<a id="schema-BulkJobCreated"></a>

### BulkJobCreated

#### BulkJobCreated

```json
{
  "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](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-BulkJob)

<a id="schema-BulkJob"></a>

### BulkJob

#### BulkJob

```json
{
  "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"
      }
    }
  }
}
```

- [JobLink](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-JobLink)

<a id="schema-BulkJobPage"></a>

### BulkJobPage

#### BulkJobPage

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

- [BulkJob](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-BulkJob)
- [Pagination](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-Pagination)

<a id="schema-BulkJobResponse"></a>

### BulkJobResponse

#### BulkJobResponse

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

- [BulkJob](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-BulkJob)

<a id="schema-CreateBulkJobRequest"></a>

### CreateBulkJobRequest

#### CreateBulkJobRequest

```json
{
  "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."
    }
  }
}
```


<a id="schema-JobLink"></a>

### JobLink

#### JobLink

```json
{
  "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
    }
  }
}
```


<a id="schema-Pagination"></a>

### Pagination

#### Pagination

```json
{
  "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
    }
  }
}
```


<a id="schema-Problem"></a>

### Problem

#### Problem

```json
{
  "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](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#schema-FieldError)

<a id="schema-FieldError"></a>

### FieldError

#### FieldError

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


<a id="schema-UpdateBulkJobRequest"></a>

### UpdateBulkJobRequest

#### UpdateBulkJobRequest

```json
{
  "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."
    }
  }
}
```

