# YouTube Data के लिए Bright Data का विकल्प

FlashData YouTube अनुरोधों की Bright Data स्क्रैपर रिकॉर्ड के साथ तुलना करें: भुगतान दरें, मासिक भत्ते, नौकरी की सीमा और Python/Bash स्नैपशॉट से सहेजी गई नौकरियों में स्थानांतरण।

स्रोत अनुरोधों के आधार पर वीडियो अनुसंधान बनाएं। पूरे कार्य की तुलना करें, फिर स्नैपशॉट वर्कफ़्लो को सहेजे गए, पुन: प्रारंभ करने योग्य कार्यों में ले जाएँ।

यह YouTube तुलना है। [Google Search के लिए Bright Data का विकल्प](https://flashdata.dev/hi/compare/brightdata/reference.md) एक अलग पेज है।

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

- [विशेषताएं](#features)
- [मूल्य निर्धारण](#pricing)
- [कोटा और सीमाएँ](#limits)
- [नौकरी स्थानांतरित करें](#migration)
- [एजेंट कार्यप्रवाह](#agents)
- [अक्सर पूछे जाने वाले प्रश्न](#faq)

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

### केंद्रित वीडियो लुकअप के लिए कम भुगतान लागत

| विशेषता | FlashData | Bright Data YouTube |
| --- | --- | --- |
| सशुल्क मेटाडेटा लुकअप · 1,000 वीडियो | $0.50 — 1,000 स्रोत अनुरोध · PAYG | $1.50 — 1,000 वितरित वीडियो रिकॉर्ड · PAYG |
| मेटाडेटा + मौजूदा कैप्शन · 1,000 वीडियो | $1.00 — 2,000 स्रोत अनुरोध · PAYG | $1.50 — 1,000 कैप्शन फ़ील्ड शामिल होने पर वीडियो रिकॉर्ड होता है |
| प्रवेश मासिक योजना | $49.00 — Micro/माह; साझा उपयोग संतुलन शामिल है | $499 — Scale/माह · 384,000 रिकॉर्ड शामिल |
| मासिक सदस्यता के बिना जैसे ही आप भुगतान करें | हाँ | हाँ |

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

| विशेषता | FlashData | Bright Data YouTube |
| --- | --- | --- |
| कीवर्ड द्वारा वीडियो खोजें | हाँ — दिनांक, अवधि, प्रकार और सॉर्टिंग फ़िल्टर के साथ खोजें | हाँ — कीवर्ड और खोज-फ़िल्टर खोज मोड |
| किसी ज्ञात वीडियो के लिए मेटाडेटा | हाँ — शीर्षक, चैनल, अवधि, थंबनेल और सहभागिता गणना | हाँ — पहचान, चैनल और सहभागिता फ़ील्ड के साथ वीडियो रिकॉर्ड |
| नेविगेशन के लिए अध्याय मार्कर | हाँ — include_chapters; सेकंड में अध्याय का समय | हाँ — अध्याय के शीर्षक, पूर्वावलोकन और प्रारंभ समय मिलीसेकंड में |
| उपलब्ध कैप्शन भाषाओं की खोज करें | मेटाडेटा में भाषा सूची | वीडियो रिकॉर्ड में ट्रैक सूची — भाषा और स्वचालित-कैप्शन जानकारी शामिल है |

### कैप्शन को साक्ष्य के रूप में प्रयोग करने योग्य बनाएं

| विशेषता | FlashData | Bright Data YouTube |
| --- | --- | --- |
| मेटाडेटा को ताज़ा किए बिना कैप्शन का अनुरोध करें | समर्पित प्रतिलेख स्रोत — प्रति वीडियो एक मानक अनुरोध | वीडियो रिकॉर्ड में कैप्शन फ़ील्ड — YouTube वीडियो स्क्रैपर |
| अनेक कैप्शन भाषाओं का अनुरोध करें | 10 तक स्पष्ट भाषाएँ — ट्रैक प्लस प्रति-भाषा त्रुटियाँ | एक चयनित भाषा — वीडियो रिकॉर्ड एकत्रित करते समय भाषा का चयन करें |
| अपलोडर या स्वचालित कैप्शन मूल का चयन करें | हाँ — params.auto क्रॉस-ओरिजिन फ़ॉलबैक के बिना एक मूल का चयन करता है | ट्रैक मेटाडेटा में उत्पत्ति दिखाई गई है — समीक्षा किए गए वीडियो स्क्रैपर के लिए कोई मूल-चयन इनपुट सूचीबद्ध नहीं है |
| पूर्ण पाठ और टाइमस्टैम्प्ड उद्धरण | पूर्ण पाठ + समयबद्ध खंड — सेकंड में/end बार प्रारंभ करें | पूर्ण पाठ + समयबद्ध खंड — सेगमेंट प्रारंभ, समाप्ति और अवधि मिलीसेकेंड में |

### अपने एप्लिकेशन या एजेंट में संग्रह चलाएँ

| विशेषता | FlashData | Bright Data YouTube |
| --- | --- | --- |
| इंटरएक्टिव और पृष्ठभूमि संग्रह | रीयलटाइम या async — मोड चुनें; पृष्ठभूमि कार्य के लिए नौकरी ID सहेजें | सिंक स्क्रैप या async ट्रिगर — एक मिनट से अधिक का सिंक कार्य स्नैपशॉट के रूप में जारी रहता है |
| एक बड़ी तैयार सूची तैयार करें | Bulk Jobs एक वीडियो-ID फ़ाइल के साथ — कंसोल या API; प्रगति, प्रकट और परिणाम भाग | Async इनपुट बैच — किसी संग्रह को ट्रिगर करें और उसका स्नैपशॉट पुनः प्राप्त या वितरित करें |
| अनुप्रयोगों और एलएलएम के लिए आउटपुट | JSON, सादा पाठ या Markdown | स्नैपशॉट निर्यात प्रारूप — JSON, NDJSON और CSV |
| बाद के विश्लेषण के लिए completed परिणाम सुरक्षित रखें | परिणाम सहेजें या थोक भंडारण का उपयोग करें — कच्चे डेटा और मैनिफ़ेस्ट को अपने भंडारण में रखें | स्नैपशॉट और भंडारण वितरण — स्नैपशॉट 30 दिनों तक बनाए रखे जाते हैं |
| स्टैंडअलोन टर्मिनल क्लाइंट | मूल निवासी CLI — Linux, macOS और Windows; कोई Node/Python रनटाइम नहीं | Node.js CLI — npm-स्थापित bdata कमांड |
| MCP, कौशल और SDK पहुंच | हाँ | हाँ |

भुगतान दरों में निःशुल्क भत्ते शामिल नहीं हैं। दोनों async नौकरियां, थोक संग्रह और एजेंट टूल प्रदान करते हैं। जहां आवश्यक हो वहां टिप्पणी संग्रह, अन्य सामाजिक प्लेटफ़ॉर्म, प्रबंधित डेटासेट और मौजूदा स्टोरेज-डिलीवरी एकीकरण रखें।

### आपके कार्य के लिए आवश्यक फ़ील्ड के लिए भुगतान करें

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

### कैप्शन ट्रैक को स्पष्ट रूप से चुनें

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

### एजेंट सत्रों में कार्य रखें

मतदान से पहले स्वीकृत नौकरी ID बचाएं। बाद की प्रक्रिया उसी कार्य को फिर से शुरू करती है और कोई अन्य क्वेरी सबमिट किए बिना डाउनलोड किए गए परिणाम का पुन: उपयोग करती है।

<a id="pricing"></a>
## संपूर्ण वीडियो कार्य की तुलना करें

Bright Data के वीडियो रिकॉर्ड में मेटाडेटा और कैप्शन शामिल हो सकते हैं। FlashData एक मेटाडेटा अनुरोध और एक अलग कैप्शन अनुरोध का उपयोग करता है। एक खोज इनपुट कई बिल योग्य रिकॉर्ड लौटा सकता है; यह कैलकुलेटर केवल ज्ञात-वीडियो लुकअप को कवर करता है।

| Bright Data YouTube ऑफर | मासिक शुल्क | रिकॉर्ड शामिल हैं | भुगतान दर / 1,000 रिकॉर्ड |
| --- | --- | --- | --- |
| पात्र निःशुल्क पूल | $0 | पात्र उत्पादों में 5,000/माह तक साझा किया गया | भत्ते के भीतर |
| उपयोग के अनुसार भुगतान | $0.00 | कोई भुगतान-योजना भत्ता नहीं | $1.50 |
| Scale · $499/month | $499.00 | 384,000 | $1.30 additional |
| उद्यम | कस्टम | कस्टम | कस्टम |

Scale में $499/माह के लिए 384,000 रिकॉर्ड शामिल हैं; अतिरिक्त रिकॉर्ड की लागत $1.30 प्रति 1,000 है। कस्टम एंटरप्राइज़ और प्रमोशनल डिपॉज़िट मिलान को मॉडल नहीं किया गया है।

| 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 डेटा में आवंटित करती है। विस्तारित खोज और डाउनलोड की अलग-अलग दरें हैं। [पूरी मूल्य सूची](https://flashdata.dev/hi/pricing/youtube-data).

### 10,000 वीडियो: दोनों तरफ जाते ही भुगतान करें

| कार्य | FlashData अनुरोध | FlashData मॉडल बिल | Bright Data निःशुल्क रिकॉर्ड लागू | Bright Data मॉडल बिल |
| --- | --- | --- | --- | --- |
| वीडियो मेटाडेटा | 10,000 | $5.00 | 0 | $15.00 |
| वीडियो मेटाडेटा | 10,000 | $5.00 | 5,000 | $7.50 |
| मेटाडेटा + मौजूदा कैप्शन | 20,000 | $10.00 | 0 | $15.00 |
| मेटाडेटा + मौजूदा कैप्शन | 20,000 | $10.00 | 5,000 | $7.50 |

एक महीने के सफल वीडियो लुकअप के लिए USD। एक लौटाए गए Bright Data वीडियो रिकॉर्ड में मेटाडेटा और मौजूदा कैप्शन शामिल हो सकते हैं; संयुक्त FlashData कार्य दो स्रोत अनुरोधों का उपयोग करता है। खोज, टिप्पणियाँ, एआई ट्रांसक्रिप्शन, विस्तारित खोज और मीडिया डाउनलोड को बाहर रखा गया है। इन रिकॉर्ड्स के लिए अभी भी उपलब्ध केवल Bright Data निःशुल्क क्रेडिट दर्ज करें; 5,000-क्रेडिट पूल साझा किया जाता है, और आवर्ती मुफ्त क्रेडिट Scale के साथ नहीं जुड़ते हैं। FlashData कीमतें इसकी वर्तमान सार्वजनिक सूची से आती हैं; संपूर्ण चयनित योजना शेष अतिरिक्त उपयोग से पहले यहां आवंटित किया गया है। FlashData प्रारंभिक शेष और साइनअप/agent परीक्षणों को बाहर रखा गया है। मॉडल किया गया बिल उपयोग के अलावा किसी भी मासिक शुल्क को मापता है, न कि नए वॉलेट की खरीदारी को: FlashData टॉप-अप $10 से शुरू होता है। कोई कर, जमा-मैच प्रमोशन, कस्टम दरें या वार्षिक छूट शामिल नहीं हैं।

### ऑफर शुरू

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

योग्य Bright Data खातों को स्क्रैपर API सहित सभी योग्य उत्पादों में साझा किए गए प्रति माह 5,000 मुफ्त क्रेडिट प्राप्त होते हैं। एक वितरित YouTube रिकॉर्ड एक क्रेडिट का उपभोग करता है। अप्रयुक्त निःशुल्क क्रेडिट आगे नहीं बढ़ते; पूर्व-प्रतिबद्ध खातों को आवर्ती निःशुल्क क्रेडिट प्राप्त नहीं होता है। मासिक निःशुल्क पूल को Scale के साथ न रखें।

<a id="limits"></a>
## भत्ते, batch आकार और running नौकरियाँ

| चिंता | FlashData | Bright Data खुरचनी API |
| --- | --- | --- |
| भत्ते का उपभोग क्या करता है? | प्रत्येक स्रोत क्वेरी; मेटाडेटा और कैप्शन अलग-अलग हैं | रिकॉर्ड सफलतापूर्वक वितरित किए गए; एक खोज इनपुट कई लौटा सकता है |
| एक इंटरैक्टिव अनुरोध | POST /v1/queries/realtime; पृष्ठभूमि कार्य के लिए async चुनें | POST /datasets/v3/scrape; 1 मिनट के बाद, HTTP 202 एक स्नैपशॉट ID लौटाता है और कार्य जारी रहता है |
| बड़े इनपुट | बैच का आकार योजना पर निर्भर करता है; IDs की फ़ाइल के लिए बल्क प्रोसेसिंग का उपयोग करें | Async /trigger 1 GB तक इनपुट स्वीकार करता है; न्यूनतम इनपुट गणना स्क्रेपर पर निर्भर करती है |
| चल रहा काम | खाता समवर्तीता चयनित योजना पर निर्भर करती है, जो नीचे दिखाया गया है | 5,000 सक्रिय नौकरियाँ/snapshots; सीमा से अधिक रिटर्न 429 |
| पीछे हटना | सम्मान Retry-After; अस्थायी एजेंट परीक्षण प्रति सेकंड एक अनुरोध की अनुमति देते हैं | सम्मान Retry-After; 25 HTTP 429 प्रति आईपी 5 मिनट में प्रतिक्रियाएं 1-घंटे API ब्लॉक को ट्रिगर कर सकती हैं |
| परिणाम सहेजे गए | डाउनलोड करें और JSON को अपने टास्क स्टोरेज में रखें | स्नैपशॉट 30 दिनों तक बनाए रखे जाते हैं; बड़े परिणामों के लिए आंशिक-आधारित पुनर्प्राप्ति के साथ, डाउनलोड अनुरोध 5 जीबी तक समर्थन करते हैं |

| FlashData योजना | समवर्ती प्रश्न | प्रति बैच अनुरोध प्रश्न |
| --- | --- | --- |
| उपयोग के अनुसार भुगतान | 25 | 100 |
| Micro | 50 | 100 |
| Starter | 100 | 200 |
| Pro | 200 | 300 |
| Scale | 300 | 400 |
| Business | 400 | 500 |

समवर्तीता प्रति सेकंड अनुरोध नहीं है। क्रेडिट अभी भी प्रत्येक प्रश्न पर लागू होते हैं। [रीयलटाइम और एसिंक्रोनस](https://flashdata.dev/hi/docs/reference/realtime-and-async/reference.md) · [बैच और बल्क](https://flashdata.dev/hi/docs/reference/batch-and-bulk/reference.md) · [बल्क प्रोसेसिंग संदर्भ](https://flashdata.dev/hi/docs/reference/bulk-processing/reference.md).

<a id="migration"></a>
## स्नैपशॉट से लेकर सहेजी गई नौकरी तक

### 1. पहुंच तैयार करें और अनुरोध को मैप करें

youtube_metadata अनुमति के साथ कुंजी बनाएं या पुन: उपयोग करें। [API कुंजियाँ](https://flashdata.dev/app/api-keys) · [उपलब्ध क्रेडिट](https://flashdata.dev/app/billing). FLASHDATA_API_KEY को किसी गुप्त स्टोर में स्टोर करें या स्क्रिप्ट के छिपे हुए प्रॉम्प्ट में दर्ज करें।

माइग्रेशन संदर्भ के लिए मौजूदा Bright Data सबमिशन:

```bash
# Existing Bright Data job submission, for migration reference.
curl --fail-with-body --silent --show-error --max-time 120 \
  --request POST \
  'https://api.brightdata.com/datasets/v3/trigger?dataset_id=gd_lk56epmy2i5g7lzu0k&format=json' \
  --header "Authorization: Bearer $BRIGHTDATA_API_KEY" \
  --header 'Content-Type: application/json' \
  --data '{"input":[{"url":"https://www.youtube.com/watch?v=FUfGcZ092b0"}]}'
```

FlashData POST https://data.flashdata.dev/v1/queries X-API-Key के साथ:

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

### 2. स्क्रिप्ट को running से पहले सेव करें

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

```python
# Save as migrate-video.py in your working folder.
import argparse
import getpass
import json
import os
import re
import time
from pathlib import Path
from urllib.parse import urlsplit

import requests

parser = argparse.ArgumentParser()
parser.add_argument("video_id")
parser.add_argument("folder", help="A new folder name, such as video-001")
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")
if not re.fullmatch(r"[A-Za-z0-9_-]+", args.folder):
    raise SystemExit("Use a simple output folder name")
os.umask(0o077)
out = Path(args.folder)
body = {"source": "youtube_metadata", "video_id": args.video_id,
        "params": {"include_formats": False, "include_chapters": True}}
key = None

def read(name):
    return json.loads((out / name).read_text(encoding="utf-8"))

def call(method, url, name, payload=None, authenticated=True):
    global key
    headers = {"Accept": "application/json"}
    if authenticated:
        if key is None:
            key = os.environ.get("FLASHDATA_API_KEY") or getpass.getpass("FlashData API key: ")
        if not key.strip():
            raise SystemExit("An API key is required")
        headers["X-API-Key"] = key
    try:
        response = requests.request(method, url, json=payload, headers=headers,
                                    timeout=(10, 120), allow_redirects=False)
    except requests.RequestException:
        raise SystemExit("Network outcome unknown. Keep this folder and check History; do not resubmit.")
    (out / name).write_bytes(response.content)
    (out / (name + ".http")).write_text(str(response.status_code))
    (out / "retry-after.txt").write_text(response.headers.get("Retry-After", ""))
    return response

if not out.exists():
    out.mkdir()
    (out / "request.json").write_text(json.dumps(body), encoding="utf-8")
    submitted = call("POST", "https://data.flashdata.dev/v1/queries", "submission.json", body)
    if submitted.status_code not in (200, 201, 202):
        raise SystemExit(f"HTTP {submitted.status_code}. Inspect submission.json and retry-after.txt.")
else:
    try:
        if read("request.json") != body:
            raise SystemExit("This folder belongs to another request. Use a new folder.")
    except (OSError, ValueError):
        raise SystemExit("Incomplete attempt. Check the folder and History before resubmitting.")
try:
    receipt = read("submission.json")
    job_id = receipt["id"]
    status = (out / "submission.json.http").read_text().strip()
    if status not in ("200", "201", "202") or receipt["source"] != body["source"] or not re.fullmatch(r"[A-Za-z0-9_-]+", job_id):
        raise ValueError()
except (OSError, ValueError, KeyError, TypeError):
    raise SystemExit("No valid saved receipt. Check History; this script will not submit again.")

if not (out / "result.json").exists():
    url = "https://api.flashdata.dev/v2/jobs/" + job_id
    for attempt in range(12):
        response = call("GET", url, "job.json")
        if response.status_code != 200:
            raise SystemExit(f"HTTP {response.status_code}. Resolve the error; then resume this folder.")
        job = response.json()["job"]
        if job["id"] != job_id or job["source"] != body["source"]:
            raise SystemExit("Job does not match the saved receipt")
        if job["status"] == "completed":
            break
        if job["status"] not in ("pending", "processing"):
            raise SystemExit("Job " + job["status"] + ". Inspect job.json; do not resubmit.")
        delay = response.headers.get("Retry-After", "5")
        if attempt == 11 or not delay.isdigit() or int(delay) > 60:
            raise SystemExit("Still running. Wait for Retry-After, then run the same command to resume.")
        time.sleep(max(1, int(delay)))
    result = call("GET", url + "/results", "result.pending.json")
    if result.status_code == 302:
        location = result.headers.get("Location", "")
        parsed = urlsplit(location)
        if parsed.scheme != "https" or not parsed.hostname or parsed.username or parsed.password:
            raise SystemExit("Expected an HTTPS storage URL")
        # Separate request: the API key is never sent to storage.
        result = call("GET", location, "result.pending.json", authenticated=False)
    if result.status_code != 200:
        raise SystemExit(f"HTTP {result.status_code}. Resolve the error, then resume this folder.")
    data = result.json()
else:
    print("Reading saved result; no API call.")
    data = read("result.json")
if not isinstance(data, dict) or data.get("source") != body["source"] or data.get("status") != "done":
    raise SystemExit("Result did not complete successfully")
items = data.get("results")
if not isinstance(items, list) or len(items) != 1 or not isinstance(items[0], dict) or items[0].get("videoId") != args.video_id:
    raise SystemExit("Expected the requested video in results")
item = items[0]
mapped = [{"video_id": item["videoId"], "url": "https://www.youtube.com/watch?v=" + item["videoId"],
           "title": item.get("title"), "description": item.get("description"),
           "views": item.get("viewCount"), "likes": item.get("likeCount"),
           "num_comments": item.get("commentCount"), "video_length": item.get("duration"),
           "channelName": item.get("channel"), "channelId": item.get("channelId"),
           "uploadDateRaw": item.get("uploadDate"), "captionLanguages": item.get("transcriptLanguages")}]
if not (out / "result.json").exists():
    (out / "result.pending.json").replace(out / "result.json")
(out / "video-records.json").write_text(json.dumps(mapped, ensure_ascii=False, indent=2), encoding="utf-8")
print(f"Saved {out}/video-records.json; actual usage: {json.dumps(data.get('usage'))}")

```

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

```bash
python migrate-video.py FUfGcZ092b0 video-001
```

वैकल्पिक रूप से, Bash, cURL 7.76+ और jq 1.6+ का उपयोग करें। नीचे दी गई पूरी स्क्रिप्ट को एक नए कार्यशील फ़ोल्डर में migrate-video.sh के रूप में सहेजें।

```bash
#!/usr/bin/env bash
# Save as migrate-video.sh in your working folder.
set -euo pipefail
umask 077
video_id="${1:?Use: VIDEO_ID OUTPUT_FOLDER}"
out="${2:?Use a folder name such as video-001}"
[[ "$video_id" =~ ^[A-Za-z0-9_-]{11}$ && "$out" =~ ^[A-Za-z0-9_-]+$ ]] || exit 2
body=$(jq -n --arg id "$video_id" '{source:"youtube_metadata", video_id:$id,
  params:{include_formats:false, include_chapters:true}}')
call() {
  local method="$1" url="$2" name="$3" authenticated="$4" payload="${5:-}"
  local -a options=(--silent --show-error --compressed --proto '=https'
    --connect-timeout 10 --max-time 120 --request "$method"
    --header 'Accept: application/json' --output "$out/$name"
    --dump-header "$out/$name.headers" --write-out '%{http_code}')
  if [[ "$authenticated" == yes ]]; 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}"
    options+=(--header "X-API-Key: $FLASHDATA_API_KEY")
  fi
  if [[ -n "$payload" ]]; then options+=(--header 'Content-Type: application/json' --data-binary "$payload"); fi
  curl "${options[@]}" "$url" > "$out/$name.http" || {
    echo 'Network outcome unknown. Keep this folder and check History; do not resubmit.' >&2; exit 1;
  }
  status=$(cat "$out/$name.http")
}
if [[ ! -e "$out" ]]; then
  mkdir -- "$out"
  printf '%s\n' "$body" > "$out/request.json"
  call POST 'https://data.flashdata.dev/v1/queries' submission.json yes "@$out/request.json"
  [[ "$status" =~ ^20[012]$ ]] || { echo "HTTP $status. Inspect submission.json and its headers." >&2; exit 1; }
else
  jq -e --argjson expected "$body" '. == $expected' "$out/request.json" >/dev/null || {
    echo 'Incomplete or different request. Check this folder and History.' >&2; exit 1;
  }
fi
[[ "$(cat "$out/submission.json.http")" =~ ^20[012]$ ]] || exit 1
id=$(jq -er 'select(.source == "youtube_metadata") | .id | select(type == "string" and test("^[A-Za-z0-9_-]+$"))' "$out/submission.json")
if [[ ! -f "$out/result.json" ]]; then
  url="https://api.flashdata.dev/v2/jobs/$id"
  for attempt in {1..12}; do
    call GET "$url" job.json yes
    [[ "$status" == 200 ]] || { echo "HTTP $status. Inspect job.json and its headers; resume after resolving." >&2; exit 1; }
    state=$(jq -er --arg id "$id" 'select(.job.id == $id and .job.source == "youtube_metadata") | .job.status' "$out/job.json")
    [[ "$state" == completed ]] && break
    [[ "$state" == pending || "$state" == processing ]] || { echo "Job $state. Do not resubmit." >&2; exit 1; }
    delay=$(awk 'tolower($1)=="retry-after:" {sub(/\r$/, "", $2); print $2}' "$out/job.json.headers")
    delay="${delay:-5}"
    [[ "$attempt" -lt 12 && "$delay" =~ ^[0-9]+$ && "$delay" -le 60 ]] || {
      echo 'Still running. Wait for Retry-After, then run the same command to resume.' >&2; exit 1;
    }
    [[ "$delay" -gt 0 ]] || delay=1
    sleep "$delay"
  done
  call GET "$url/results" result.pending.json yes
  if [[ "$status" == 302 ]]; then
    location=$(awk 'tolower($1)=="location:" {sub(/\r$/, "", $2); print $2}' "$out/result.pending.json.headers")
    [[ "$location" =~ ^https://[^/@[:space:]]+(/|$) ]] || { echo 'Expected HTTPS storage URL.' >&2; exit 1; }
    # Separate request, without the API key. Do not add -L to an authenticated request.
    call GET "$location" result.pending.json no
  fi
  [[ "$status" == 200 ]] || { echo "HTTP $status. Resolve it, then resume this folder." >&2; exit 1; }
  result="$out/result.pending.json"
else
  echo 'Reading saved result; no API call.'
  result="$out/result.json"
fi
mapped=$(jq -e --arg id "$video_id" '
  if .source != "youtube_metadata" or .status != "done" then error("Result 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 != $id then error("Wrong video") else . end
  | [{video_id:.videoId, url:("https://www.youtube.com/watch?v=" + .videoId), title, description,
      views:.viewCount, likes:.likeCount, num_comments:.commentCount, video_length:.duration,
      channelName:.channel, channelId, uploadDateRaw:.uploadDate, captionLanguages:.transcriptLanguages}]' "$result")
[[ "$result" == "$out/result.json" ]] || mv -- "$result" "$out/result.json"
printf '%s\n' "$mapped" > "$out/video-records.json"
printf 'Saved %s/video-records.json; actual usage: ' "$out"
jq -c '.usage' "$out/result.json"

```

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

```bash
bash migrate-video.sh FUfGcZ092b0 video-001
```

यदि अभी भी running है, तो सहेजे गए कार्य को फिर से शुरू करने के लिए वही आदेश दोहराएं। API कॉल के बिना पूर्ण किए गए रन result.json का पुन: उपयोग करें। एक नया फ़ोल्डर एक नया अनुरोध सबमिट करता है; अनिश्चित सबमिशन का पुनः प्रयास करने से पहले इतिहास की जाँच करें। कुंजियों को चैट से दूर रखें और उन्हें कभी भी हस्ताक्षरित संग्रहण URLs पर अग्रेषित न करें।

### 3. मैप किया गया रिकॉर्ड पढ़ें

वीडियो-001/video-records.json सामान्य वीडियो फ़ील्ड नामों को संरक्षित करता है; result.json कच्चा डेटा और उपयोग बरकरार रखता है। गुम मेट्रिक्स null बने हुए हैं। channelName एक प्रदर्शन नाम है, हैंडल नहीं; uploadDateRaw एक सामान्यीकृत तारीख नहीं है। प्रतिलेख और मीडिया फ़ील्ड गढ़े नहीं गए हैं।

```json
[
  {
    "video_id": "FUfGcZ092b0",
    "url": "https://www.youtube.com/watch?v=FUfGcZ092b0",
    "title": "Example video",
    "description": "Example description",
    "views": 1200,
    "likes": null,
    "num_comments": null,
    "video_length": 197,
    "channelName": "Example channel",
    "channelId": "UC_EXAMPLE",
    "uploadDateRaw": "2025-01-15",
    "captionLanguages": [
      "en",
      "es"
    ]
  }
]
```

| चिंता | मौजूदा एकीकरण | FlashData परिवर्तन |
| --- | --- | --- |
| खुरचनी चयन | dataset_id=gd_lk56epmy2i5g7lzu0k | स्रोत=youtube_metadata; कैप्शन में अलग से youtube_transcript का उपयोग होता है |
| इनपुट | इनपुट ऐरे में एक घड़ी URL | एक 11-अक्षर video_id |
| प्रमाणीकरण | प्राधिकरण: वाहक | X-API-Key अनुरोधित स्रोत अनुमति के साथ |
| सबमिट करें | POST /datasets/v3/trigger → snapshot_id | POST /v1/queries → आईडी; रसीद सहेजें |
| ट्रैक | स्नैपशॉट प्रगति → ready | GET /v2/jobs/{id} → job.status=completed |
| पुनर्प्राप्त करें | स्नैपशॉट को JSON, NDJSON या CSV के रूप में डाउनलोड करें | GET /v2/jobs/{id}/results → हस्ताक्षरित भंडारण URL; API कुंजी के बिना प्राप्त करें |
| वीडियो फ़ील्ड | video_id, title, description, views, likes, num_comments, video_length | videoId, शीर्षक, विवरण, viewCount, likeCount, commentCount, अवधि (सेकंड) |
| चैनल और दिनांक | यूट्यूबर एक हैंडल है; date_posted एक तारीख है | channelName, channelId और uploadDateRaw रखें; किसी डिस्प्ले नाम का नाम बदलकर किसी हैंडल पर न रखें |
| प्रतिलिपि | वीडियो रिकॉर्ड में प्रतिलेख और formatted_transcript के रूप में शामिल किया जा सकता है | अलग ट्रैक अनुरोध; fullText और खंड सेकंड का उपयोग करते हैं। यदि मौजूदा पार्सर मिलीसेकंड की अपेक्षा करता है तो टाइमस्टैम्प मैप करें |
| प्रत्यक्ष मीडिया URL | video_url एक स्ट्रीमिंग है URL | अपने स्टोरेज में डिलीवरी के लिए अलग YouTube डाउनलोड वर्कफ़्लो का उपयोग करें |

### वैकल्पिक कैप्शन

अनुदान youtube_transcript अनुमति. इस बॉडी को X-API-Key के साथ POST https://data.flashdata.dev/v1/queries पर सबमिट करें और अपनी नौकरी बचाएं ID। यह प्रति वीडियो एक मानक अनुरोध जोड़ता है:

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

auto=false अपलोडर द्वारा प्रदत्त कैप्शन का चयन करता है। भाषा और मूल को सुरक्षित रखें. Bright Data स्वरूपित प्रतिलेख समय मिलीसेकंड का उपयोग करता है; FlashData खंड सेकंड का उपयोग करते हैं। मिलीसेकंड की अपेक्षा वाले पार्सर के लिए 1,000 से गुणा करें। [टाइमस्टैम्प वाले कैप्शन का उदाहरण](https://flashdata.dev/hi/docs/guides/timestamped-captions-recipe/reference.md).

### पुनर्प्राप्ति

- लंबित/processing: सहेजे गए ID को फिर से शुरू करें। मतदान परिबद्ध है और संख्यात्मक Retry-After का सम्मान करता है।
- 401/403: प्रमाणीकरण या अनुमति का समाधान करें; निरसन पर रोक.
- 402: जारी रखने से पहले उपलब्ध स्वामी शेष को पुनर्स्थापित करें।
- 429: भेजना बंद करें और सम्मान करें Retry-After; सबमिशन को स्वचालित रूप से पुनः प्रयास न करें.
- रसीद के बिना समयबाह्य: दूसरा फ़ोल्डर बनाने से पहले इतिहास का निरीक्षण करें।

[त्रुटियाँ और स्थिति कोड](https://flashdata.dev/hi/docs/errors/reference.md).

<a id="agents"></a>
## एक कनेक्शन, पुन: प्रयोज्य कार्य

योग्य एजेंट 72 घंटों के लिए 1 क्रेडिट (100 मानक YouTube डेटा अनुरोध तक) के साथ शुरुआत कर सकते हैं। पहले सहेजी गई पहुंच का पुन: उपयोग करें; मेटाडेटा और कैप्शन भत्ता साझा करते हैं।

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

```text
Migrate one Bright Data YouTube video lookup to FlashData.
Read https://flashdata.dev/auth.md and reuse saved access first.
Inspect the current video-record parser and list its required fields.
Fetch metadata for one known video. Request captions separately only if needed.
Keep channel handles, dates, caption origin and timestamp units explicit.
Save the submission receipt, job ID, raw JSON and normalized output.
Resume accepted work; do not submit again after a timeout or agent restart.
Verify the output before scheduling. Have the owner claim access and approve
the required permissions and shared balance for continued use.
Keep keys in the host's secret store. Stop on revoked access or insufficient balance.
```

[ट्रायल और खाते से लिंक करना](https://flashdata.dev/hi/docs/guides/agent-onboarding/reference.md) · [नियमित कार्य](https://flashdata.dev/hi/docs/guides/recurring-tasks/reference.md) · [नतीजे सेव करें](https://flashdata.dev/hi/docs/guides/save-results/reference.md).

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

### क्या यह Bright Data Google खोज तुलना है?

यह पेज YouTube स्क्रैपर API को कवर करता है। Google खोज विभिन्न मूल्य निर्धारण इकाइयों और अनुरोध कॉन्फ़िगरेशन के साथ Bright Data के SERP उत्पाद का उपयोग करती है। Google खोज तुलना का अपना पृष्ठ है।

### क्या Bright Data मेटाडेटा और एक ट्रांसक्रिप्ट के लिए दो बार शुल्क लेता है?

इसके YouTube वीडियो स्कीमा में लौटाए गए वीडियो रिकॉर्ड में मेटाडेटा और कैप्शन फ़ील्ड शामिल हैं। स्वचालित रूप से दो रिकॉर्ड न गिनें. FlashData अलग मेटाडेटा और ट्रांसक्रिप्ट क्वेरी का उपयोग करता है; कैलकुलेटर में संयुक्त कार्यभार प्रति वीडियो दो FlashData अनुरोधों को गिनता है। किसी विशेष वीडियो के लिए कैप्शन फ़ील्ड अनुपलब्ध हो सकता है।

### किस प्रदाता के पास अधिक मुफ़्त भत्ता है?

Bright Data हर महीने योग्य खाते 5,000 साझा क्रेडिट प्रदान करता है। FlashData का योग्य साइनअप भत्ता एक प्रारंभिक शेष है, और इसका अस्थायी एजेंट परीक्षण अलग है। इन ऑफ़र के अलग-अलग नवीनीकरण नियम हैं। मॉडल Bright Data PAYG को सटीक रूप से शेष फ्री-रिकॉर्ड इनपुट का उपयोग करें।

### क्या मैं प्रत्येक Bright Data स्क्रैपर को बदल सकता हूँ?

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

### क्या दोनों प्रदाता एआई एजेंटों का समर्थन करते हैं?

हाँ. दोनों MCP, एक CLI और एजेंट कौशल प्रदान करते हैं। FlashData का स्टैंडअलोन CLI, स्रोत अनुमतियाँ और साझा Google/YouTube संतुलन एक केंद्रित अनुसंधान वर्कफ़्लो के लिए उपयोगी हैं। सहेजी गई पहुंच का पुन: उपयोग करें और आवर्ती कार्य शेड्यूल करने से पहले मालिक से निरंतर खाता पहुंच को मंजूरी देने के लिए कहें।

### क्या मैं माइग्रेट करने के बाद स्नैपशॉट ID का पुन: उपयोग कर सकता हूँ?

नहीं, Bright Data स्नैपशॉट और नए FlashData जॉब ID को अलग-अलग पहचानकर्ताओं के रूप में सहेजें। उदाहरण केवल अपनी सहेजी गई FlashData रसीद का पुन: उपयोग करता है और जाँचता है कि लौटाया गया वीडियो अनुरोधित ID से मेल खाता है।

[API कुंजी प्राप्त करें](https://flashdata.dev/signup) · [Google Search तुलना](https://flashdata.dev/hi/compare/brightdata/reference.md).
