# Bulk फ़ाइल प्रसंस्करण

वीडियो IDs की एक फ़ाइल की प्रक्रिया करें, अपने आवेदन में डेटासेट आयात करने से पहले हर परिणाम भाग को पुनर्प्राप्त करें और कवरेज की जांच करें।

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

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

## एक ID फ़ाइल से एक चेक डेटासेट तक

इस वर्कफ़्लो का उपयोग वीडियो कैटलॉग, अनुसंधान संग्रह या ingestion कतार के लिए किया जाता है। एक फ़ाइल प्रत्येक ID के लिए एक स्रोत और समान विकल्प का उपयोग करती है। दो वीडियो मेटाडाटा नमूना के साथ शुरू करें, फिर अपनी खुद की फ़ाइल को प्रतिस्थापित करें।

### इस वर्कफ़्लो द्वारा निर्मित फ़ाइलें

```text
video-ids.txt → Bulk कार्य → bulk-results.ndjson
  → audit/completed.ndjson आपके अनुप्रयोग के लिए परिणाम
  → audit/failed-video-ids.txt ने समीक्षा करने में विफलता की पुष्टि की
  → audit/missing.ndjson इनपुट जिसका परिणाम लापता हैं
  → audit/summary.json कवरेज और परिणाम गिनती
```

- [एक छोटी सूची के साथ आवेदन रिकॉर्ड IDs रखें](https://flashdata.dev/hi/docs/guides/enrich-youtube-videos/reference.md)
- [Batch बनाम Bulk](https://flashdata.dev/hi/docs/reference/batch-and-bulk/reference.md#choose)
- [Bulk API खेल का मैदान](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#playground)
- [YouTube वीडियो बल्क डाउनलोड](https://flashdata.dev/hi/products/youtube-download#bulk-downloads)

<a id="before-you-start"></a>

## शुरू करने से पहले

CLI स्थापित करें और youtube_metadata अनुमति के साथ मौजूदा प्रोफ़ाइल या FLASHDATA_API_KEY का उपयोग करें। data.accessVerified: true की पुष्टि करें और उपलब्ध शेष राशि, दो अनुरोधों और वर्तमान सीमाओं के लिए मूल्य निर्धारण की समीक्षा करें। अपनी खुद की फ़ाइल के लिए, मूल्य निर्धारण की जांच करते समय अपनी ID गिनती का उपयोग करें। प्रत्येक संसाधित ID एक अलग क्वेरी है, फ़ाइल के लिए एक फ्लैट चार्ज नहीं है।

Bash का प्रयोग jq या PowerShell 7 के साथ चरणों 1–3 के लिए किया जाता है। चरण 4 में वैकल्पिक आयात लेखा परीक्षा Python 3.10+ और इसकी मानक पुस्तकालय का उपयोग करती है। CLI को स्वयं ही Node.js और Python की आवश्यकता नहीं है।

### नि: शुल्क पहुँच और खाता चेक

```bash
flashdata auth status --json
flashdata account balance --json
flashdata account pricing --source youtube_metadata --request-count 2
flashdata account limits
```

- [CLI स्थापित करें](https://flashdata.dev/hi/docs/guides/flashdata-cli/reference.md#install)
- [एक API कुंजी बनाएँ](https://flashdata.dev/app/api-keys)
- [एजेंट एक्सेस और दावा करना](https://flashdata.dev/hi/docs/guides/agent-access/reference.md)
- [इसके बजाय HTTP का उपयोग करें](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#endpoints)

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

## 1. IDs तैयार करें

एक नए काम करने वाले फ़ोल्डर में भाग लें। एक 11-character वीडियो ID प्रति लाइन के साथ UTF-8 टेक्स्ट का प्रयोग करें, एक YouTube URL नहीं। अधिकतम फ़ाइल का आकार 2 GiB है। खाली लाइनों और डुप्लिकेट निकालें: CLI विकृत इनपुट को अस्वीकार करता है, और बार-बार IDs को अलग से संसाधित किया जाता है।

### Bash

#### Bash

```bash
# Run in a new working directory.
(
  set -euC
  printf '%s\n' 'jNQXAC9IVRw' 'dQw4w9WgXcQ' > video-ids.txt
)
cat video-ids.txt
```


### PowerShell 7

#### PowerShell 7

```powershell
if (Test-Path -LiteralPath video-ids.txt) { throw 'Keep the existing file or use a new folder.' }
$idsFile = Join-Path (Get-Location) 'video-ids.txt'
$idsText = [string]::Join([char]10, @('jNQXAC9IVRw', 'dQw4w9WgXcQ', ''))
[IO.File]::WriteAllText($idsFile, $idsText, [Text.UTF8Encoding]::new($false))
Get-Content -LiteralPath video-ids.txt
```



<a id="run"></a>

## 2. फ़ाइल को चलाएं

CLI एक नौकरी बनाता है, फ़ाइल को अपलोड करता है, प्रत्येक परिणाम को एक NDJSON फ़ाइल में संसाधित करना शुरू कर देता है। एक नए आउटपुट पथ का प्रयोग करें। स्थानीय रन ID थोक-पहली बार वसूली के लिए दूरस्थ नौकरी रसीद रखता है।

### Bash

#### Bash

```bash
flashdata bulk run --source youtube_metadata \
  --input video-ids.txt --run-id bulk-first \
  --output bulk-results.ndjson --timeout 30m --json
```


### PowerShell 7

#### PowerShell 7

```powershell
flashdata bulk run --source youtube_metadata `
  --input video-ids.txt --run-id bulk-first `
  --output bulk-results.ndjson --timeout 30m --json
```


- [किसी अन्य टर्मिनल में प्रगति की जाँच करें](https://flashdata.dev/hi/docs/guides/bulk/reference.md#progress)
- [एक टाइमआउट के बाद पुनर्प्राप्त करें](https://flashdata.dev/hi/docs/guides/bulk/reference.md#controls)

<a id="results"></a>

## 3. परिणामों का निरीक्षण करना

ओपन bulk-results.ndjson प्रत्येक लाइन इंडेक्स, video_id और स्टेटस के साथ एक JSON रिकॉर्ड है। सफल पंक्तियों में एक परिणाम सारणी होती है; असफल पंक्तियों में त्रुटि होती है। शून्य-आधारित सूचकांक द्वारा इनपुट में रिकॉर्ड में शामिल हों, फ़ाइल ऑर्डर नहीं। Bash कमांड jq का उपयोग करता है।

### एक सफल पंक्ति · संक्षिप्त उदाहरण

```json
{"index":0,"video_id":"jNQXAC9IVRw","source":"youtube_metadata","status":"completed","results":[{"videoId":"jNQXAC9IVRw","title":"Example video title"}]}
```

### Bash

#### Bash

```bash
# Bash + jq: read each record without loading the whole file.
jq -c '{index, video_id, status, title: .results[0].title, error}' bulk-results.ndjson
```


### PowerShell 7

#### PowerShell 7

```powershell
Get-Content -LiteralPath bulk-results.ndjson | ForEach-Object {
  $row = $_ | ConvertFrom-Json
  $title = if ($row.results) { $row.results[0].title } else { $null }
  [pscustomobject]@{ index = $row.index; video_id = $row.video_id; status = $row.status; title = $title; error = $row.error }
}
```



<a id="audit"></a>

## 4. आयात करने से पहले कवरेज की जाँच करें

नीचे audit-bulk.py सहेजें। इसे अपरिवर्तित इनपुट फ़ाइल और सभी पुनः प्राप्त परिणाम भागों के खिलाफ चलाएं। यह प्रत्येक सूचकांक, वीडियो ID और स्रोत की जांच करता है, डुप्लिकेट परिणाम पंक्तियों को अस्वीकार करता है, और लापता परिणामों से पुष्टि की विफलताओं को अलग करता है। एक अन्य स्रोत के लिए, --source SOURCE_ID जोड़ें।

Expect inputRows: 2, पूरा: 2, विफल: 0, लापता: 0 और allSucceeded: true सफल नमूने के लिए। केवल पूर्ण पंक्तियां आवेदन के परिणाम आयात में हैं। उनके साथ लेखा परीक्षा सारांश और असफल परिणाम रखें।


<a id="audit-script"></a>

### बचाओ audit-bulk.py

audit-bulk.py को video-ids.txt और bulk-results.ndjson के बगल में कार्य फ़ोल्डर में बनाया गया है। नीचे दिए गए कोड को कॉपी करें और इसे सहेजें।

स्क्रिप्ट लाइन से फ़ाइलों को लाइन पढ़ता है और मेमोरी में पूरे डेटासेट को लोड करने के बजाय स्थानीय SQLite सूचकांक का उपयोग करता है। इसके लिए वीडियो IDs की एक मान्य इनपुट फ़ाइल की आवश्यकता होती है। प्रत्येक लेखा परीक्षा एक नई आउटपुट डायरेक्टरी का उपयोग करती है; आंशिक फाइलें पार्सिंग फिनिश तक अलग रहती हैं।

#### audit-bulk.py

```python
# audit-bulk.py — Python 3.10+, standard library only; no network requests.
import argparse
import json
import re
import sqlite3
import sys
from contextlib import ExitStack
from pathlib import Path

parser = argparse.ArgumentParser()
parser.add_argument('--input', required=True)
parser.add_argument('--results', required=True)
parser.add_argument('--out', required=True)
parser.add_argument('--source', default='youtube_metadata')
args = parser.parse_args()
out = Path(args.out)
try:
    out.mkdir()  # Keep any previous audit. Use a new directory for another attempt.
    with ExitStack() as stack:
        db = sqlite3.connect(out / 'index.sqlite')
        stack.callback(db.close)
        db.execute('CREATE TABLE inputs (idx INTEGER PRIMARY KEY, video_id TEXT, outcome TEXT)')
        count = 0
        with open(args.input, encoding='utf-8-sig') as inputs:
            for index, line in enumerate(inputs):
                video_id = line.strip()
                if not re.fullmatch(r'[A-Za-z0-9_-]{11}', video_id):
                    raise ValueError('Invalid ID on input line ' + str(index + 1))
                db.execute('INSERT INTO inputs VALUES (?, ?, NULL)', (index, video_id))
                count += 1
        if not count:
            raise ValueError('The input file is empty.')
        db.commit()
        files = {name: stack.enter_context(open(out / (name + '.part'), 'x', encoding='utf-8'))
                 for name in ['completed.ndjson', 'failed.ndjson', 'missing.ndjson', 'failed-video-ids.txt']}
        completed = failed = 0
        with open(args.results, encoding='utf-8-sig') as results:
            for line_number, line in enumerate(results, 1):
                if not line.strip():
                    continue
                row = json.loads(line)
                if not isinstance(row, dict) or type(row.get('index')) is not int:
                    raise ValueError('Invalid result index on line ' + str(line_number))
                expected = db.execute('SELECT video_id, outcome FROM inputs WHERE idx = ?',
                                      (row['index'],)).fetchone()
                if (not expected or row.get('video_id') != expected[0]
                        or row.get('source') != args.source or expected[1] is not None):
                    raise ValueError('Unknown, duplicate or mismatched result on line ' + str(line_number))
                status = row.get('status')
                if status not in ['completed', 'failed']:
                    raise ValueError('Unexpected item status on line ' + str(line_number))
                if status == 'completed':
                    if not isinstance(row.get('results'), list):
                        raise ValueError('Completed row is missing its results array.')
                    if args.source == 'youtube_metadata' and (len(row['results']) != 1
                            or not isinstance(row['results'][0], dict)
                            or row['results'][0].get('videoId') != expected[0]):
                        raise ValueError('Metadata does not belong to the requested video.')
                    completed += 1
                else:
                    failed += 1
                db.execute('UPDATE inputs SET outcome = ? WHERE idx = ?', (status, row['index']))
                files[status + '.ndjson'].write(json.dumps(row, ensure_ascii=False) + '\n')
        db.commit()
        missing = 0
        for index, video_id in db.execute('SELECT idx, video_id FROM inputs WHERE outcome IS NULL ORDER BY idx'):
            files['missing.ndjson'].write(json.dumps({'index': index, 'video_id': video_id,
                                                     'status': 'missing_result'}) + '\n')
            missing += 1
        for (video_id,) in db.execute("SELECT video_id FROM inputs WHERE outcome = 'failed' GROUP BY video_id ORDER BY MIN(idx)"):
            files['failed-video-ids.txt'].write(video_id + '\n')
        summary = {'source': args.source, 'inputRows': count, 'completed': completed,
                   'failed': failed, 'missing': missing, 'coverageComplete': missing == 0,
                   'allSucceeded': failed == 0 and missing == 0}
    for name in files:
        (out / (name + '.part')).rename(out / name)
    with open(out / 'summary.json', 'x', encoding='utf-8') as output:
        json.dump(summary, output, indent=2)
    print(json.dumps(summary, indent=2))
    sys.exit(0 if summary['allSucceeded'] else 2)
except Exception as error:
    print(str(error), file=sys.stderr)
    print('Audit not complete. Preserve this directory and inspect the inputs/results.', file=sys.stderr)
    sys.exit(1)
```


<a id="run-audit"></a>

### आयात लेखा परीक्षा चलायें

स्क्रिप्ट, मूल इनपुट और डाउनलोड किए गए परिणामों वाले फ़ोल्डर से भाग लें। लेखा परीक्षा केवल स्थानीय फाइलों को पढ़ती है।

#### Bash

##### Bash

```bash
python3 audit-bulk.py --input video-ids.txt --results bulk-results.ndjson --out audit
```


#### PowerShell 7

##### PowerShell 7

```powershell
python audit-bulk.py --input video-ids.txt --results bulk-results.ndjson --out audit
```



<a id="import"></a>

### पूर्ण पंक्तियों को आयात करें और लेखा परीक्षा रखें

| फ़ाइल / संकेत | इसे इस तरह से इस्तेमाल करें |
| --- | --- |
| completed.ndjson | सूचकांक से मूल फ़ाइल में शामिल हों। एक सूची कुंजी के लिए video_id का उपयोग करें; ताज़ा इतिहास के भंडारण के दौरान job/snapshot पहचान को बनाए रखें। |
| failed.ndjson + failed-video-ids.txt | इन IDs को जानबूझकर पुनः प्राप्त करने से पहले त्रुटियों की समीक्षा करें। सफल और लापता आइटम असफल ID सूची से बाहर रखा गया है। |
| missing.ndjson | मौजूदा नौकरी से सभी परिणाम भागों को पुनर्प्राप्त करें, फिर पुनर्प्राप्त फ़ाइल को एक नई डायरेक्टरी में ऑडिट करें। मिसिंग आउटपुट की पुष्टि नहीं हुई है। |
| summary.json | coverageComplete यह जाँचता है कि प्रत्येक इनपुट का परिणाम है। allSucceeded को भी कोई असफल वीडियो की आवश्यकता नहीं है। लेखा परीक्षा असफलता या लापता पंक्तियों के लिए 2 से बाहर निकलती है। |
| Exit 1 / No summary.json | विकृत या गलत डेटा: सहेजी गई फ़ाइलों का निरीक्षण करें। एक पूर्ण डेटासेट के रूप में आंशिक लेखा परीक्षा को प्रकाशित न करें। |

- [मौजूदा परिणामों को पुनर्प्राप्त करें](https://flashdata.dev/hi/docs/guides/bulk/reference.md#controls)
- [परिणाम प्रतिधारण](https://flashdata.dev/hi/docs/guides/save-results/reference.md#bulk)

<a id="item-failures"></a>

## अगर कुछ वीडियो विफल हो गए

एक पूर्ण Bulk नौकरी में विफल वीडियो हो सकते हैं। CLI उन पंक्तियों को भी बचाता है, फिर bulk_item_failures के साथ निकलता है। यह तय करने से पहले अपनी त्रुटियों का निरीक्षण करें कि व्यक्तिगत IDs को पुनः प्राप्त करना है या नहीं; पूरी फ़ाइल को स्वचालित रूप से दोहराना नहीं है।

### केवल असफल रिकॉर्ड दिखाएं · jq

```bash
jq -c 'select(.status != "completed") | {index, video_id, status, error}' bulk-results.ndjson
```


<a id="progress"></a>

## ट्रैक प्रगति और क्षमता

जबकि मूल आदेश चलता है बचाया नौकरी पढ़ें। CLI डेटा के तहत स्थिति लपेटता है; प्रत्यक्ष HTTP इसे नौकरी के तहत लपेटता है। एक देरी और backoff के साथ जाँच करें, और 429 पर Retry-After को सम्मान दें। एक स्थानीय टाइमआउट या बंद टर्मिनल दूरस्थ काम को रद्द नहीं करता है।

| फील्ड | इसे पढ़िए |
| --- | --- |
| input.scannedBytes / input.bytes | फ़ाइल स्कैन की प्रगति, पूर्ण क्वेरी या अपलोड की गई मीडिया नहीं। |
| input.complete | सभी इनपुट पढ़ा गया है; प्रश्नों और परिणाम पैकेजिंग अभी भी चल सकता है। |
| counts.accepted / completed / failed | जमा हुआ IDs, सफल वीडियो और असफल वीडियो। बकाया = स्वीकार किए जाते हैं - पूरा हो गया। |
| counts.invalid / results | अब तक पैक किए गए इनपुट लाइन / रिकॉर्ड। HTTP उन फ़ाइलों को स्वीकार कर सकता है जिनमें अवैध रेखाएं शामिल हैं; CLI अपलोड करने से पहले इनपुट को मान्य करता है। |
| delivery | ग्राहक डेटा वितरण: uploadedParts, retryCount, storageType और customerStorage. प्रत्येक वीडियो के मीडिया अपलोड से अलग है। |

### Bash

#### Bash

```bash
(
set -eu
BULK_ID=$(flashdata runs show bulk-first --json | jq -er '.data.remoteId')
flashdata bulk get "$BULK_ID" --json
)
```


### PowerShell 7

#### PowerShell 7

```powershell
$run = flashdata runs show bulk-first --json | ConvertFrom-Json
if ($LASTEXITCODE -ne 0 -or -not $run.data.remoteId) { throw 'Read the saved run before continuing.' }
flashdata bulk get $run.data.remoteId --json
```



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

### जब तक प्रतीक्षा या कार्य करना

Bulk धीरे-धीरे आपके खाते की maxPendingJobs क्षमता के भीतर जमा करता है, जो अन्य नौकरियों के साथ साझा होता है। अपर्याप्त क्रेडिट या निष्क्रिय सदस्यता नौकरी को रोक सकती है। Resuming से पहले pauseReason की जाँच करें।

| राज्य | अगली कार्रवाई |
| --- | --- |
| awaiting_upload | फ़ाइल को अपलोड करें, फिर मौजूदा नौकरी शुरू करें। |
| running / finalizing | प्रतीक्षा करें अंतिम रूप देने में अधूरे प्रश्नों, पैकेजिंग और भंडारण वितरण शामिल हो सकते हैं। |
| paused | pauseReason को हल करें और उसी काम को फिर से शुरू करें। |
| completed | सभी परिणाम भागों को डाउनलोड करें और असफल पंक्तियों का निरीक्षण करें। |
| failed / cancelled | Inspect job.error और बचाया रसीद। स्वीकृत कार्य अभी भी finish हो सकता है; कोई पूर्ण प्रकटन प्रकाशित नहीं किया गया है। |


<a id="controls"></a>

## एक बाधित वर्कफ़्लो फिर से शुरू करें

एक स्थानीय टाइमआउट या बाधित परिणाम डाउनलोड के बाद, थोक-पहली बार पुनर्प्राप्त करें। यह मौजूदा दूरस्थ नौकरी पढ़ता है; यह फिर से डेटासेट जमा नहीं करता है। एक नया आउटपुट फ़ाइल नाम का उपयोग करें। एक partial_result त्रुटि एक आंशिक स्थानीय फ़ाइल छोड़ सकती है; इसे पुनर्प्राप्त परिणाम से अलग रखें।

उसी CLI प्रोफाइल और स्टेट डाइरेक्टरी का उपयोग करें। एक नामित प्रोफ़ाइल के लिए, प्रत्येक कमांड में --profile नाम जोड़ें।

| स्थिति | फिक्स |
| --- | --- |
| awaiting_upload | runs recover एक अपलोड या प्रारंभ नहीं होता है। बचाया ID, स्पष्ट रूप से जारी रहने से पहले स्थिति और मूल फ़ाइल अपलोड करें। |
| paused | रिपोर्ट किए गए कारण को हल करें, फिर बचाए गए ID के साथ बल्क रिज्यूमे का उपयोग करें। रिकवरी स्वचालित रूप से प्यूज्ड काम को फिर से शुरू नहीं करती है। |
| 401 / 403 | जमा करने वाले खाते और स्रोत तक वैध पहुंच को पुनर्स्थापित करें। प्रमाणीकरण के बाद उसी काम को फिर से शुरू करें। |
| 409 / 410 | 409: परिणाम तैयार नहीं हैं। 410: संग्रहीत परिणाम समाप्त हो गए; अपनी सहेजी गई प्रतिलिपि का उपयोग करें। |
| Expired upload URL | पुराने काम की पुष्टि करने से पहले कभी एक नया बनाने शुरू नहीं हुआ। एक अनिश्चित प्रस्तुतीकरण पहले अपने बचाया ID पढ़ने का एक कारण है। |

### बचाया रन को पुनर्प्राप्त करें

```bash
flashdata runs show bulk-first --json
flashdata runs recover bulk-first --output recovered-results.ndjson --timeout 30m --json
```

- [CLI रिकवरी और आवर्ती रन](https://flashdata.dev/hi/docs/guides/cli-automation/reference.md#recover)
- [दर सीमा](https://flashdata.dev/hi/docs/guides/usage-and-limits/reference.md)

<a id="pause"></a>

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

BULK_ID को ID के साथ runs show बल्क-फ़र्स्ट से बदलें। Pause नए प्रस्तुतियों और परिणाम पैकेजिंग बंद हो जाता है; स्वीकार किए गए प्रश्नों जारी है। Resuming से पहले pauseReason को हल करें। बदल विकल्प या भंडारण क्रेडेंशियल के लिए, मौजूदा नौकरी को Bulk API के माध्यम से अद्यतन करें।

#### पौलुस

```bash
flashdata bulk pause BULK_ID --json
```

#### कारण को ठीक करने के बाद फिर से शुरू करें

```bash
flashdata bulk resume BULK_ID --json
```

- [Bulk नौकरी अद्यतन करें](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#updateBulkJob)

<a id="cancel"></a>

### स्थायी रूप से रद्द करना

जब आप नौकरी छोड़ने का इरादा रखते हैं तो केवल रद्द कर दिया जाता है। रद्द करना स्वीकार किए गए प्रश्नों को रद्द नहीं करता है या पूरा काम वापस नहीं करता है। गणना अभी भी बदल सकती है, और कोई पूर्ण प्रकट प्रकाशित नहीं होता है। प्यूस प्रतिवर्ती है।

#### चुने हुए काम को रद्द करना

```bash
flashdata bulk cancel BULK_ID --json
```


<a id="manifest"></a>

## प्रत्येक परिणाम भाग को पुनर्प्राप्त करें

एक मौजूदा पूर्ण नौकरी के लिए, CLI अपने प्रकटन का अनुसरण करता है और प्रत्येक परिणाम को एक NDJSON फ़ाइल में सहेजता है। एक नए आउटपुट पथ का उपयोग करें और संयुक्त फ़ाइल पर आयात लेखा परीक्षा चलाएं। डाउनलोड परिणाम वितरित मीडिया का वर्णन करते हैं; वे एमपी 4 या ऑडियो बाइट नहीं हैं।

### एक मौजूदा नौकरी से सभी भागों को आकर्षित करें

```bash
flashdata bulk results BULK_ID --output saved-results.ndjson --timeout 30m --json
```

- [डेटासेट कवरेज की जाँच करें](https://flashdata.dev/hi/docs/guides/bulk/reference.md#audit)
- [मैनिफेस्ट, भागों और प्रतिधारण संदर्भ](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md#downloadBulkJobManifest)

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

## अपने भंडारण के लिए वितरित करें

इस आदेश को चलाने से पहले अपने प्रदाता को कार्य फ़ोल्डर में storage.json के रूप में क्रेडेंशियल्स को कार्य करने से पहले सहेजें। नीचे जुड़े प्रदाता फ़ील्ड का उपयोग करें; फ़ाइल को निजी रखें। CLI की --storage-config ने इस JSON फ़ाइल को पढ़ा और मीडिया के लिए डेटा या स्टोरेज के लिए result_storage का चयन किया। --options एक फ़ाइल पथ भी लेता है, न कि JSON को इनलाइन करता है।

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

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

### बचाया भंडारण विन्यास के साथ भागो

#### मेटाडाटा वर्कफ़्लो में भंडारण जोड़ें

```bash
flashdata bulk run --source youtube_metadata --input video-ids.txt --storage-config storage.json --run-id bulk-with-storage --output stored-results.ndjson --timeout 30m --json
```

