# एक वीडियो के मेटाडाटा को पुनर्प्राप्त करें

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

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

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

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

youtube_metadata अनुमति और उपलब्ध क्रेडिट के साथ एक कुंजी का उपयोग करें। Python 3.10+ को अनुरोधों के साथ चुनें, या Bash को cURL 7.76+ और jq के साथ चुनें। Windows पर, Git Bash का उपयोग Bash संस्करण के लिए किया जाता है।

- [API कुंजी लें](https://flashdata.dev/app/api-keys)
- [एजेंट ट्रायल और खाता लिंक करना](https://flashdata.dev/hi/docs/guides/agent-onboarding/reference.md)
- [ऋण और मूल्य निर्धारण](https://flashdata.dev/hi/docs/guides/credits-and-billing/reference.md)

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

## 1. एक वीडियो चुनें

एक वीडियो-metadata फ़ोल्डर बनाएं और वहां request.json को सेव करें। उस फ़ोल्डर में एक टर्मिनल खोलें। video_id को 11-character ID के साथ एक घड़ी URL या YouTube Search परिणाम से बदल दें; पूर्ण URL पारित न करें।

स्पष्ट रूप से दोनों वैकल्पिक झंडे सेट करें: यह पहला अनुरोध मीडिया प्रारूपों और अध्यायों को छोड़ देता है। यह वीडियो या इसके कैप्शन को डाउनलोड किए बिना मेटाडाटा को पुनर्प्राप्त करता है।

### video-metadata/request.json

```json
{
  "source": "youtube_metadata",
  "video_id": "FUfGcZ092b0",
  "params": {
    "include_formats": false,
    "include_chapters": false
  }
}
```


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

## 2. मेटाडाटा को आकर्षित और सहेजना

एक संस्करण चुनें और अपनी स्क्रिप्ट को request.json के बगल में सहेजें। यह FLASHDATA_API_KEY पढ़ता है या एक छिपे हुए प्रॉम्प्ट पर अपनी कुंजी के लिए पूछता है। एजेंटों को अपने गुप्त स्टोर से उस पर्यावरण चर को लोड करना चाहिए।

स्नैपशॉट-001 के साथ आउटपुट फ़ोल्डर के रूप में चलाएं। एक नया फ़ोल्डर एक मेटाडाटा क्वेरी भेजता है और इसकी सूचना के उपयोग को बचाता है। एक सफल प्रतिक्रिया के लिए स्क्रिप्ट चेक जिसमें अनुरोध के साथ बिल्कुल एक वीडियो शामिल है ID लेखन से पहले video.json.

### Python

#### अपने Python वातावरण में स्थापित करें

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

#### video-metadata/metadata.py

```python
import argparse
import getpass
import json
import os
import re
from datetime import datetime, timezone
from pathlib import Path

import requests

parser = argparse.ArgumentParser()
parser.add_argument("folder", help="New output folder, or an existing saved snapshot")
out = Path(parser.parse_args().folder)

if not out.exists():
    body = Path("request.json").read_bytes()
    request = json.loads(body)
    if (not isinstance(request, dict) or request.get("source") != "youtube_metadata"
            or not isinstance(request.get("video_id"), str)
            or not re.fullmatch(r"[A-Za-z0-9_-]{11}", request["video_id"])):
        raise SystemExit("Use youtube_metadata and an 11-character video_id, not a URL")
    key = os.environ.get("FLASHDATA_API_KEY") or getpass.getpass("FlashData API key: ")
    if not key.strip():
        raise SystemExit("An API key is required")
    out.mkdir()
    (out / "request.json").write_bytes(body)
    (out / "requested-at.txt").write_text(
        datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"), encoding="utf-8"
    )
    try:
        response = requests.post(
            "https://data.flashdata.dev/v1/queries/realtime",
            headers={"X-API-Key": key, "Content-Type": "application/json",
                     "Accept": "application/json"},
            data=body, timeout=120, allow_redirects=False,
        )
    except requests.RequestException:
        raise SystemExit(f"Request interrupted. Keep {out} and check History before retrying.")
    (out / "result.json").write_bytes(response.content)
    (out / "response-headers.txt").write_text(
        "\n".join(f"{k}: {v}" for k, v in response.headers.items()), encoding="utf-8"
    )
    (out / "http-status.txt").write_text(str(response.status_code), encoding="utf-8")
else:
    print(f"Reading saved response from {out}; no API call.")

if not (out / "http-status.txt").exists():
    raise SystemExit("Incomplete attempt. Keep the folder and check History before retrying.")
status = (out / "http-status.txt").read_text().strip()
if status != "200":
    raise SystemExit(f"HTTP {status}: inspect {out}/result.json and response-headers.txt")
try:
    data = json.loads((out / "result.json").read_bytes())
except ValueError:
    raise SystemExit("Invalid JSON; inspect the saved result.json")
request = json.loads((out / "request.json").read_bytes())
if not isinstance(data, dict) or data.get("source") != "youtube_metadata" or data.get("status") != "done":
    raise SystemExit("Metadata request did not finish successfully; inspect result.json")
videos = data.get("results")
if (not isinstance(videos, list) or len(videos) != 1 or not isinstance(videos[0], dict)
        or videos[0].get("videoId") != request["video_id"]):
    raise SystemExit("Expected one metadata object matching the requested video_id")
record = {
    "request": request,
    "requested_at": (out / "requested-at.txt").read_text().strip(),
    "usage": data.get("usage"), "result_file": "result.json",
}
for filename, value in (("video.json", videos[0]), ("record.json", record)):
    (out / filename).write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
print(f"Saved {videos[0]['videoId']} to {out}/video.json")
```

#### वीडियो-metadata से भागो/

```bash
python metadata.py snapshot-001
```


### Bash

#### अपने उपकरण की जाँच करें

```bash
curl --version
jq --version
```

#### video-metadata/metadata.sh

```bash
#!/usr/bin/env bash
set -euo pipefail
out="${1:?Usage: bash metadata.sh OUTPUT_FOLDER}"

if [[ ! -e "$out" ]]; then
  jq -e '.source == "youtube_metadata" and
    (.video_id | if type == "string" then length == 11 and test("^[A-Za-z0-9_-]{11}$")
     else false end)' request.json > /dev/null
  if [[ -z "${FLASHDATA_API_KEY:-}" ]]; then
    read -r -s -p "FlashData API key: " FLASHDATA_API_KEY
    printf '\n'
  fi
  : "${FLASHDATA_API_KEY:?An API key is required}"
  mkdir -- "$out"
  cp request.json "$out/request.json"
  date -u +'%Y-%m-%dT%H:%M:%SZ' > "$out/requested-at.txt"
  curl --fail-with-body --silent --show-error --max-time 120 \
    --request POST 'https://data.flashdata.dev/v1/queries/realtime' \
    --header "X-API-Key: $FLASHDATA_API_KEY" \
    --header 'Content-Type: application/json' --header 'Accept: application/json' \
    --data-binary "@$out/request.json" \
    --dump-header "$out/response-headers.txt" --output "$out/result.json" \
    --write-out '%{http_code}' > "$out/http-status.txt" || {
      printf 'Request failed. Keep %s and inspect its saved files before retrying.\n' "$out" >&2
      exit 1
    }
else
  printf 'Reading saved response from %s; no API call.\n' "$out"
fi

if [[ ! -f "$out/http-status.txt" ]] || [[ "$(cat "$out/http-status.txt")" != 200 ]]; then
  printf 'Incomplete or failed attempt. Inspect the saved files and History before retrying.\n' >&2
  exit 1
fi
video=$(jq -e --slurpfile request "$out/request.json" '
  if .source != "youtube_metadata" or .status != "done"
  then error("Expected a successful youtube_metadata response") else . end
  | .results
  | if type != "array" then error("Expected a metadata array")
    elif length != 1 then error("Expected exactly one video") else .[0] end
  | if type != "object" then error("Expected a metadata object")
    elif .videoId != $request[0].video_id then error("Returned videoId does not match the request")
    else . end' "$out/result.json")
printf '%s\n' "$video" > "$out/video.json"
jq --slurpfile request "$out/request.json" \
  --arg requested_at "$(tr -d '\r\n' < "$out/requested-at.txt")" \
  '{request: $request[0], requested_at: $requested_at, usage, result_file: "result.json"}' \
  "$out/result.json" > "$out/record.json"
printf 'Saved %s to %s/video.json\n' "$(jq -r .videoId "$out/video.json")" "$out"
```

#### वीडियो-metadata से भागो/

```bash
bash metadata.sh snapshot-001
```



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

## 3. वीडियो रिकॉर्ड पढ़ें

सफलता प्रिंट बचाए गए <video ID> को snapshot-001/video.json. उस फ़ाइल को पूर्ण मेटाडाटा ऑब्जेक्ट और record.json के लिए सटीक प्रस्तुत अनुरोध, requested_at और उपयोग के लिए पढ़ें। इन फ़ाइलों को पढ़ना कोई API कॉल नहीं बनाता है।

### Python

#### स्थानीय रूप से पढ़ें

```bash
python -m json.tool snapshot-001/video.json
python -m json.tool snapshot-001/record.json
```


### Bash

#### स्थानीय रूप से पढ़ें

```bash
cat snapshot-001/video.json
cat snapshot-001/record.json
```



<a id="expected"></a>

### उदाहरण

संक्षिप्त, स्पष्ट video.json रिटर्न्ड मान भिन्न होते हैं। स्क्रिप्ट हर उपलब्ध फ़ील्ड को संरक्षित करती है, जिसमें null मान शामिल हैं, और result.json में पूरी प्रतिक्रिया रखता है।

#### video-metadata/snapshot-001/video.json

```json
{
  "videoId": "FUfGcZ092b0",
  "title": "Example research video",
  "channel": "Example channel",
  "duration": 120,
  "viewCount": null,
  "transcriptLanguages": [
    "en"
  ]
}
```


<a id="fields"></a>

### खेतों को पढ़ें

| फील्ड | इसके लिए उपयोग करें |
| --- | --- |
| videoId | रिकॉर्ड की स्थिर कुंजी। शीर्षक और चैनल प्रदर्शन नाम बदल सकते हैं। |
| duration | सेकंड में वीडियो की लंबाई। अज्ञात के रूप में लापता या null मानों को संरक्षित करें। |
| viewCount / likeCount / commentCount | इस स्नैपशॉट में उपलब्ध गिनती। शून्य एक रिपोर्ट की गई गिनती है। |
| transcriptLanguages | एक अलग कैप्शन अनुरोध के लिए उम्मीदवार भाषा कोड। यह सूची यह नहीं पहचानती है कि क्या कोई ट्रैक स्वचालित या मैनुअल है। |


<a id="reuse"></a>

## स्नैपशॉट का पुन: उपयोग करें या किसी अन्य का अनुरोध करें

बचा हुआ जवाब से video.json और record.json के पुनर्निर्माण के लिए उसी कमांड को चलाएं। कोई कुंजी या नेटवर्क अनुरोध की आवश्यकता नहीं है। शीर्ष स्तर request.json को संपादित करने से स्नैपशॉट-001 के साथ संग्रहीत इनपुट को नहीं बदलता है।

### Python

#### Reuse बचाया डेटा

```bash
python metadata.py snapshot-001
```


### Bash

#### Reuse बचाया डेटा

```bash
bash metadata.sh snapshot-001
```


- [परिणाम सहेजें और फिर से उपयोग करें](https://flashdata.dev/hi/docs/guides/save-results/reference.md)

<a id="chapters"></a>

### उपलब्ध अध्यायों को शामिल करें

अध्याय मार्करों को शामिल करने के लिए, इस संस्करण के साथ request.json को प्रतिस्थापित करें और एक नया आउटपुट फ़ोल्डर का उपयोग करें। include_chapters: true उपलब्ध होने पर अध्यायों को वापस लौटाता है; यह उन्हें नहीं बनाता है। दोनों include_chapters और include_formats डिफ़ॉल्ट रूप से true को छोड़ दिया जाता है।

#### video-metadata/request.json

```json
{
  "source": "youtube_metadata",
  "video_id": "FUfGcZ092b0",
  "params": {
    "include_formats": false,
    "include_chapters": true
  }
}
```

#### Python

##### एक अन्य स्नैपशॉट का अनुरोध करें

```bash
python metadata.py snapshot-002
```


#### Bash

##### एक अन्य स्नैपशॉट का अनुरोध करें

```bash
bash metadata.sh snapshot-002
```


- [मेटाडाटा क्षेत्र और विकल्प](https://flashdata.dev/hi/docs/sources/youtube_metadata/reference.md)

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

## यदि मेटाडाटा अनुपलब्ध है

| क्या हुआ | क्या करें |
| --- | --- |
| Invalid video_id | केवल 11-character ID का प्रयोग करें। अनुरोध भेजने से पहले इनपुट सत्यापन बंद हो जाता है। |
| निजी, हटाया या प्रतिबंधित वीडियो | उस ID के लिए असफलता रखें। स्रोत त्रुटि की जाँच करें और उसी आइटम को बार-बार जमा करने के बजाय एक सुलभ वीडियो चुनें। |
| खाली परिणाम या एक अलग videoId | स्क्रिप्ट video.json लिखने के बिना बंद हो जाता है। रिकॉर्ड का उपयोग करने से पहले सहेजे गए अनुरोध और प्रतिक्रिया का निरीक्षण करें। |
| मिसिंग गिनती, अध्यायों या भाषाओं | एक मेलिंग मेटाडाटा रिकॉर्ड अभी भी सफल हो सकता है। अनुपलब्ध फ़ील्ड को अज्ञात रूप में संरक्षित करें; उन्हें आविष्कार मूल्यों के साथ नहीं भरें। |
| 401 / 403 / 402 | एक नए प्रयास से पहले, क्रमश: कुंजी, youtube_metadata अनुमति और शेष राशि की जाँच करें। |
| 429 | Retry-After को response-headers.txt में पढ़ें और प्रतीक्षा करें। स्क्रिप्ट स्वचालित रूप से कभी भी पीछे नहीं आती है। |
| टाइमआउट, 5xx, invalid JSON या एक अधूरा फ़ोल्डर | फिर से जमा करने से पहले प्रयास करें और History को चेक करें। इसके फ़ोल्डर का उपयोग करने से कोई नया अनुरोध नहीं होता है। |

### Python

inspect_metadata.py को metadata.py के बगल में सहेजें, फिर इसे चलाएं।

#### video-metadata/inspect_metadata.py

```python
from pathlib import Path

for name in ("http-status.txt", "response-headers.txt", "result.json"):
    path = Path("snapshot-001") / name
    print(f"--- {name} ---")
    print(path.read_text(encoding="utf-8", errors="replace") if path.exists() else "Not saved")
```

#### स्थानीय रूप से निरीक्षण

```bash
python inspect_metadata.py
```


### Bash

#### स्थानीय रूप से निरीक्षण

```bash
for name in http-status.txt response-headers.txt result.json; do
  printf '\n--- %s ---\n' "$name"
  if [[ -f "snapshot-001/$name" ]]; then cat "snapshot-001/$name"; else printf 'Not saved\n'; fi
done
```


- [अनुरोध इतिहास](https://flashdata.dev/app/jobs)
- [त्रुटियाँ और स्टेटस कोड](https://flashdata.dev/hi/docs/errors/reference.md)

<a id="next"></a>

## अपने वर्कफ़्लो में वीडियो का उपयोग करें

अपने खोज परिणामों या डेटासेट में इस रिकॉर्ड में शामिल होने के लिए videoId का उपयोग करें। बोली जाने वाली सामग्री के लिए, अगले एक विशिष्ट कैप्शन ट्रैक को पुनः प्राप्त करें। कई IDs के लिए, संवर्धन गाइड का उपयोग करें। ये अपनी अनुमति और शुल्क के साथ अलग-अलग अनुरोध हैं।

- [पुनर्प्राप्ति टाइम्सटैम्प्ड कैप्शन](https://flashdata.dev/hi/docs/guides/timestamped-captions-recipe/reference.md)
- [एनरिक चयनित वीडियो IDs](https://flashdata.dev/hi/docs/guides/enrich-youtube-videos/reference.md)
