# YouTube वीडियो की एक सूची को समृद्ध करें

अपनी मूल रिकॉर्ड IDs और हर परिणाम को रखते हुए किसी प्लेलिस्ट, रीडिंग लिस्ट या एप्लिकेशन डेटासेट में मेटाडाटा जोड़ें।

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

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

## अपने रिकॉर्ड से एक समृद्ध डेटासेट तक

तीन रिकॉर्ड के साथ शुरू दो वीडियो का जिक्र करते हैं। प्रत्येक विशिष्ट वीडियो को एक बार क्वेरी करें, फिर मेटाडाटा को सभी तीन रिकॉर्डों में वापस शामिल करें। यह वर्कफ़्लो एक छोटे Batch अनुरोध का उपयोग करता है और असफल वस्तुओं को दिखाई देता है।

| उत्पादन क्षेत्र | उद्देश्य |
| --- | --- |
| record_id · input | मूल क्रम में आपका मूल रिकॉर्ड और फ़ील्ड। |
| video_id · query_index · job_id | प्रत्येक रिकॉर्ड को उस क्वेरी को ट्रेस करें जिसने इसे बनाया था। |
| status · metadata · result_file | एक पूर्ण परिणाम, या एक स्पष्ट pending/failed/read-error परिणाम। |

- [केवल एक ही वीडियो](https://flashdata.dev/hi/docs/guides/video-metadata-recipe/reference.md)
- [एक बड़ी फ़ाइल प्रक्रिया](https://flashdata.dev/hi/docs/guides/bulk/reference.md)
- [Batch बनाम Bulk](https://flashdata.dev/hi/docs/reference/batch-and-bulk/reference.md#choose)

<a id="authenticate"></a>

## 1. अपने उपकरण और एक्सेस की जाँच करें

उपयोग FlashData CLI v.1.2.1 पर PATH और Node.js 22+. अपने मौजूदा मालिक क्रेडेंशियल और youtube_metadata अनुमति के साथ एक नए फ़ोल्डर में भाग लें। Bash और PowerShell नीचे एक ही आदेश का उपयोग करते हैं।

एक ही खाते और प्रोफ़ाइल को पूरे में रखें। एक नामित प्रोफ़ाइल के लिए, इस टर्मिनल में FLASHDATA_PROFILE सेट करें ताकि कलेक्टर भी इसका उपयोग करता है। एजेंट अपने गुप्त स्टोर से FLASHDATA_API_KEY को लोड कर सकते हैं।

### उपकरण और मुफ्त एक्सेस चेक

```bash
flashdata --version
node --version
flashdata auth status --json
mkdir video-enrichment
cd video-enrichment
```

- [CLI स्थापित करें](https://flashdata.dev/hi/docs/guides/flashdata-cli/reference.md#install)
- [एक मालिक कुंजी को कॉन्फ़िगर करें](https://flashdata.dev/hi/docs/guides/cli-automation/reference.md#profiles)

<a id="access-check"></a>

### संतुलन और क्षमता की जाँच करें

मालिक पहुँच की पुष्टि करें, youtube_metadata अनुमति और दो बैच आइटम और लंबित नौकरियों के लिए कमरा। यदि अस्थायी पहुंच अभी भी सक्रिय है, तो दावा करें कि यह एकल-वीडियो नुस्खा का उपयोग करता है। जमा करने से पहले चरण 3 में सूखे रन अनुमान की समीक्षा करें।

#### फ्री खाता पढ़ता

```bash
flashdata account balance --json
flashdata account limits --json
```


<a id="input"></a>

## 2. अपने इनपुट रिकॉर्ड तैयार करें

इसे videos.json के रूप में सहेजें। अपने खुद के रिकॉर्ड IDs और 11-character YouTube वीडियो IDs के साथ मानों को बदलें। अतिरिक्त क्षेत्र स्थानीय मानचित्रण में रहते हैं और उन्हें FlashData को नहीं भेजा जाता है। दोहराया वीडियो IDs की अनुमति है; record_id अद्वितीय होना चाहिए।

### videos.json

```json
[
  {
    "record_id": "lesson-intro",
    "video_id": "jNQXAC9IVRw",
    "collection": "Course"
  },
  {
    "record_id": "playlist-song",
    "video_id": "dQw4w9WgXcQ",
    "collection": "Playlist"
  },
  {
    "record_id": "saved-intro",
    "video_id": "jNQXAC9IVRw",
    "collection": "Reading list"
  }
]
```


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

### बचाओ prepare.mjs

वीडियो-संवर्धन फ़ोल्डर में videos.json के बगल में prepare.mjs बनाएं। नीचे दिए गए कोड को कॉपी करें और इसे सहेजें।

स्क्रिप्ट prepared/. बनाने से पहले हर पंक्ति को मान्य करता है यह आपके मूल रिकॉर्ड और ऑर्डर को बनाए रखते हुए इस मेटाडाटा अनुरोध के लिए वीडियो IDs को डिप्लिकेट करता है।

#### prepare.mjs

```javascript
// prepare.mjs — local preparation; sends no API requests.
import { mkdir, readFile, writeFile } from 'node:fs/promises';

const rows = JSON.parse((await readFile('videos.json', 'utf8')).replace(/^\uFEFF/, ''));
if (!Array.isArray(rows) || rows.length === 0) throw new Error('Supply a nonempty array of records.');
const recordIds = new Set(), videoIndexes = new Map(), queries = [];
const mapping = rows.map((input, index) => {
  if (!input || typeof input !== 'object' || Array.isArray(input)
      || typeof input.record_id !== 'string' || !input.record_id.trim()
      || recordIds.has(input.record_id) || typeof input.video_id !== 'string'
      || !/^[A-Za-z0-9_-]{11}$/.test(input.video_id)) {
    throw new Error('Invalid or duplicate record_id, or invalid video_id at row ' + (index + 1));
  }
  recordIds.add(input.record_id);
  if (!videoIndexes.has(input.video_id)) {
    videoIndexes.set(input.video_id, queries.length);
    queries.push({ source: 'youtube_metadata', video_id: input.video_id,
      params: { include_formats: false } });
  }
  return { input, query_index: videoIndexes.get(input.video_id) };
});
// Existing preparation is kept intact. Use it to resume, or choose a new folder.
await mkdir('prepared');
await writeFile('prepared/batch.json', JSON.stringify(queries, null, 2), { flag: 'wx' });
await writeFile('prepared/input-map.json', JSON.stringify(mapping, null, 2), { flag: 'wx' });
console.log(JSON.stringify({ inputRecords: rows.length, uniqueQueries: queries.length,
  reusedVideoIds: rows.length - queries.length }, null, 2));
```


<a id="prepared"></a>

### स्थानीय रूप से क्वेरी सूची का निर्माण

prepare.mjs को बचाने के बाद, इसे एक बार चलाएं। Expect inputRecords: 3, uniqueQueries: 2 और reusedVideoIds: 1 इस रन के लिए prepared/batch.json और prepared/input-map.json को अपरिवर्तित रखें। यदि तैयार / पहले से ही मौजूद है, तो इसे फिर से शुरू करने के लिए उपयोग करें; एक अलग डेटासेट के लिए एक नया फ़ोल्डर का उपयोग करें।

#### Prepare · कोई API कॉल

```bash
node prepare.mjs
```


<a id="submit"></a>

## 3. पूर्वावलोकन करें और अद्वितीय वीडियो जमा करें

ड्राई रन वास्तविक क्वेरी गिनती, वर्तमान मूल्य निर्धारण और खाता सीमाओं की जाँच करता है। इसे फिर से देखें, फिर एक बार सबमिट करें। नमूना में दो बिलेबल क्वेरी हैं, भले ही इनपुट में तीन रिकॉर्ड हों।

submission.json और CLI राज्य निर्देशिका रखें। उसी रन ID और एक रुकावट के बाद इनपुट का पुन: उपयोग करें। एक नया रन ID नया काम बनाता है; पुनः प्रयास करने से पहले एक अनिश्चित प्रस्तुतीकरण का निरीक्षण करता है।

### प्रस्तुत किए बिना पूर्वावलोकन

```bash
flashdata batch submit --input prepared/batch.json --dry-run --json
```

### अनुमान की समीक्षा करने के बाद जमा करें

```bash
flashdata batch submit --input prepared/batch.json --run-id video-metadata-001 --output submission.json --json
```

- [Batch अनुरोध अनुबंध](https://flashdata.dev/hi/docs/reference/batch-and-bulk/reference.md#batch)

<a id="finish"></a>

## 4. परिणाम एकत्र करना और शामिल करना

नीचे collect.mjs सहेजें, फिर इसे चलाएं। कलेक्टर प्रति अधूरे काम दो मिनट तक इंतजार करता है, सत्यापित करता है कि परिणाम अनुरोधित वीडियो से संबंधित हैं और प्रत्येक परिणाम को मूल रिकॉर्ड में शामिल करता है। एक समय में एक कलेक्टर को चलाएं।

एक ही नौकरी IDs को फिर से शुरू करने के लिए इसे फिर से चलाएं। यह मान्य स्थानीय परिणामों का पुन: उपयोग करता है और कोई नया क्वेरी नहीं भेजता है। एक्सिट कोड 1 का मतलब है कि कुछ परिणाम अभी भी ध्यान देने की जरूरत है; सूची को पुनः प्राप्त करने के बजाय उनका निरीक्षण करें।


<a id="collector"></a>

### बचाओ collect.mjs

उसी वीडियो-संवर्धन फ़ोल्डर में collect.mjs बनाएं, submission.json और prepared/. के बगल में नीचे दिए गए कोड को कॉपी करें और इसे सहेजें।

#### collect.mjs

```javascript
// collect.mjs — reads saved jobs; never submits another query.
import { execFileSync } from 'node:child_process';
import { mkdir, readFile, writeFile, rename } from 'node:fs/promises';

const readJSON = async file => JSON.parse((await readFile(file, 'utf8')).replace(/^\uFEFF/, ''));
const cli = (...args) => JSON.parse(execFileSync('flashdata', [
  ...args, '--json', '--non-interactive', '--timeout', '2m',
], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], maxBuffer: 16 * 1024 * 1024 }));
const inputs = await readJSON('prepared/batch.json');
const mapping = await readJSON('prepared/input-map.json');
const saved = await readJSON('submission.json');
const receipts = (saved.submission ?? saved).queries;
if (!Array.isArray(inputs) || !inputs.length || !Array.isArray(receipts)
    || receipts.length !== inputs.length || new Set(receipts.map(r => r.id)).size !== receipts.length
    || inputs.some(q => q.source !== 'youtube_metadata') || !Array.isArray(mapping) || !mapping.length
    || mapping.some(row => !Number.isInteger(row.query_index)
      || inputs[row.query_index]?.video_id !== row.input?.video_id)) {
  throw new Error('Input/receipt mismatch. Keep the original prepared files and receipt.');
}
await mkdir('results', { recursive: true });
const binding = JSON.stringify({ inputs, mapping, receipts });
try { await writeFile('results/input-receipts.json', binding, { flag: 'wx' }); }
catch (error) {
  if (error.code !== 'EEXIST') throw error;
  if (await readFile('results/input-receipts.json', 'utf8') !== binding) {
    throw new Error('Inputs or receipts changed. Restore the original files.');
  }
}
const rows = inputs.map((input, query_index) => ({ query_index,
  video_id: input.video_id, job_id: receipts[query_index].id, status: 'unread' }));
const saveRows = async (path, values) => {
  await writeFile(path + '.next', values.map(row => JSON.stringify(row)).join('\n') + '\n');
  await rename(path + '.next', path);
};
for (const row of rows) {
  try {
    if (!/^[a-zA-Z0-9_-]+$/.test(row.job_id ?? '')) throw new Error('Invalid job ID.');
    const file = 'results/' + row.job_id + '.json';
    let result;
    try { result = await readJSON(file); }
    catch (error) { if (error.code !== 'ENOENT') throw error; }
    if (!result) {
      let job;
      try { job = cli('jobs', 'wait', row.job_id).data; }
      catch { job = cli('jobs', 'get', row.job_id).data; }
      if (job.videoId !== row.video_id || job.source !== 'youtube_metadata') {
        throw new Error('Job/input mismatch. Inspect the saved input and receipt.');
      }
      row.status = job.status;
      row.error = job.error ?? null;
      if (job.status === 'completed') {
        cli('jobs', 'result', row.job_id, '--output', file);
        result = await readJSON(file);
      }
    }
    if (result) {
      if (result.status !== 'done' || result.source !== 'youtube_metadata'
          || result.results?.length !== 1 || result.results[0].videoId !== row.video_id) {
        throw new Error('Result/video mismatch. Inspect the saved JSON before continuing.');
      }
      Object.assign(row, { status: 'completed', metadata: result.results[0], error: null,
        credits: result.usage?.credits ?? null, result_file: file });
    }
  } catch (error) {
    row.status = 'read_error';
    row.error = error.stderr?.toString().trim() || error.message;
  }
  await saveRows('metadata.ndjson', rows); // One outcome and charge per unique query.
  await saveRows('enriched.ndjson', mapping.map(({ input, query_index }) => {
    const { credits, ...outcome } = rows[query_index]; // Do not duplicate a charge across input records.
    return { record_id: input.record_id, input, ...outcome };
  }));
}
const failed = rows.filter(row => ['failed', 'cancelled'].includes(row.status));
await writeFile('failed-videos.json', JSON.stringify(failed, null, 2));
console.table(rows.map(({ video_id, job_id, status }) => ({ video_id, job_id, status })));
console.log('Saved enriched.ndjson, metadata.ndjson and results/*.json.');
if (rows.some(row => row.status !== 'completed')) process.exitCode = 1;
```


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

### रन या फिर से शुरू कलेक्टर

collect.mjs को बचाने के बाद वीडियो-संवर्धन से भाग लें। मूल CLI प्रोफ़ाइल और राज्य निर्देशिका रखें।

#### इकट्ठा या फिर से शुरू करें

```bash
node collect.mjs
```


<a id="output"></a>

### अपेक्षित फाइलें

| फ़ाइल | इसके लिए उपयोग करें |
| --- | --- |
| enriched.ndjson | प्रति मूल रिकॉर्ड एक पंक्ति, जिसमें डुप्लिकेट और विफलताएं शामिल हैं। record_id द्वारा आयात करें |
| metadata.ndjson | प्रत्येक अद्वितीय क्वेरी के लिए एक पंक्ति, नौकरी ID, परिणाम फ़ाइल और वास्तविक क्रेडिट के साथ। यहां एक बार उपयोग की गणना करें। |
| results/*.json | रॉ सफल उत्तरों के साथ बचाया input/receipt बाइंडिंग। |
| failed-videos.json | समीक्षा के लिए failed/cancelled नौकरियों की पुष्टि की। इस सूची में से लंबित और पढ़ने वाली आतंकवादी नौकरियों को रखा गया है। |


<a id="use-dataset"></a>

## 5. अपने आवेदन में समृद्ध रिकॉर्ड का उपयोग करें

inspect.mjs को Video-enrichment में सेव करें, इसके अलावा enriched.ndjson को उस फ़ोल्डर से चलाएं। तीन मूल रिकॉर्ड और दो अद्वितीय प्रश्नों की उम्मीद है। Upsert ने record_id द्वारा पूर्ण पंक्तियों को पूरा किया, अपने इनपुट फ़ील्ड को बनाए रखा और अपनी आयात रिपोर्ट में दिखाई देने वाली गैर-पूर्ण पंक्तियों को बनाए रखा। मेटाडाटा से शीर्षक और अवधि पढ़ें; लिंक या बाद में कैप्शन अनुरोध के लिए video_id का उपयोग करें।

### inspect.mjs

```javascript
// inspect.mjs — inspect your dataset without another API call.
import { readFile } from 'node:fs/promises';
const rows = (await readFile('enriched.ndjson', 'utf8')).trim().split('\n').map(JSON.parse);
console.table(rows.map(row => ({ record_id: row.record_id, video_id: row.video_id,
  collection: row.input.collection, status: row.status, title: row.metadata?.title ?? null })));
console.log('Original records:', rows.length);
console.log('Unique queries:', new Set(rows.map(row => row.query_index)).size);
```

### शामिल रिकॉर्ड का निरीक्षण करें

```bash
node inspect.mjs
```

- [एक वीडियो के लिए कैप्शन चुनें](https://flashdata.dev/hi/docs/guides/youtube-data-guide/reference.md#captions)

<a id="recover"></a>

## उस आइटम से जारी रखें जिसे ध्यान देने की आवश्यकता होती है

अपने 24-घंटे प्रतिधारण अवधि के भीतर परिणाम सहेजें। पुनरावर्ती ताज़ा करने के लिए, एक नए स्नैपशॉट फ़ोल्डर का उपयोग करें और चलाएं ID केवल जब आप ताजा डेटा के लिए भुगतान करना चाहते हैं; record_id अपने आवेदन में स्थिर।

| Outcome | अगली कार्रवाई |
| --- | --- |
| pending / processing | बाद में कलेक्टर को फिर से चलाएं। उसी काम को रखें IDs. |
| failed / cancelled | failed-videos.json और नौकरी की त्रुटि की समीक्षा करें। उस वीडियो को फिर से अनुरोध करने से पहले कारण को सही करें। |
| read_error | एक्सेस, इनपुट बाइंडिंग या सेव्ड परिणाम को ठीक करें। निरीक्षण के लिए कच्चे फ़ाइल को रखें; एक पढ़ने की त्रुटि का मतलब नहीं है कि एक नई क्वेरी की आवश्यकता है। |
| प्रस्तुतीकरण परिणाम अज्ञात | फिर से जमा करने से पहले स्थानीय रन और History का निरीक्षण करें। |

### सहेजे गए बैच का निरीक्षण करें

```bash
flashdata runs show video-metadata-001 --json
```

- [अनिश्चित कार्य को पुनर्प्राप्त करें](https://flashdata.dev/hi/docs/guides/agent-recovery/reference.md)
- [Bulk के साथ एक बड़ी फ़ाइल संसाधित करें](https://flashdata.dev/hi/docs/guides/bulk/reference.md)
- [परिणाम सहेजें और फिर से उपयोग करें](https://flashdata.dev/hi/docs/guides/save-results/reference.md)
