# Supadata YouTube डेटा के लिए वैकल्पिक

YouTube प्रतिलेख और मेटाडेटा लागत, मूल कैप्शन सुविधाओं और एजेंट पहुंच की तुलना करें। चलाने योग्य Python और Bash उदाहरणों के साथ Supadata से माइग्रेट करें।

Supadata तथ्यों की समीक्षा 2026-11-10. FlashData कीमतें और परीक्षण भत्ते इसके वर्तमान सार्वजनिक कैटलॉग का उपयोग करते हैं।

- [विशेषताएं](#features)
- [लागत की तुलना करें](#costs)
- [एक प्रतिलेख माइग्रेट करें](#migration)
- [मेटाडेटा और थोक](#workflows)
- [एआई एजेंटों के लिए](#agents)
- [अक्सर पूछे जाने वाले प्रश्न](#faq)

<a id="features"></a>
## सुविधाओं की तुलना

मौजूदा YouTube कैप्शन और मेटाडेटा एकत्र करने वाले ऐप्स और एजेंटों के लिए।

### भुगतान YouTube पुनर्प्राप्ति किफायती रखें

| विशेषता | FlashData | Supadata |
| --- | --- | --- |
| सदस्यता के बिना भुगतान किया गया उपयोग | हाँ — भुगतान-जैसा-आप-जाओ क्रेडिट; $10 से खरीदारी | भुगतान योजनाएं — Basic: $60/वर्ष · Pro: $17/माह |
| मूल प्रतिलेख या मेटाडेटा · मूल्य प्रति 1,000 | $0.50 — जाते ही भुगतान करें · कोई मासिक शुल्क नहीं | $5.67 पर Pro — $17 / 3,000 included credits; full allowance का उपयोग किया गया |
| मासिक योजना के बिना बैच | 100 तक प्रश्न/बैच — जाते ही भुगतान करें स्वामी कुंजी; परीक्षण सीमा अलग है | Pro और ऊपर — वीडियो और प्रतिलेख batch समापन बिंदु |

### वीडियो ढूंढें और एक शोध पुस्तकालय बनाएं

| विशेषता | FlashData | Supadata |
| --- | --- | --- |
| विषय के अनुसार वीडियो खोजें | हाँ — दिनांक, अवधि, प्रकार और सॉर्टिंग फ़िल्टर के साथ कीवर्ड खोज | हाँ — फ़िल्टर के साथ वीडियो, चैनल और प्लेलिस्ट खोजें |
| कैप्शन लाए बिना वीडियो मेटाडेटा ताज़ा करें | हाँ — शीर्षक, चैनल, अवधि, थंबनेल और सहभागिता गणना | हाँ — लेखक, मीडिया और सांख्यिकी फ़ील्ड के साथ मेटाडेटा समापन बिंदु को अलग करें |
| वीडियो मेटाडेटा में कैप्शन भाषाएँ | हाँ — hasTranscripts और transcriptLanguages | प्रतिलेख प्रतिक्रिया में — availableLangs; अलग मेटाडेटा स्कीमा |

### उद्धरणों और विश्लेषण के लिए प्रतिलेखों को उपयोगी रखें

| विशेषता | FlashData | Supadata |
| --- | --- | --- |
| स्रोत उद्धरणों के लिए टाइमस्टैम्प्ड पाठ | सेकंड में JSON खंड — प्रारंभ और समाप्ति समय के साथ टेक्स्ट करें | JSON टुकड़े मिलीसेकेंड में — ऑफसेट और अवधि के साथ पाठ |
| एक ही प्रतिक्रिया से पूरा पाठ और टाइमस्टैम्प | हाँ — fullText और खंड एक साथ लौटाए जाते हैं | टेक्स्ट या खंड चुनें — text=true एक स्ट्रिंग लौटाता है; अन्यथा अपने ऐप में टुकड़ों को शामिल करें |
| एक अनुरोध में एकाधिक मौजूदा कैप्शन भाषाएँ | 10 तक भाषाएँ — ट्रैक और प्रति-भाषा त्रुटियाँ | एक पसंदीदा भाषा — प्रतिलेख समापन बिंदु पर लैंग पैरामीटर |
| अपलोडर द्वारा प्रदत्त या YouTube-जनरेटेड कैप्शन का चयन करें | हाँ — स्पष्ट params.auto=false या true | कोई मूल चयनकर्ता दस्तावेज़ीकृत नहीं है — मोड मूल पुनर्प्राप्ति बनाम एआई पीढ़ी का चयन करता है |
| अनुपलब्ध कैप्शन को स्पष्ट रूप से संभालें | केवल मौजूदा ट्रैक — भाषा सरणियाँ ट्रैक और त्रुटियाँ लौटाती हैं; कोई नया प्रतिलेखन नहीं | देशी या एआई फ़ॉलबैक चुनें — मोड=ऑटो वाक्-से-पाठ उत्पन्न कर सकता है; मूल मौजूदा कैप्शन की पुनर्प्राप्ति को सीमित करता है |

### एक अनुरोध से दोहराए जाने योग्य वर्कफ़्लो की ओर बढ़ें

| विशेषता | FlashData | Supadata |
| --- | --- | --- |
| इंटरएक्टिव और पृष्ठभूमि अनुरोध | रीयलटाइम या async — निष्पादन मोड चुनें और कार्य सहेजें ID | परिणाम या प्रतिलिपि कार्य — HTTP 200 डेटा लौटाता है; HTTP 202 नौकरी लौटाता है ID |
| वीडियो की तैयार सूची तैयार करें | बैच API या Bulk Jobs कंसोल — एक ID फ़ाइल अपलोड करें; प्रकट और परिणाम भागों को रखें | Async batch API · Pro+ — वीडियो सूचियाँ, प्लेलिस्ट या चैनल स्वीकार करता है |
| संपूर्ण प्लेलिस्ट या चैनल एकत्रित करें | स्पष्ट वीडियो की आपूर्ति करें IDs — बैच या थोक प्रसंस्करण से पहले सूची तैयार करें | प्लेलिस्ट या चैनल batch इनपुट — Regular videos; excludes Shorts and live वीडियो |
| अनुप्रयोगों और एलएलएम के लिए आउटपुट | JSON, सादा पाठ या Markdown — प्रतिक्रिया और सामग्री प्रारूप चुनें | JSON टेक्स्ट या टुकड़ों के साथ — अपने एप्लिकेशन या प्रॉम्प्ट में प्रतिलेख सामग्री का उपयोग करें |
| भाषा एसडीके | Python, TypeScript और जाओ | Python और JavaScript / TypeScript |
| एजेंट होस्ट के लिए MCP पहुंच | हाँ — OAuth या API कुंजी के साथ रिमोट MCP | हाँ — MCP सर्वर Supadata क्रेडेंशियल के साथ |
| मालिक के साइनअप से पहले प्रोग्रामेटिक परीक्षण | हाँ — 100 तक मूल प्रतिलेख अनुरोध · 72 घंटे | खाता API कुंजी पहले — साइनअप के बाद हर महीने 100 निःशुल्क क्रेडिट |

Supadata एआई-जनरेटेड ट्रांसक्रिप्शन और कई सोशल प्लेटफॉर्म का समर्थन करता है। FlashData के कैप्शन एंडपॉइंट मौजूदा YouTube ट्रैक को पुनः प्राप्त करते हैं। दोनों सेवाएँ MCP और SDK प्रदान करती हैं।

### एक छोटा शोध कार्यभार किफायती रखें

आपके द्वारा उपयोग किए जाने वाले YouTube डेटा अनुरोधों के लिए भुगतान करें। बाद में सदस्यता जोड़ें यदि इसकी कम दर और शामिल शेष राशि आपकी मात्रा के अनुरूप हो।

[अपने कार्यभार का मूल्य निर्धारण करें](#costs)

### कैप्शन स्रोत को स्पष्ट रखें

YouTube-जनरेटेड या अपलोडर द्वारा प्रदत्त कैप्शन का चयन करें, लौटाई गई भाषा रखें और उद्धरणों के लिए टाइमस्टैम्प सुरक्षित रखें। नए स्पीच-टू-टेक्स्ट उत्पन्न किए बिना कई भाषाओं में मौजूदा ट्रैक का अनुरोध करें।

[अपने ट्रांस्क्रिप्ट रीडर को मैप करें](#migration)

### एक वीडियो से एक पाइपलाइन तक बढ़ें

realtime, async और batch कार्य के लिए समान अनुरोध आकार का उपयोग करें। उसी खाते और साझा शेष राशि का उपयोग करके अनुसंधान वर्कफ़्लो में Google खोजें जोड़ें।

[अगला चरण बनाएं](#workflows)

<a id="costs"></a>
## संपूर्ण वीडियो वर्कफ़्लो का मूल्य निर्धारण करें

USD. एक भाषा में एक मूल प्रतिलेख या एक मेटाडेटा लुकअप एक अनुरोध और एक Supadata क्रेडिट है। मेटाडेटा और एक मूल प्रतिलेख प्रति वीडियो दो अनुरोध हैं। FlashData अपने लाइव YouTube डेटा कैटलॉग का उपयोग करता है, अतिरिक्त उपयोग से पहले शामिल क्रेडिट मूल्य को लागू करता है। इसकी प्रदर्शित इकाई दर एक उपयोग दर है; Supadata योजना शुल्क को पूर्ण मासिक भत्ते से विभाजित किया जाता है। Basic केवल वार्षिक है: $60 अग्रिम भुगतान किया जाता है, प्रत्येक माह 300 क्रेडिट के बराबर $5/माह के रूप में दिखाया जाता है, 3,600 तुरंत उपलब्ध नहीं होता है। अन्य Supadata योजनाएं मासिक सूची कीमतों का उपयोग करती हैं। चयनित होने तक इस अनुमान में ऑटो रिचार्ज बंद है; चयनित होने पर, सबसे छोटा संपूर्ण प्रकाशित पैक कमी को पूरा कर देता है। वास्तविक ऑटो-रिचार्ज समय पहले खरीदा जा सकता है। खरीद राशि में कोई आरंभिक शेष नहीं माना जाता है। FlashData टॉप-अप $10 से शुरू होते हैं; खरीदारी के लिए धन बाद के लिए छोड़ा जा सकता है। Supadata मासिक क्रेडिट रोल ओवर नहीं होता है। परीक्षण क्रेडिट, कर, अन्य API उपयोग, अन्य योजनाओं पर वार्षिक छूट, एआई पीढ़ी और अनुवाद को बाहर रखा गया है। शून्य अनुरोध पर चयनित योजना शुल्क बना रहता है, और प्रभावी दर अपरिभाषित होती है।

### FlashData YouTube डेटा प्लान

| FlashData योजना | प्रति 1,000 अनुरोध | मासिक शुल्क | हर महीने शामिल अनुरोध |
| --- | --- | --- | --- |
| उपयोग के अनुसार भुगतान | $0.50 | $0.00 | 0 |
| Micro | $0.40 | $49.00 | 125,000 |
| Starter | $0.35 | $199.00 | 571,428 |
| Pro | $0.30 | $499.00 | 1,666,666 |
| Scale | $0.25 | $999.00 | 4,000,000 |
| Business | $0.20 | $1,999.00 | 10,000,000 |

[YouTube Data की पूरी मूल्य सूची](https://flashdata.dev/hi/pricing/youtube-data)

### Supadata प्रकाशित योजनाएँ

| Supadata योजना | योजना भुगतान | क्रेडिट/माह | प्रति 1,000 पूर्ण भत्ते पर | ऑटो रिचार्ज पैक |
| --- | --- | --- | --- | --- |
| मुफ़्त | $0.00/माह | 100 | $0.00 | उपलब्ध नहीं है |
| Basic · annual only | $60.00 / वर्ष ($5.00 / माह समतुल्य) | 300 | $16.67 | $10.00 / 1,000 क्रेडिट |
| Pro · monthly | $17.00/माह | 3,000 | $5.67 | $10.00 / 1,000 क्रेडिट |
| Mega · monthly | $47.00/माह | 30,000 | $1.57 | $10.00 / 5,000 क्रेडिट |
| Giga · monthly | $297.00/माह | 300,000 | $0.99 | $20.00 / 20,000 क्रेडिट |
| Supa · monthly | $897.00/माह | 1,000,000 | $0.90 | $20.00 / 20,000 क्रेडिट |

### उदाहरण: प्रत्येक वीडियो के लिए मेटाडेटा और एक मूल प्रतिलेख

FlashData भुगतान करें बनाम Supadata Mega मासिक, ऑटो रिचार्ज के साथ। यह एक स्पष्ट योजना तुलना है; HTML कैलकुलेटर में स्वतंत्र रूप से अन्य योजनाओं का चयन करें।

| वीडियो/माह | डेटा अनुरोध | FlashData प्रतिरूपित उपयोग | Supadata Mega + संपूर्ण रिचार्ज पैक | रिचार्ज पैक |
| --- | --- | --- | --- | --- |
| 100 | 200 | $0.10 | $47.00 | 0 |
| 1,000 | 2,000 | $1.00 | $47.00 | 0 |
| 10,000 | 20,000 | $10.00 | $47.00 | 0 |
| 100,000 | 200,000 | $100.00 | $387.00 | 34 |

### मुफ़्त पहुंच और एआई पीढ़ी

Supadata निःशुल्क रिफिल 100 मासिक क्रेडिट। इसका मूल प्रतिलेख एक क्रेडिट का उपयोग करता है; एआई पीढ़ी प्रति मिनट दो क्रेडिट का उपयोग करती है। इसलिए 30-मिनट की जेनरेट की गई प्रतिलेख 60 क्रेडिट का उपयोग करती है। डिफ़ॉल्ट ऑटो मोड पीढ़ी को ट्रिगर कर सकता है; मोड=नेटिव उस फ़ॉलबैक से बचता है। जेनरेशन, अनुवाद और विस्तारित खोज को इस तुलना से बाहर रखा गया है।

योग्य सत्यापित FlashData साइनअप 4,000 मानक YouTube डेटा अनुरोध तक प्रारंभिक भत्ता प्राप्त कर सकते हैं। यह मासिक निःशुल्क श्रेणी नहीं है.

<a id="migration"></a>
## एक मूल प्रतिलेख रीडर को माइग्रेट करें

| परिवर्तन | Supadata | FlashData | क्या करें? |
| --- | --- | --- | --- |
| निवेदन | GET /v1/transcript यूआरएल, लैंग, टेक्स्ट और मोड के साथ | POST /v1/queries/realtime स्रोत, video_id और पैरामीटर के साथ | 11-वर्ण YouTube ID निकालें। Supadata कुंजी FlashData को प्रमाणित नहीं करती है। |
| प्रमाणीकरण | x-api-कुंजी: आपकी Supadata कुंजी | X-API-Key: आपकी FlashData कुंजी | youtube_transcript अनुमति के साथ एक क्रेडेंशियल बनाएं या पुन: उपयोग करें। शीर्षलेख नाम केस-असंवेदनशील हैं; क्रेडेंशियल परिवर्तन. |
| मूल बनाम उत्पन्न | मोड=नेटिव मौजूदा कैप्शन पुनर्प्राप्त करता है; ऑटो AI पर वापस आ सकता है; जेनरेट हमेशा AI का उपयोग करता है | youtube_transcript मौजूदा YouTube कैप्शन पढ़ता है | पहले मूल पुनर्प्राप्ति को स्थानांतरित करें। उन वीडियो के लिए एक अलग वाक्-से-पाठ चरण रखें जिनमें नए प्रतिलेखन की आवश्यकता है। |
| कैप्शन मूल | मोड पुनर्प्राप्ति बनाम पीढ़ी का चयन करता है | params.auto=true YouTube-जनरेटेड कैप्शन का चयन करता है; false अपलोडर द्वारा प्रदत्त कैप्शन का चयन करता है | ये ऑटो सेटिंग्स समतुल्य नहीं हैं. FlashData ऑटो कभी भी स्पीच-टू-टेक्स्ट प्रारंभ नहीं करता है। |
| भाषा | लैंग को प्राथमिकता दी जाती है; अनुपलब्ध भाषाएं पहले उपलब्ध भाषा पर वापस आ सकती हैं | params.language स्पष्ट है; auto=true अनुरोधित कोड के बाद -orig संस्करण का प्रयास करता है | languageCode और requestedLanguageCode की जाँच करें। FlashData चुपचाप किसी अन्य भाषा या कैप्शन मूल का चयन नहीं करता है। |
| खंड | सामग्री[]: पाठ, ऑफसेट और अवधि मिलीसेकेंड में | परिणाम[0].सेगमेंट[]: पाठ, प्रारंभ और सेकंड में समाप्त | ऑफसेट = राउंड(प्रारंभ × 1000); अवधि = दौर((अंत − प्रारंभ) × 1000). संकेतों को बदलने के बजाय ओवरलैप को सुरक्षित रखें। |
| सादा पाठ | text=true सामग्री को एक स्ट्रिंग के रूप में लौटाता है | परिणाम[0].fullText | सारांश के लिए fullText पढ़ें और टाइमस्टैम्प उद्धरणों के लिए खंड रखें। |
| भाषा की खोज | प्रतिलेख प्रतिक्रिया में availableLangs | transcriptLanguages में youtube_metadata | जब आपके ऐप को पूरी भाषा सूची की आवश्यकता हो तो मेटाडेटा प्राप्त करें। एक लौटे ट्रैक से availableLangs का आविष्कार न करें। |
| समापन | HTTP 200 परिणाम, या HTTP 202 + jobId | रीयलटाइम स्थिति=done; async सबमिशन रिटर्न FlashData नौकरी IDs | प्रत्येक प्रदाता के राज्यों को अलग से संभालें। नए काम पर जाने से पहले वहां मौजूदा Supadata नौकरियां खत्म करें। |

### 1. पहुंच स्थापित करें

[API कुंजियाँ](https://flashdata.dev/app/api-keys) में youtube_transcript की अनुमति के साथ FlashData कुंजी बनाएं या पुन: उपयोग करें। वैकल्पिक मेटाडेटा कार्य के लिए youtube_metadata जोड़ें। [उपलब्ध क्रेडिट](https://flashdata.dev/app/billing) जांचें या [पात्र एजेंट ट्रायल एक्सेस](#agents) का उपयोग करें। चाबियाँ किसी परिवेश या गुप्त स्टोर में रखें।

Supadata मूल अनुरोध बदला जा रहा है:

```bash
# Existing Supadata call: use your saved SUPADATA_API_KEY.
curl --get --fail-with-body --silent --show-error \
  'https://api.supadata.ai/v1/transcript' \
  --header "x-api-key: $SUPADATA_API_KEY" \
  --data-urlencode 'url=https://www.youtube.com/watch?v=FUfGcZ092b0' \
  --data-urlencode 'lang=en' --data-urlencode 'text=false' \
  --data-urlencode 'mode=native'
```

FlashData रिप्लेसमेंट JSON बॉडी POST /v1/queries/realtime: के लिए

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

### 2. स्क्रिप्ट सहेजें, फिर उसे चलाएँ

Python या Bash चुनें। प्रत्येक नया आउटपुट फ़ोल्डर एक अनुरोध सबमिट करता है; किसी फ़ोल्डर का पुन: उपयोग किसी अन्य API कॉल के बिना सहेजे गए आउटपुट को पढ़ता है। संस्करण सहेजे गए फ़ाइल स्वरूप को साझा करते हैं। अनुरोधित कैप्शन ट्रैक वाला एक वीडियो चुनें।

#### Python

Python 3.10+ आवश्यक है। python -m pip install requests से आवश्यक पैकेज इंस्टॉल करें। नए कार्य फ़ोल्डर में नीचे दिया पूरा स्क्रिप्ट youtube-migrate.py नाम से सेव करें, फिर उसे चलाएँ।

```python
import argparse
import getpass
import json
import math
import os
import re
from pathlib import Path

import requests

parser = argparse.ArgumentParser()
parser.add_argument("operation", choices=["transcript", "metadata"])
parser.add_argument("video_id")
parser.add_argument("folder", type=Path)
parser.add_argument("--language", default="en")
parser.add_argument("--origin", choices=["auto", "manual"], default="auto")
args = parser.parse_args()
if not re.fullmatch(r"[A-Za-z0-9_-]{11}", args.video_id):
    raise SystemExit("Use an 11-character YouTube video ID")
source = "youtube_" + args.operation
params = ({"language": args.language, "auto": args.origin == "auto"}
          if args.operation == "transcript"
          else {"include_formats": False, "include_chapters": True})
body = {"source": source, "video_id": args.video_id, "params": params}
out = args.folder
if not out.exists():
    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(parents=True)
    (out / "request.json").write_text(json.dumps(body), encoding="utf-8")
    try:
        response = requests.post(
            "https://data.flashdata.dev/v1/queries/realtime", json=body,
            headers={"X-API-Key": key, "Accept": "application/json"},
            timeout=120, allow_redirects=False,
        )
    except requests.RequestException:
        raise SystemExit("Outcome unknown. Keep this folder and check History before retrying.")
    (out / "response.json").write_bytes(response.content)
    (out / "http-status.txt").write_text(str(response.status_code), encoding="utf-8")
    (out / "retry-after.txt").write_text(response.headers.get("Retry-After", ""), encoding="utf-8")
else:
    print("Reading saved output; no API call.")

try:
    saved_request = json.loads((out / "request.json").read_text(encoding="utf-8"))
    status = (out / "http-status.txt").read_text(encoding="utf-8").strip()
except (OSError, ValueError):
    raise SystemExit("Incomplete attempt. Inspect this folder and History before retrying.")
if saved_request != body:
    raise SystemExit("This folder belongs to a different request. Use a new folder.")
if status != "200":
    raise SystemExit(f"HTTP {status}: inspect response.json and retry-after.txt")
data = json.loads((out / "response.json").read_text(encoding="utf-8"))
if not isinstance(data, dict) or data.get("status") != "done" or data.get("source") != source:
    raise SystemExit("Request did not complete successfully; inspect response.json")
results = data.get("results")
if not isinstance(results, list) or len(results) != 1 or not isinstance(results[0], dict):
    raise SystemExit("Expected one result; inspect response.json")
item = results[0]
if item.get("videoId") != args.video_id:
    raise SystemExit("Returned video does not match the request")
if args.operation == "transcript":
    allowed = {args.language}
    if args.origin == "auto" and not args.language.endswith("-orig"):
        allowed.add(args.language + "-orig")
    if item.get("languageCode") not in allowed or item.get("isAutoGenerated") is not params["auto"]:
        raise SystemExit("Returned caption language or origin does not match")
    if not isinstance(item.get("segments"), list):
        raise SystemExit("Expected caption segments")
    content = []
    for cue in item["segments"]:
        if not isinstance(cue, dict):
            raise SystemExit("Invalid caption segment")
        start, end, text = cue.get("start"), cue.get("end"), cue.get("text")
        if (type(start) not in (int, float) or type(end) not in (int, float)
                or not math.isfinite(start) or not math.isfinite(end)
                or start < 0 or end < start or not isinstance(text, str)):
            raise SystemExit("Invalid caption segment")
        content.append({"text": text, "offset": round(start * 1000),
                        "duration": round((end - start) * 1000)})
    normalized = {"content": content, "lang": item["languageCode"].removesuffix("-orig")}
else:
    normalized = {name: item.get(name) for name in (
        "videoId", "title", "channel", "duration", "viewCount", "likeCount",
        "commentCount", "hasTranscripts", "transcriptLanguages", "chapters")}
(out / "normalized.json").write_text(
    json.dumps(normalized, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
)
print(f"Saved {out}/normalized.json; actual usage: {json.dumps(data.get('usage'))}")

```

उस कार्यशील फ़ोल्डर से चलाएँ:

```bash
python youtube-migrate.py transcript FUfGcZ092b0 transcript-001
```

यह YouTube-जनरेटेड अंग्रेजी कैप्शन का चयन करता है। अपलोडर द्वारा प्रदत्त ट्रैक के लिए --origin मैनुअल जोड़ें, या भाषा चुनने के लिए --language कोड जोड़ें।

वैकल्पिक अलग मेटाडेटा अनुरोध:

```bash
python youtube-migrate.py metadata FUfGcZ092b0 metadata-001
```

#### Bash

Bash, cURL 7.76+ और jq 1.6+ की आवश्यकता है। इस पूरी स्क्रिप्ट को अपने वर्किंग फोल्डर में running से पहले youtube-migrate.sh के रूप में सेव करें:

```bash
#!/usr/bin/env bash
set -euo pipefail
operation="${1:?Use: transcript|metadata VIDEO_ID OUTPUT_FOLDER [LANGUAGE] [auto|manual]}"
video_id="${2:?Set VIDEO_ID}"
out="${3:?Set OUTPUT_FOLDER}"
language="${4:-en}"
origin="${5:-auto}"
[[ "$operation" == transcript || "$operation" == metadata ]] || exit 1
[[ "$video_id" =~ ^[A-Za-z0-9_-]{11}$ ]] || exit 1
[[ "$origin" == auto || "$origin" == manual ]] || exit 1
body=$(jq -n --arg source "youtube_$operation" --arg id "$video_id" \
  --arg language "$language" --arg origin "$origin" '
  {source: $source, video_id: $id, params:
    (if $source == "youtube_transcript" then {language: $language, auto: ($origin == "auto")}
     else {include_formats: false, include_chapters: true} end)}')
if [[ ! -e "$out" ]]; then
  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 -p -- "$out"
  printf '%s\n' "$body" > "$out/request.json"
  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" --output "$out/response.json" \
    --dump-header "$out/response-headers.txt" --write-out '%{http_code}' \
    > "$out/http-status.txt" || {
      printf 'Request failed. Keep the output folder and inspect History before retrying.\n' >&2
      exit 1
    }
else
  printf 'Reading saved output; no API call.\n'
fi
jq -e --argjson expected "$body" '. == $expected' "$out/request.json" >/dev/null
[[ "$(cat "$out/http-status.txt")" == 200 ]] || {
  printf 'Inspect the saved HTTP status, response and Retry-After header.\n' >&2; exit 1;
}
normalized=$(jq -e --argjson request "$body" '
  if .source != $request.source or .status != "done" then error("Request not done") else . end
  | .results | if type != "array" then error("Expected results")
    elif length != 1 then error("Expected one result") else .[0] end
  | if .videoId != $request.video_id then error("Wrong video") else . end
  | if $request.source == "youtube_metadata" then
      {videoId, title, channel, duration, viewCount, likeCount, commentCount,
       hasTranscripts, transcriptLanguages, chapters}
    else
      if (.languageCode != $request.params.language and
          ($request.params.auto != true or ($request.params.language | endswith("-orig")) or
           .languageCode != ($request.params.language + "-orig"))) or
          .isAutoGenerated != $request.params.auto then error("Wrong language or origin") else . end
      | {lang: (.languageCode | sub("-orig$"; "")), content: [.segments[] |
          if (.start | type) != "number" or (.end | type) != "number" or (.text | type) != "string"
          then error("Invalid caption segment")
          elif (.start | isfinite | not) or (.end | isfinite | not) or .start < 0 or .end < .start
          then error("Invalid caption timing")
          else {text, offset: (.start * 1000 | round), duration: ((.end - .start) * 1000 | round)} end]}
    end' "$out/response.json")
printf '%s\n' "$normalized" > "$out/normalized.json"
printf 'Saved %s/normalized.json; actual usage: ' "$out"
jq -c '.usage' "$out/response.json"

```

उस कार्यशील फ़ोल्डर से चलाएँ:

```bash
bash youtube-migrate.sh transcript FUfGcZ092b0 transcript-001
```

फ़ोल्डर के बाद वैकल्पिक तर्क भाषा और मूल हैं; उदाहरण के लिए एन मैनुअल अपलोडर द्वारा प्रदत्त अंग्रेजी कैप्शन का चयन करता है।

वैकल्पिक अलग मेटाडेटा अनुरोध:

```bash
bash youtube-migrate.sh metadata FUfGcZ092b0 metadata-001
```

अस्थायी परीक्षण पहुंच के लिए, अनुरोधों को कम से कम एक सेकंड के अंतराल पर क्रमिक रूप से चलाएं।

### 3. आउटपुट पढ़ें

response.json कच्चे परिणाम और उपयोग को सुरक्षित रखता है। normalized.json प्रतिलेख खंड सेकंड को ऑफसेट/duration मिलीसेकंड में परिवर्तित करता है। यह एक सेगमेंट एडाप्टर है, पूर्ण Supadata-संगत प्रतिक्रिया नहीं: availableLangs निर्मित नहीं है। मेटाडेटा आउटपुट निरर्थक मानों को सुरक्षित रखता है। विफल या बाधित अनुरोध अपना साक्ष्य रखते हैं और रुक जाते हैं।

उदाहरणात्मक normalized.json:

```json
{
  "content": [
    {
      "text": "Example caption text.",
      "offset": 1250,
      "duration": 2250
    }
  ],
  "lang": "en"
}
```

[ट्रांसक्रिप्ट स्कीमा](https://flashdata.dev/hi/docs/sources/youtube_transcript/reference.md)

<a id="workflows"></a>
## मेटाडेटा और बल्क वर्कफ़्लोज़

| डेटा | Supadata /v1/metadata | FlashData youtube_metadata |
| --- | --- | --- |
| वीडियो पहचान | id | परिणाम[0].videoId |
| शीर्षक और विवरण | शीर्षक, विवरण | परिणाम[0].शीर्षक, परिणाम[0].विवरण |
| चैनल | author.displayName; additionalData.channelId | परिणाम[0].चैनल; परिणाम[0].channelId |
| सगाई | stats.views, stats.likes, stats.comments | परिणाम[0].viewCount, likeCount, commentCount |
| अवधि | media.duration (सेकंड) | परिणाम[0]अवधि (सेकंड) |
| थंबनेल | media.thumbnailUrl | परिणाम[0].थंबनेल[]; वह आकार चुनें जिसकी आपके ऐप को आवश्यकता है |
| प्रकाशन तिथि | createdAt | परिणाम[0].uploadDate; अपने ऐप में इसके प्रारूप को सामान्य करें |
| कैप्शन खोज | प्रतिलेख प्रतिक्रिया से availableLangs पढ़ें | परिणाम[0].hasTranscripts और transcriptLanguages |

### एक अनुरोध में कई मौजूदा भाषाएँ

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

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

### एक शोध पुस्तकालय को समृद्ध करें

एक बार मेटाडेटा प्राप्त करें, उसका वीडियो ID और उपलब्ध कैप्शन भाषाओं को सहेजें, फिर वह ट्रैक पुनः प्राप्त करें जिसकी आपको आवश्यकता है। निरर्थक सहभागिता गणनाओं को शून्य में बदलने के बजाय null रखें।

[YouTube डेटा सर्वोत्तम अभ्यास](https://flashdata.dev/hi/docs/guides/youtube-data-guide/reference.md)

### वीडियो की एक सूची संसाधित करें IDs

अपने इनपुट को स्पष्ट वीडियो IDs में विस्तारित करें, फिर बैच या एक बल्क फ़ाइल का उपयोग करें। FlashData ड्रॉप-इन batch इनपुट के रूप में Supadata playlistId को स्वीकार नहीं करता है। failed आइटम को पुनः प्रयास करने से पहले प्रति-आइटम स्थिति और आउटपुट सहेजें।

[बल्क प्रोसेसिंग संदर्भ](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md)

### अनुसंधान को एक शेड्यूल पर चलाएँ

मालिक का क्रेडेंशियल, चेकपॉइंट completed वीडियो बनाए रखें और पुनरारंभ करने पर सहेजे गए आउटपुट को पढ़ें। निरस्त पहुंच या अपर्याप्त शेष राशि के लिए रुकें; किसी निर्धारित कार्य को जारी रखने के लिए दूसरा परीक्षण न बनाएं।

[नियमित कार्य](https://flashdata.dev/hi/docs/guides/recurring-tasks/reference.md)

### Production प्रवासन निर्णय

- FlashData बैच या बल्क फ़ाइल प्रोसेसिंग से पहले स्पष्ट वीडियो IDs में प्लेलिस्ट/channel इनपुट को हल करें; Supadata playlistId ड्रॉप-इन इनपुट नहीं है।
- Supadata खोज की लागत प्रति 20-परिणाम पृष्ठ पर एक क्रेडिट, या सीमा के साथ ceil(limit/20) होती है। FlashData मानक YouTube खोज 20 परिणामों तक का समर्थन करता है; विस्तारित खोज की एक अलग दर है. मानचित्र फ़िल्टर करें और पृष्ठ टोकन स्थानांतरित न करें।
- Supadata एक घंटे की completed प्रतिलेख नौकरी परिणाम विंडो का दस्तावेजीकरण करता है। नए काम पर जाने से पहले वहां मौजूद नौकरियों को ख़त्म करें और परिणामों को संग्रहीत करें। प्रदाता-विशिष्ट कार्य IDs को अलग रखें।
- क्रॉस-प्लेटफ़ॉर्म मीडिया, एआई एक्सट्रैक्शन, अनुवाद और ऑडियो ट्रांसक्रिप्शन को उनके मौजूदा पथों पर रखें जब तक कि समकक्ष वर्कफ़्लो लागू न किया गया हो।

<a id="agents"></a>
## एजेंट परीक्षण, दावा और आवर्ती उपयोग

योग्य एजेंट 1 क्रेडिट से शुरू कर सकते हैं, 72 घंटों के लिए 100 मूल प्रतिलेख अनुरोध तक। मेटाडेटा और प्रतिलेख इस भत्ते को साझा करते हैं।

1. पहले मौजूदा पहुंच का पुन: उपयोग करें; अन्यथा केवल आवश्यक अनुमतियों के साथ एक योग्य परीक्षण प्रारंभ करें।
2. एक उपयोगी परिणाम लौटाएं, कच्चे आउटपुट और उपयोग को बचाएं, और वही प्रोफ़ाइल और राज्य निर्देशिका रखें।
3. स्वामी साइन इन या साइन अप करता है, ईमेल सत्यापित करता है और दावे, दायरे और साझा-शेष पहुंच को मंजूरी देता है।
4. आवर्ती कार्यों के लिए स्वामी क्रेडेंशियल का पुन: उपयोग करें। अप्रयुक्त परीक्षण क्रेडिट स्थानांतरित नहीं होते. निरस्तीकरण या अपर्याप्त शेष के बाद रुकें; जारी रखने के लिए कभी भी दूसरा परीक्षण न बनाएं.

```text
Migrate the native YouTube transcript part of this project from Supadata to FlashData.
Read https://flashdata.dev/auth.md and https://flashdata.dev/docs/sources/youtube_transcript/reference.md.
Reuse a saved FlashData credential before requesting an eligible temporary trial.
Use youtube_transcript permission and one explicit video ID, language and caption origin.
Do not map Supadata mode=auto to FlashData auto=true: the latter selects existing YouTube-generated captions.
Save the raw response and actual usage. Convert segment seconds to milliseconds if my reader expects offset/duration.
Do not fabricate captions or available languages. Report missing tracks and keep AI generation separate.
Ask the owner to claim access before recurring use. Store credentials outside chat and source control.
Reuse saved outputs on restart and stop after revocation; never create repeated trials to keep running.
```

[ट्रायल और खाते से लिंक करना](https://flashdata.dev/hi/docs/guides/agent-onboarding/reference.md) · [स्टैंडअलोन CLI](https://flashdata.dev/hi/docs/guides/flashdata-cli/reference.md) · [MCP कनेक्शन](https://flashdata.dev/hi/docs/integrations/mcp-clients/reference.md)

<a id="faq"></a>
## प्रवासन प्रश्न

### क्या FlashData Supadata के AI प्रतिलेखन को प्रतिस्थापित कर सकता है?

FlashData के प्रतिलेख और कैप्शन स्रोत YouTube पर पहले से मौजूद कैप्शन को पुनः प्राप्त करते हैं। वे ऑडियो का प्रतिलेखन, पाठ का अनुवाद या दृश्य विश्लेषण नहीं करते हैं। मूल YouTube पुनर्प्राप्ति को FlashData पर ले जाएं; जब आपके एप्लिकेशन को इसकी आवश्यकता हो तो स्पीच-टू-टेक्स्ट, क्रॉस-प्लेटफ़ॉर्म वीडियो या एआई निष्कर्षण के लिए एक अलग सेवा रखें।

### कोई व्यक्ति क्या खरीदने का अनुरोध करता है?

कैलकुलेटर एक भाषा में एक मौजूदा प्रतिलेख या एक वीडियो मेटाडेटा लुकअप को कवर करता है। दोनों को लाने में प्रति वीडियो दो अनुरोधों का उपयोग होता है। Supadata इनमें से प्रत्येक ऑपरेशन को एक क्रेडिट पर बिल करता है। FlashData चयनित योजना के YouTube डेटा दर का उपयोग करता है। विस्तारित खोज, एआई ट्रांसक्रिप्शन, अनुवाद और मीडिया डिलीवरी इस अनुमान से बाहर हैं।

### क्या FlashData हमेशा सस्ता होता है?

अपने वास्तविक कार्यभार और चयनित योजनाओं की तुलना करें। Supadata में हर महीने निःशुल्क 100 क्रेडिट शामिल है। FlashData का अस्थायी एजेंट परीक्षण सीमित है और समाप्त हो रहा है; यह मासिक निःशुल्क श्रेणी नहीं है. कम मात्रा में, एक निःशुल्क भत्ता पूरे कार्य को कवर कर सकता है। भुगतान की गई योजना शुल्क, रिचार्ज पैक और अप्रयुक्त शेष आपके द्वारा भुगतान की जाने वाली राशि को प्रभावित करते हैं।

### क्या Supadata पहले से ही MCP और SDK का समर्थन करता है?

हाँ. दोनों सेवाएँ MCP और Python/JavaScript एकीकरण का समर्थन करती हैं। FlashData एक गो SDK, स्टैंडअलोन CLI और एक अस्थायी एजेंट परीक्षण भी प्रदान करता है जिसका आवर्ती पहुंच के लिए दावा किया जा सकता है। वह इंटरफ़ेस चुनें जिसे आपका होस्ट समर्थन करता है; MCP अकेले स्विच करने का कारण नहीं है।

### यदि कोई कैप्शन ट्रैक गुम है तो क्या होगा?

इसे डेटा गैप के रूप में मानें। FlashData अपलोडर द्वारा प्रदत्त और YouTube-जनरेटेड कैप्शन के बीच स्विच नहीं करता है या एक प्रतिलेख को संश्लेषित नहीं करता है। किसी भाषा सरणी के लिए, अनुरोध done होने पर भी त्रुटियों का निरीक्षण करें। Supadata ऑटो मोड में एक प्रतिलेख उत्पन्न कर सकता है, जबकि मूल मोड एक अनुपलब्ध प्रतिलेख के लिए HTTP 206 लौटा सकता है; इसका दस्तावेज़ीकरण उस प्रतिक्रिया को एक क्रेडिट पर बिल करता है।

### क्या मैं मौजूदा एप्लिकेशन प्रतिक्रिया आकार को बनाए रख सकता हूं?

अपना स्वयं का एडॉप्टर रखें. उदाहरण FlashData खंडों को मिलीसेकंड में ऑफसेट और अवधि के साथ सामग्री प्रविष्टियों में परिवर्तित करता है, लेकिन पूर्ण Supadata-संगत प्रतिक्रिया का दावा नहीं करता है। यदि आपको उपलब्ध भाषाओं की आवश्यकता है तो FlashData मेटाडेटा पढ़ें, और कार्य की स्थिति, त्रुटि और उपयोग प्रबंधन को स्पष्ट रूप से माइग्रेट करें।

[API कुंजी प्राप्त करें](https://flashdata.dev/signup)
