# YouTube Data सर्वोत्तम प्रथाओं

प्रासंगिक वीडियो खोजें, कैप्शन ट्रैक का चयन करें और नए चैनल अपलोड को दोहराए बिना कार्य को संसाधित करें।

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

<a id="choose"></a>

## पहले से ही आपके पास मौजूद जानकारी के साथ शुरू करें

प्रत्येक स्रोत एक अलग सवाल का जवाब देता है। एक ज्ञात वीडियो ID या चैनल हैंडल के लिए खोज छोड़ें, और केवल उन वीडियो को अपनी कार्य आवश्यकताओं को पूरा करें।

| आपका कार्य | स्रोत | निर्णय |
| --- | --- | --- |
| एक विषय के बारे में वीडियो खोजें | youtube_search | पांच उम्मीदवारों के साथ शुरू करें, फिर प्रासंगिकता का चयन करें। |
| एक ज्ञात वीडियो का निरीक्षण करें | youtube_metadata | शीर्षक, चैनल, अवधि और कैप्शन भाषाओं को प्राप्त करें। |
| क्या कहा गया था? | youtube_transcript / youtube_captions | एक भाषा चुनें और एक स्वचालित या मैनुअल ट्रैक चुनें। |
| हाल के चैनल अपलोड की जाँच करें | youtube_channel | अपने संसाधित IDs के साथ वापस लौटे IDs की तुलना करें। |

- [वीडियो खोजें](https://flashdata.dev/hi/docs/guides/youtube-data-guide/reference.md#discover)
- [एक ज्ञात वीडियो के साथ काम करें](https://flashdata.dev/hi/docs/guides/youtube-data-guide/reference.md#metadata)
- [एक चैनल की निगरानी करें](https://flashdata.dev/hi/docs/guides/youtube-data-guide/reference.md#channel)

<a id="setup"></a>

## अनुरोध उदाहरण चलाएं

प्रत्येक JSON शरीर को अपने प्रदर्शित फ़ाइल नाम का उपयोग करके सहेजें। Python नीचे query.py सहायक का उपयोग करता है; cURL उसी फ़ाइल को जमा कर सकता है। आपको आवश्यक और उपलब्ध क्रेडिट के साथ एक कुंजी का उपयोग करें। प्रत्येक प्रस्तुति एक क्वेरी है, भले ही लौटाए गए वीडियो की संख्या की परवाह किए बिना।

### Python

Python 3.10+. एक बार अनुरोध स्थापित करें, नीचे query.py को सहेज लें, फिर प्रत्येक अनुरोध के बगल में कमांड का उपयोग करें। मौजूदा आउटपुट का पुन: उपयोग किया जाता है; परिवर्तित इनपुट को एक नया आउटपुट फ़ाइल नाम की आवश्यकता होती है।

#### इंस्टॉल करें

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


### cURL

Bash. REQUEST.json और RESULT.json को अपने चुने हुए उदाहरण के लिए फ़ाइल नाम के साथ बदलें। एक अनुरोध को दोहराने से पहले परिणाम की जाँच करें; यह कमांड एक त्रुटि के लिए भी HTTP बॉडी को बचाता है।

#### एक बचाया JSON अनुरोध जमा करें

```bash
(
set -eu
: "${FLASHDATA_API_KEY:?Set FLASHDATA_API_KEY first}"
test ! -e RESULT.json || { echo 'Read RESULT.json first'; exit 1; }
curl --fail-with-body --silent --show-error --max-time 70 \
  --request POST 'https://data.flashdata.dev/v1/queries/realtime' \
  --header "X-API-Key: $FLASHDATA_API_KEY" \
  --header 'Content-Type: application/json' \
  --data-binary @REQUEST.json --output RESULT.json
)
```



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

### अपने API कुंजी सेट करें

अपने टर्मिनल या गुप्त स्टोर से FLASHDATA_API_KEY का पुन: उपयोग करें। अन्यथा नीचे एक छिपे हुए प्रॉम्प्ट का उपयोग करके कुंजी दर्ज करें। इसे इस प्रक्रिया में रखें कि ये उदाहरण चल रहे हैं।

#### Bash

##### कुंजी सेट करें

```bash
# Bash: paste the key into a hidden prompt, not into this command.
read -r -s -p "FlashData API key: " FLASHDATA_API_KEY
printf '\n'
export FLASHDATA_API_KEY
```


#### PowerShell 7

##### कुंजी सेट करें

```powershell
# PowerShell 7: paste the key into a hidden prompt.
$flashdataSecureKey = Read-Host "FlashData API key" -AsSecureString
$env:FLASHDATA_API_KEY = [System.Net.NetworkCredential]::new("", $flashdataSecureKey).Password
Remove-Variable flashdataSecureKey
```


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

<a id="runner"></a>

### Python उदाहरणों के लिए query.py को सहेजें

एक नए काम करने वाले फ़ोल्डर में query.py बनाएं और इसमें नीचे दिए गए पूर्ण कोड को कॉपी करें। इस फ़ोल्डर में अनुरोध JSON फ़ाइलों और अन्य Python स्क्रिप्ट को सेव करें और वहां से सभी कमांड चलाएं।

#### query.py

```python
# query.py — submit a saved request once, then reuse its response.
import json
import os
import sys
from pathlib import Path
import requests

if len(sys.argv) != 3:
    raise SystemExit("Usage: python query.py REQUEST.json RESULT.json")
payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8-sig"))
output = Path(sys.argv[2])
marker = output.with_name(output.name + ".request.json")
receipt = output.with_name(output.name + ".http.json")
if marker.exists():
    if json.loads(marker.read_text()) != payload:
        raise SystemExit("Changed request: choose a new output filename.")
    if not output.exists() or not receipt.exists():
        raise SystemExit("Outcome unknown: check History before resubmitting.")
    saved = json.loads(receipt.read_text())
    if saved["status"] != 200 or json.loads(output.read_text(encoding="utf-8")).get("status") != "done":
        raise SystemExit(f"Saved request failed or incomplete; Retry-After: {saved['retry_after']}. Inspect {output}.")
    print(f"Read the saved {output}; no new query submitted.")
    raise SystemExit(0)
if output.exists():
    raise SystemExit("Output already exists. Read it or choose a new filename.")
key = os.environ["FLASHDATA_API_KEY"]
with marker.open("x", encoding="utf-8") as file:
    json.dump(payload, file)
response = requests.post("https://data.flashdata.dev/v1/queries/realtime",
                         headers={"X-API-Key": key}, json=payload,
                         timeout=70, allow_redirects=False)
output.write_text(response.text, encoding="utf-8")
receipt.write_text(json.dumps({"status": response.status_code,
                               "retry_after": response.headers.get("Retry-After")}), encoding="utf-8")
if response.status_code != 200:
    raise SystemExit(f"HTTP {response.status_code}; Retry-After: {response.headers.get('Retry-After')}")
if response.json().get("status") != "done":
    raise SystemExit(f"Inspect {output} and History before retrying.")
print(json.dumps({"saved": str(output), "usage": response.json().get("usage")}, indent=2))
```


<a id="discover"></a>

## विवरण प्राप्त करने से पहले उम्मीदवारों का पता लगाएं

वीडियो फ़िल्टर अन्य परिणाम प्रकारों को बाहर करता है; उपशीर्षक कैप्शन के साथ वीडियो की खोज को संकीर्ण करता है। यह एक कैप्शन भाषा का चयन नहीं करता है या आपको आवश्यक ट्रैक की गारंटी देता है। discover-request.json के रूप में सहेजें।

### discover-request.json

```json
{
  "source": "youtube_search",
  "query": "battery recycling process explained",
  "params": {
    "max_results": 5,
    "filters": {
      "type": "video",
      "subtitles": true
    }
  }
}
```

### एक बार query.py के साथ जमा करें

```bash
python query.py discover-request.json search.json
```


<a id="candidates"></a>

### प्रासंगिकता द्वारा चयन करें, पहले नहीं ID

candidates.py को query.py और search.json के बगल में सहेजें, फिर इसे उस फ़ोल्डर से चलाएं। यह खोज ऑर्डर रखता है और डुप्लिकेट वीडियो IDs को हटा देता है। इनस्पेक्ट खिताब, चैनल और अवधि, फिर अगले अनुरोध में चयनित ID की प्रतिलिपि बनाएँ। कोई उम्मीदवार के साथ एक खाली सूची पूरी की गई है।

#### candidates.py

```python
# candidates.py — read a saved response; no API calls.
import json
import re
from pathlib import Path

data = json.loads(Path("search.json").read_text(encoding="utf-8"))
if data.get("status") != "done":
    raise SystemExit("Search did not complete; inspect search.json.")
candidates, seen = [], set()
for item in (data.get("results") or [{}])[0].get("results", []):
    video_id = item.get("videoId", "")
    if not re.fullmatch(r"[A-Za-z0-9_-]{11}", video_id) or video_id in seen:
        continue
    seen.add(video_id)
    candidates.append({"videoId": video_id, "title": item.get("title"),
                       "channel": item.get("channel"), "duration": item.get("duration"),
                       "url": "https://www.youtube.com/watch?v=" + video_id})
Path("candidates.json").write_text(json.dumps(candidates, indent=2), encoding="utf-8")
print(json.dumps(candidates, indent=2))
```

#### सहेजे गए खोज पढ़ें

```bash
python candidates.py
```


<a id="extended"></a>

### केवल तभी विस्तार करें जब शॉर्टलिस्ट अपर्याप्त हो

मानक खोज max_results को 20 तक सपोर्ट करता है। एक व्यापक संग्रह के लिए, youtube_search_extended पर स्विच करें, जो 700 तक का समर्थन करता है और इसमें अलग-अलग मूल्य निर्धारण होता है। यह उदाहरण 50 के लिए पूछता है; जांचें कि क्या आपके पहले परिणाम उन सभी को समृद्ध करने से पहले उपयोगी हैं।

#### extended-request.json

```json
{
  "source": "youtube_search_extended",
  "query": "battery recycling process explained",
  "params": {
    "max_results": 50,
    "filters": {
      "type": "video"
    }
  }
}
```

#### एक बार चलाएं

```bash
python query.py extended-request.json extended.json
```

- [एक लंबे समय तक खोज asynchronously प्रस्तुत करें](https://flashdata.dev/hi/docs/reference/realtime-and-async/reference.md#async)
- [एनरिक चयनित IDs](https://flashdata.dev/hi/docs/guides/enrich-youtube-videos/reference.md)

<a id="metadata"></a>

## केवल मेटाडाटा को अपनी सुविधा की जरूरत को पुनर्प्राप्त करें

अपने चयनित ID के साथ नमूना video_id बदलें। एक साधारण वीडियो कार्ड या कैप्शन-लैंग्वे चेक के लिए प्रारूपों और अध्यायों को अक्षम रखें। एक रूपरेखा के लिए include_chapters सक्षम करें, या include_formats जब एक मीडिया प्रारूप का चयन करें।

### metadata-request.json

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

### एक बार query.py के साथ जमा करें

```bash
python query.py metadata-request.json metadata.json
```

- [मेटाडाटा प्रतिक्रिया क्षेत्र](https://flashdata.dev/hi/docs/sources/youtube_metadata/reference.md#response)
- [मीडिया वितरण कार्यप्रवाह](https://flashdata.dev/hi/docs/guides/media-delivery-pipeline/reference.md)

<a id="tracks"></a>

### उपलब्ध भाषाओं का निरीक्षण करना

कैप्शन चुनने से पहले परिणाम [0].transcriptLanguages पढ़ें। प्रारूपों, अध्यायों और भाषाओं में लौटे गए वीडियो ऑब्जेक्ट पर फ़ील्ड हैं; उपयोग रिकॉर्ड बाहरी प्रतिक्रिया से संबंधित है।

| सेटिंग | इसके लिए उपयोग करें |
| --- | --- |
| language | transcriptLanguages, जैसे कि एन या zh-Hans से एक कोड। यह सूची मैनुअल और स्वचालित ट्रैक्स को अलग नहीं करती है। |
| auto: true | एक मौजूदा स्वचालित रूप से उत्पन्न ट्रैक। |
| auto: false | एक मौजूदा मैन्युअल रूप से ट्रैक प्रदान की। दो ट्रैक प्रकारों के बीच कोई गिरावट नहीं है। |

#### पढ़िए metadata.json · कोई क्वेरी नहीं

```bash
python -m json.tool metadata.json
```


<a id="captions"></a>

## भाषा चुनें और स्पष्ट रूप से ट्रैक करें

उसी video_id का उपयोग अपने मेटाडाटा अनुरोध के रूप में करें और चुनी गई ट्रैक से मिलान करने के लिए भाषा और ऑटो को बदल दें। youtube_transcript डिफ़ॉल्ट auto: true; youtube_captions डिफ़ॉल्ट रूप से auto: false को। दोनों मौजूदा कैप्शन को पुनः प्राप्त करते हैं, न कि भाषण-टू-टेक्स्ट।

### captions-request.json

```json
{
  "source": "youtube_transcript",
  "video_id": "FUfGcZ092b0",
  "params": {
    "language": "en",
    "auto": true
  }
}
```

### एक बार query.py के साथ जमा करें

```bash
python query.py captions-request.json captions.json
```

- [कैप्शन पैरामीटर](https://flashdata.dev/hi/docs/sources/youtube_transcript/reference.md#parameters)
- [एक पूर्ण सारांश बनाएँ](https://flashdata.dev/hi/docs/guides/youtube-summary/reference.md)

<a id="citations"></a>

### सबूत के साथ टाइमस्टैम्प रखें

cite-segments.py को captions.json के बगल में सहेजें और इसे उस फ़ोल्डर से चलाएं। परिणाम का उपयोग करें [0].segment for cation: शुरू और अंत सेकंड हैं। पाठ के साथ languageCode और isAutoGenerated को संरक्षित करें। fullText पढ़ने के लिए उपयोगी है, लेकिन सेगमेंट टाइमिंग को प्रतिस्थापित नहीं करता है। यदि चयनित ट्रैक गायब हो गया है, तो यह तय करने से पहले अंतराल को रिकॉर्ड करें कि क्या दूसरा क्वेरी सार्थक है।

#### cite-segments.py

```python
import json
from pathlib import Path

response = json.loads(Path("captions.json").read_text(encoding="utf-8"))
if response.get("status") != "done":
    raise SystemExit("Inspect captions.json before continuing.")
track = (response.get("results") or [{}])[0]
if not track.get("segments"):
    raise SystemExit("No caption evidence was returned.")
for segment in track["segments"][:3]:
    url = f"https://www.youtube.com/watch?v={track['videoId']}&t={int(segment['start'])}s"
    print(segment["text"], url)
```

#### सहेजा गया captions · कोई API कॉल

```bash
python cite-segments.py
```


<a id="channel"></a>

## एक ज्ञात चैनल से केवल नए वीडियो की प्रक्रिया करें

एक चैनल हैंडल और एक बाउंडेड video_limit (1–100) का उपयोग करें। परिणाम [0].videos हाल की सूची लौटे हैं; videoCount चैनल मेटाडाटा है, न कि लौटाए गए आइटम की संख्या। एक सीमा और अनुसूची चुनें जो आपको उन अपलोड को कवर करने की आवश्यकता है जिन्हें आपको देखना होगा।

### channel-request.json

```json
{
  "source": "youtube_channel",
  "handle": "@TED",
  "params": {
    "video_limit": 10
  }
}
```

### एक बार query.py के साथ जमा करें

```bash
python query.py channel-request.json channel.json
```


<a id="channel-diff"></a>

### एक कतार और एक पूरा होने वाला चेकपॉइंट रखें

channel-queue.py को query.py और channel.json के बगल में सहेजें और इसे उस फ़ोल्डर से चलाएं। new-ids.json बनाने के लिए तर्क के बिना भागो, फिर उन IDs के लिए साक्ष्यों को संसाधित और सहेजना। केवल प्रत्येक quieued ID सफल होने के बाद ही --commit को चलाएं; एक विफलता चेकपॉइंट को अपरिवर्तित छोड़ देती है। इस उदाहरण के लिए प्रति चैनल और एक कार्यकर्ता का उपयोग करें।

#### channel-queue.py

```python
# channel-queue.py — plan first; commit only after every queued video is processed.
import json
import re
import sys
from pathlib import Path

checkpoint = Path("processed-ids.json")
processed = set(json.loads(checkpoint.read_text()) if checkpoint.exists() else [])
queue = Path("new-ids.json")
if sys.argv[1:] == ["--commit"]:
    processed.update(json.loads(queue.read_text()))
    temporary = checkpoint.with_suffix(".tmp")
    temporary.write_text(json.dumps(sorted(processed)), encoding="utf-8")
    temporary.replace(checkpoint)
    queue.unlink()
    print("Checkpoint saved.")
elif sys.argv[1:]:
    raise SystemExit("Usage: python channel-queue.py [--commit]")
else:
    data = json.loads(Path("channel.json").read_text(encoding="utf-8"))
    if data.get("status") != "done":
        raise SystemExit("Channel query did not complete.")
    ids = dict.fromkeys(video.get("videoId", "") for video in
                        (data.get("results") or [{}])[0].get("videos", []))
    new = [value for value in ids if re.fullmatch(r"[A-Za-z0-9_-]{11}", value)
           and value not in processed]
    if queue.exists() and json.loads(queue.read_text()) != new:
        raise SystemExit("Finish the existing queue before replacing it.")
    queue.write_text(json.dumps(new, indent=2), encoding="utf-8")
    print(json.dumps(new, indent=2))
```

#### योजना → प्रक्रिया →

```bash
python channel-queue.py
# Process every ID in new-ids.json and save its result first.
python channel-queue.py --commit
```

- [अनुसूची और पुन: उपयोग क्रेडेंशियल](https://flashdata.dev/hi/docs/guides/recurring-tasks/reference.md)
- [वीडियो की एक सूची में शामिल हों](https://flashdata.dev/hi/docs/guides/enrich-youtube-videos/reference.md)

<a id="channel-checkpoint"></a>

### जानबूझकर एक ताजा चैनल चेक शुरू करें

क्वेरी सहायक एक बचाया प्रतिक्रिया का पुन: उपयोग करता है। अगले अनुसूचित चेक के लिए, एक नया परिणाम फ़ाइल नाम का उपयोग करें, इसका निरीक्षण करें, फिर उस प्रतिलिपि को पूरा करें जो कतार चरण के लिए channel.json के जवाब को पूरा करता है। रखना processed-ids.json रनों के बीच। यह हाल की सूची एक पूर्ण चैनल निर्यात या एक घटना स्ट्रीम नहीं है।

#### Next Check · एक ताजा फ़ाइल नाम चुनें

```bash
python query.py channel-request.json channel-next.json
```

#### स्थिति की पुष्टि करने के बाद किया जाता है

```bash
python -c "from shutil import copyfile; copyfile('channel-next.json', 'channel.json')"
```


<a id="suggestions"></a>

## क्वेरी को बेहतर बनाने के लिए सुझावों का उपयोग करें

सुझाव परिणाम में वाक्यांशों वापसी [0], वीडियो रिकॉर्ड नहीं। एक उपयोगी वाक्यांश का चयन करें और एक अलग youtube_search अनुरोध करें। आप जिन दर्शकों को शोध कर रहे हैं उनके लिए भाषा और क्षेत्र सेट करें।

### suggestions-request.json

```json
{
  "source": "youtube_suggestions",
  "query": "battery recycling",
  "params": {
    "language": "en",
    "region": "US"
  }
}
```

### एक बार query.py के साथ जमा करें

```bash
python query.py suggestions-request.json suggestions.json
```


<a id="license"></a>

## उन्हें अनुमति के रूप में इलाज किए बिना लाइसेंस लेबल स्टोर करें

youtube_trainability एक वीडियो के लिए एक लाइसेंस लेबल लौटाता है। अनुमति: ["all"] क्रिएटिव कॉमन्स के लिए नक्शे; ["none"] में लापता लाइसेंस मेटाडाटा भी शामिल है। वीडियो ID, स्रोत प्रतिक्रिया और पुनर्प्राप्ति तिथि को रखें। यह लेबल डाउनलोड, पुन: उपयोग या प्रशिक्षण अधिकार प्रदान नहीं करता है।

### license-request.json

```json
{
  "source": "youtube_trainability",
  "video_id": "FUfGcZ092b0"
}
```

### एक बार query.py के साथ जमा करें

```bash
python query.py license-request.json license.json
```


<a id="operations"></a>

## ऐप्स और एजेंटों के लिए काम को सीमित करें

| नियम | कार्यान्वयन |
| --- | --- |
| समृद्ध होने से पहले चुनें | एक विषय कार्य के लिए: एक खोज, एक चयनित वीडियो का मेटाडाटा और एक चयनित कैप्शन ट्रैक। अपने ऐप में कॉल बजट को लागू करें और प्रत्येक स्रोत को अलग से मूल्य दें। |
| वास्तविक इनपुट द्वारा पुन: उपयोग | मेटाडाटा: वीडियो ID + विकल्प। कैप्शन: वीडियो ID + भाषा + ट्रैक। चैनल स्नैपशॉट को पुनर्प्राप्ति समय की भी आवश्यकता होती है या ID को चलाने की आवश्यकता होती है। |
| लापता साक्ष्य पर रोक | एक खाली खोज परिणाम या चुपचाप बंद कैप्शन ट्रैक स्विच नहीं है। इसलिए उपयोगकर्ता या वर्कफ़्लो अगले कार्रवाई का चयन कर सकते हैं, तो अंतर वापस लौटें। |
| उपयोग को संरक्षित करना और असफल काम करना | सफल प्रतिक्रियाओं के साथ उपयोग सहेजें। 429, सम्मान Retry-After; एक अनिश्चित प्रस्तुतीकरण के बाद, एक अन्य भुगतान क्वेरी से पहले History की जाँच करें। |

- [Realtime और async](https://flashdata.dev/hi/docs/reference/realtime-and-async/reference.md)
- [Batch और थोक](https://flashdata.dev/hi/docs/reference/batch-and-bulk/reference.md)
- [त्रुटियां और रिट्री](https://flashdata.dev/hi/docs/errors/reference.md#retries)
- [वर्तमान मूल्य निर्धारण और संतुलन](https://flashdata.dev/hi/docs/guides/credits-and-billing/reference.md)
