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

YouTube मेटाडेटा और कैप्शन लागत, प्रीपेड पैक और कैश हिट की तुलना करें। ऐप्स और एजेंटों के लिए चलने योग्य Python और Bash फ़ील्ड एडाप्टर के साथ FlashData पर माइग्रेट करें।

ताज़ा वीडियो डेटा. एक छोटा प्रारंभिक खर्च. अपने शेष सामाजिक-डेटा एकीकरण को बनाए रखते हुए YouTube मेटाडेटा और कैप्शन कॉल को स्थानांतरित करें।

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

- [विशेषताएं](#features)
- [मूल्य निर्धारण और कैश](#costs)
- [अनुरोध माइग्रेट करें](#migration)
- [अनुसंधान कार्यप्रवाह](#workflow)
- [एआई एजेंटों के लिए](#agents)
- [अक्सर पूछे जाने वाले प्रश्न](#faq)

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

### ताजा YouTube डेटा की लागत कम करें

| विशेषता | FlashData | ScrapeCreators |
| --- | --- | --- |
| प्रवेश भुगतान दर / 1,000 मेटाडेटा या कैप्शन कॉल | $0.50 — उपयोग के अनुसार भुगतान करें | $1.88 — Freelance · ताज़ा एक-क्रेडिट कॉल |
| न्यूनतम सूचीबद्ध इकाई दर / 1,000 कॉल | $0.20 — वैकल्पिक मासिक योजना; इसका शुल्क अभी भी लागू है | $0.994 — Business · $497 प्रीपेड पैक; कस्टम एंटरप्राइज़ को बाहर रखा गया |
| पहले भुगतान की गई क्रेडिट खरीदारी | $10 से | $47 — 25,000-क्रेडिट Freelance पैक |
| मासिक शुल्क के बिना भुगतान करें | हाँ | हाँ |

### वीडियो ढूंढें और उन तथ्यों को ताज़ा करें जिनकी आपको आवश्यकता है

| विशेषता | FlashData | ScrapeCreators |
| --- | --- | --- |
| कीवर्ड और फ़िल्टर के आधार पर वीडियो ढूंढें | हाँ — दिनांक, अवधि, प्रकार और छँटाई फ़िल्टर | हाँ — खोज फ़िल्टर और निरंतरता-टोकन पृष्ठांकन |
| किसी ज्ञात वीडियो के लिए मेटाडेटा | हाँ — शीर्षक, चैनल, अवधि, थंबनेल और सहभागिता गणना | हाँ — वीडियो/Short विवरण समापन बिंदु |
| नेविगेशन के लिए अध्याय मार्कर | हाँ — include_chapters; मौजूद होने पर प्रारंभ/end बार वाले शीर्षक | हाँ — मौजूद होने पर वीडियो प्रतिक्रिया में अध्याय |
| उपलब्ध कैप्शन ट्रैक खोजें | मेटाडेटा भाषा सूची — hasTranscripts और transcriptLanguages | मेटाडेटा captionTracks — भाषा कोड और ट्रैक विवरण |

### कैप्शन चयन और साक्ष्य स्पष्ट रखें

| विशेषता | FlashData | ScrapeCreators |
| --- | --- | --- |
| एक ही प्रतिक्रिया से पाठ और टाइमस्टैम्प | पूर्ण पाठ + समयबद्ध खंड — सेकंड में/end बार प्रारंभ करें | पूर्ण पाठ + समयबद्ध खंड — startMs/endMs मिलीसेकंड स्ट्रिंग के रूप में |
| एक अनुरोध में कई कैप्शन भाषाएँ | 10 तक भाषाएँ — मौजूदा ट्रैक और प्रति-भाषा त्रुटियाँ | एक चयनित भाषा — भाषा या original_audio चयन प्रति प्रतिलेख कॉल |
| कैप्शन का मूल स्पष्ट रूप से चुनें | अपलोडर या YouTube-जनरेट किया गया — params.auto एक मूल का चयन करता है | भाषा और मौखिक-ऑडियो चयन — original_audio कैप्शन-उत्पत्ति स्विच नहीं है |
| गुम-कैप्शन हैंडलिंग | मौजूदा ट्रैक और स्पष्ट त्रुटियाँ — भाषा सरणियाँ सफल ट्रैक को सुरक्षित रखती हैं और लापता चयनों की रिपोर्ट करती हैं | शून्य प्रतिलेख फ़ील्ड — अनुरोधित ट्रैक गुम होने पर शून्य क्रेडिट खर्च होता है; नहीं YouTube एआई प्रतिलेखन |
| चुनें कि पुन: उपयोग किया गया डेटा कितना पुराना हो सकता है | आपके एप्लिकेशन में कैश नीति — पुनर्प्राप्ति समय बचाएं और तय करें कि दोबारा कब लाना है | cache_max_age — 1–30-दिन के विकल्प; कैश हिट की लागत शून्य क्रेडिट और एक्सपोज़ cached_at |

### दोहराने योग्य डेटा वर्कफ़्लो चलाएँ

| विशेषता | FlashData | ScrapeCreators |
| --- | --- | --- |
| वीडियो की सहेजी गई फ़ाइल को संसाधित करें IDs | थोक नौकरियाँ प्रबंधित की गईं — फ़ाइल सबमिट करें, उसके कार्य को ट्रैक करें और आउटपुट पुनर्प्राप्त करें | प्रति-वीडियो समापन बिंदु कॉल — अपने एकीकरण में फ़ाइल लूप और परिणाम संग्रहण प्रबंधित करें |
| लंबे संग्रहों को पृष्ठभूमि कार्यों में ले जाएँ | Async, बैच और बल्क एपीआई — कार्य जारी रखें IDs, स्थिति ट्रैक करें और परिणाम पुनः प्राप्त करें | सिंक्रोनस YouTube कॉल — आपके कार्यकर्ता में प्रति-वीडियो कॉल कतार और चेकपॉइंट |
| संरचित और पठनीय आउटपुट | JSON, सादा पाठ या Markdown — API प्रतिक्रिया शीर्षलेख के माध्यम से चयनित | JSON API और CLI प्रारूप — CLI CSV, टेबल और Markdown भी निर्यात करता है |
| टर्मिनल स्थापना | स्टैंडअलोन निष्पादन योग्य — Linux, macOS और Windows; कोई Node/Python रनटाइम नहीं | एनपीएम CLI — @scrapecreators/cli |
| MCP और एजेंट कौशल | हाँ | हाँ |
| डेटा से होस्टेड मीडिया डिलीवरी तक जारी रखें | हाँ — YouTube अपने भंडारण में डाउनलोड करें; अलग अनुमति और जीबी-आधारित मूल्य निर्धारण | अलग डाउनलोडर वर्कफ़्लो — YouTube मेटाडेटा और ट्रांसक्रिप्ट एपीआई मीडिया फ़ाइलें वितरित नहीं करते हैं |

दोनों प्रीपेड एक्सेस, MCP, एक CLI और एजेंट कौशल प्रदान करते हैं। ScrapeCreators अन्य सामाजिक प्लेटफ़ॉर्म और YouTube टिप्पणियों को भी कवर करता है। समर्थित कैश हिट निःशुल्क हैं।

### जिन वीडियो की आप परवाह करते हैं उन्हें ताज़ा करें

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

### छोटी खरीदारी से शुरुआत करें

FlashData क्रेडिट टॉप-अप $10 से शुरू होते हैं। पहले एक YouTube कार्यभार हटाएँ, जबकि आपका मौजूदा एकीकरण टिप्पणियों और अन्य सामाजिक प्लेटफ़ॉर्म को संभालना जारी रखता है।

### सटीक कैप्शन ट्रैक चुनें

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

<a id="costs"></a>
## ताज़ा अनुरोधों, कैश हिट्स और अग्रिम खरीदारी की तुलना करें

| ScrapeCreators ऑफर | एकमुश्त खरीदारी | क्रेडिट | प्रति 1,000 ताज़ा एक-क्रेडिट कॉल | मासिक शुल्क |
| --- | --- | --- | --- | --- |
| शुरुआती मुफ़्त ऑफर | $0 | 100 एक बार | निःशुल्क आरंभिक भत्ता | $0 |
| Freelance | $47.00 | 25,000 | $1.88 | $0 |
| Business | $497.00 | 500,000 | $0.994 | $0 |
| उद्यम | कस्टम | 1,000,000+ | कस्टम | प्रीपेड क्रेडिट के लिए $0 |

ये प्रीपेड पैक हैं जिनका कोई मासिक नवीनीकरण नहीं है। Business बिल्कुल $0.994 प्रति 1,000 एक-क्रेडिट कॉल के बराबर है; $0.99 गोलाकार है. वर्तमान नीति के तहत खरीदे गए क्रेडिट की कोई समाप्ति तिथि नहीं है। प्रारंभिक और अर्जित बोनस क्रेडिट को मॉडल से बाहर रखा गया है।

| 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 |

FlashData शामिल-अनुरोध गणना पूर्ण साझा शेष को मानक YouTube डेटा में आवंटित करती है। विस्तारित खोज और डाउनलोड की अलग-अलग दरें हैं। [पूरी मूल्य सूची](https://flashdata.dev/hi/pricing/youtube-data).

### उदाहरण: 1,000 वीडियो के लिए मेटाडेटा और कैप्शन

2,000 अनुरोध, कोई खोज खोज नहीं। FlashData जाते ही भुगतान करें बनाम ScrapeCreators Freelance। केवल देखे गए कैश हिट की गणना करें; आपके अपने स्थानीय भंडारण के माध्यम से टाले गए अनुरोध किसी भी प्रदाता को सबमिट नहीं किए जाते हैं।

| मुफ़्त कैश हिट | FlashData कॉल | FlashData उपयोग | FlashData खरीद | ScrapeCreators क्रेडिट | ScrapeCreators उपयोग मूल्य | ScrapeCreators खरीद |
| --- | --- | --- | --- | --- | --- | --- |
| 0 | 2,000 | $1.00 | $10.00 | 2,000 | $3.76 | $47.00 |
| 1,000 | 2,000 | $1.00 | $10.00 | 1,000 | $1.88 | $47.00 |
| 2,000 | 2,000 | $1.00 | $10.00 | 0 | $0.00 | $0.00 |

USD, अनुरोधों का एक महीना। एक ताजा मेटाडेटा लुकअप, मूल-कैप्शन परिणाम या मानक खोज अनुरोध एक ScrapeCreators क्रेडिट का उपयोग करता है। मेटाडेटा प्लस कैप्शन दोनों तरफ दो अनुरोधों का उपयोग करता है। केवल ऊपर दर्ज किए गए मेटाडेटा/transcript कैश हिट काटे जाते हैं; खोज कैशिंग नहीं मानी गई है. यह मॉडल लौटाए गए कैप्शन को गिनता है, न कि मिस्ड-ट्रैक प्रयासों को, और एआई जेनरेशन को बाहर करता है। FlashData अपने वर्तमान मानक YouTube डेटा कीमतों का उपयोग करता है, अतिरिक्त उपयोग से पहले संपूर्ण चयनित योजना भत्ता आवंटित करता है। विस्तारित खोज और डाउनलोड की कीमत अलग-अलग है। आरंभिक शेष, परीक्षण, बोनस क्रेडिट, कर और अन्य उपयोग को बाहर रखा गया है। खरीदारी शून्य बैलेंस से शुरू होती है: FlashData टॉप-अप में न्यूनतम $10 होता है; ScrapeCreators खरीदारी पूरे चयनित पैक तक होती है। अप्रयुक्त खरीदे गए क्रेडिट बाद के कार्यों को पूरा कर सकते हैं। ScrapeCreators का कोई मासिक पैक नवीनीकरण नहीं है; एक चयनित FlashData मासिक योजना का शुल्क अभी भी शून्य अनुरोध पर है।

### कैश व्यवहार

समर्थित मेटाडेटा/transcript समापन बिंदुओं पर, cache_max_age 1d, 3d, 7d, 14d या 30d स्वीकार करता है। हिट शून्य क्रेडिट का उपयोग करते हैं और रिपोर्ट cached_at करते हैं; मिसेज़ सामान्य दर का उपयोग करते हैं। खोज कैश हिट मान्य नहीं हैं. तय करें कि क्या सहेजा गया डेटा कार्य के लिए पर्याप्त ताज़ा है। [नतीजे सेव करें और दोबारा उपयोग करें](https://flashdata.dev/hi/docs/guides/save-results/reference.md).

### ऑफर शुरू

ScrapeCreators 100 निःशुल्क क्रेडिट से शुरू होता है। योग्य सत्यापित FlashData साइनअप 4,000 मानक YouTube डेटा अनुरोध तक प्रारंभिक भत्ता प्राप्त कर सकते हैं। ये ऑफर मासिक रूप से रीसेट नहीं होते हैं। अलग अस्थायी एजेंट परीक्षण नीचे दिखाई देता है।

<a id="migration"></a>
## एक वीडियो और उसके कैप्शन टाइमस्टैम्प को माइग्रेट करें

### 1. पहुंच सेट करें और ट्रैक चुनें

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

मौजूदा अनुरोध, केवल मैपिंग के लिए:

```bash
# Existing call, for mapping only; reuse your saved key.
curl --get --fail-with-body --silent --show-error \
  'https://api.scrapecreators.com/v1/youtube/video/transcript' \
  --header "x-api-key: $SCRAPECREATORS_API_KEY" \
  --data-urlencode 'url=https://www.youtube.com/watch?v=FUfGcZ092b0' \
  --data-urlencode 'language=en'
```

FlashData POST https://data.flashdata.dev/v1/queries/realtime X-API-Key के साथ और यह JSON बॉडी:

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

original_audio=true बोलचाल की भाषा चुनता है। FlashData params.auto=true YouTube-जनरेटेड कैप्शन का चयन करता है। भाषा और मूल को अलग-अलग निर्दिष्ट करें।

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

Python 3.10+ आवश्यक है। python -m pip install requests से आवश्यक पैकेज इंस्टॉल करें। नए कार्य फ़ोल्डर में नीचे दिया पूरा स्क्रिप्ट creator-research.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")
    transcript = []
    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")
        transcript.append({"text": text,
                           "startMs": str(math.floor(start * 1000 + 0.5)),
                           "endMs": str(math.floor(end * 1000 + 0.5)),
                           "startTimeText": f"{int(start) // 60}:{int(start) % 60:02d}"})
    normalized = {"videoId": item["videoId"],
                  "url": "https://www.youtube.com/watch?v=" + item["videoId"],
                  "transcript": transcript, "transcript_only_text": item.get("fullText"),
                  "language": item.get("languageName"), "languageCode": item["languageCode"],
                  "isAutoGenerated": item["isAutoGenerated"]}
else:
    duration = item.get("duration")
    if duration is not None and (type(duration) not in (int, float)
                                or not math.isfinite(duration) or duration < 0):
        raise SystemExit("Invalid video duration")
    normalized = {"id": item["videoId"], "title": item.get("title"),
                  "url": "https://www.youtube.com/watch?v=" + item["videoId"],
                  "description": item.get("description"),
                  "viewCountInt": item.get("viewCount"), "likeCountInt": item.get("likeCount"),
                  "commentCountInt": item.get("commentCount"),
                  "durationMs": None if duration is None else math.floor(duration * 1000 + 0.5),
                  "channel": {"id": item.get("channelId"), "title": item.get("channel")},
                  "uploadDateRaw": item.get("uploadDate")}
(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 creator-research.py transcript FUfGcZ092b0 captions-001
# Optional metadata, run separately:
python creator-research.py metadata FUfGcZ092b0 metadata-001
```

अपलोडर द्वारा प्रदान किए गए कैप्शन के लिए --origin मैनुअल जोड़ें। डिफ़ॉल्ट YouTube-जनरेटेड अंग्रेजी कैप्शन है।

वैकल्पिक रूप से, Bash, cURL 7.76+ और jq 1.6+ का उपयोग करें। नीचे दी गई पूरी स्क्रिप्ट को एक नए कार्यशील फ़ोल्डर में creator-research.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
      if .duration == null then .
      elif (.duration | type) != "number" then error("Invalid video duration")
      elif (.duration | isfinite | not) or .duration < 0 then error("Invalid video duration") else . end
      | {id: .videoId, title, url: ("https://www.youtube.com/watch?v=" + .videoId), description,
         viewCountInt: .viewCount, likeCountInt: .likeCount, commentCountInt: .commentCount,
         durationMs: (if .duration == null then null else (.duration * 1000 | round) end),
         channel: {id: .channelId, title: .channel}, uploadDateRaw: .uploadDate}
    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
      | if (.segments | type) != "array" then error("Expected caption segments") else . end
      | {videoId, url: ("https://www.youtube.com/watch?v=" + .videoId),
         transcript_only_text: .fullText, language: .languageName, languageCode, isAutoGenerated,
         transcript: [.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, startMs: (.start * 1000 | round | tostring), endMs: (.end * 1000 | round | tostring),
            startTimeText: (((.start / 60 | floor) | tostring) + ":" +
              ((.start | floor) % 60 | if . < 10 then "0" + tostring else tostring end))} 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 creator-research.sh transcript FUfGcZ092b0 captions-001
# Optional metadata, run separately:
bash creator-research.sh metadata FUfGcZ092b0 metadata-001
```

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

### 3. मैप किए गए आउटपुट और वास्तविक उपयोग को पढ़ें

कैप्शन-001/normalized.json एक फ़ील्ड एडाप्टर है; response.json कच्ची प्रतिक्रिया और वास्तविक उपयोग को बरकरार रखता है। सेकंड स्ट्रिंग मिलीसेकंड बन जाते हैं। languageCode और isAutoGenerated चयनित ट्रैक को सुरक्षित रखें। यह पूर्ण ड्रॉप-इन प्रतिक्रिया नहीं है: कोई निर्मित क्रेडिट शेष, कैश फ़्लैग, अपलोडर एट्रिब्यूशन या दिनांक फ़ील्ड नहीं है। मेटाडेटा लुप्त मेट्रिक्स को null और उसकी मूल तिथि को uploadDateRaw के रूप में संरक्षित करता है।

```json
{
  "videoId": "FUfGcZ092b0",
  "url": "https://www.youtube.com/watch?v=FUfGcZ092b0",
  "transcript": [
    {
      "text": "Example caption text.",
      "startMs": "1250",
      "endMs": "3500",
      "startTimeText": "0:01"
    }
  ],
  "transcript_only_text": "Example caption text.",
  "language": "English",
  "languageCode": "en-orig",
  "isAutoGenerated": true
}
```

| ScrapeCreators एकीकरण | FlashData परिवर्तन |
| --- | --- |
| GET /v1/youtube/video?url=… | POST क्वेरी API स्रोत के साथ: youtube_metadata और video_id। परिणाम पढ़ें[0], प्रतिक्रिया रूट नहीं। |
| GET /v1/youtube/video/transcript?url=… | स्रोत का उपयोग करें: youtube_transcript. params.language और params.auto को स्पष्ट रूप से सेट करें। |
| प्रतिलेख[].startMs / endMs | FlashData प्रारंभ/अंत सेकंड हैं। प्रत्येक को 1,000 से गुणा करें और मौजूदा मिलीसेकंड रीडर के लिए स्ट्रिंग के रूप में क्रमबद्ध करें। |
| original_audio=true | ScrapeCreators में बोली जाने वाली भाषा का चयन करता है, ऑटो-जेनरेटेड कैप्शन का नहीं। अपने ऐप में आवश्यक भाषा का समाधान करें; params.auto इसके बजाय कैप्शन मूल का चयन करता है। |
| भाषा और transcript_only_text | मानचित्र languageName और fullText. languageCode अलग रखें; एक भाषा का नाम और एक भाषा कोड अलग-अलग क्षेत्र हैं। |
| viewCountInt, likeCountInt, commentCountInt | मानचित्र viewCount, likeCount, commentCount. जब कोई मीट्रिक अनुपस्थित हो तो null को सुरक्षित रखें। |
| durationMs और publishDate | अवधि सेकंड को मिलीसेकंड में बदलें। uploadDate को एक कच्चे फ़ील्ड के रूप में तब तक सुरक्षित रखें जब तक कि आपका ऐप उसके लिए आवश्यक दिनांक प्रारूप को मान्य नहीं कर लेता। |
| चैनल / अपलोडर / ownerByline | FlashData चैनल और channelId तीनों पहचानों को पुन: पेश नहीं करते हैं। मानचित्र केवल वही फ़ील्ड्स रखता है जिनकी आपके पाठक को आवश्यकता है; संगीत-क्रेडिट एट्रिब्यूशन के लिए एक अलग पथ रखें। |
| cached, cached_at, credits_charged | FlashData कच्ची प्रतिक्रिया और उपयोग रखें। अपना खुद का लाने का समय रिकॉर्ड करें; प्रदाता कैश फ़्लैग का निर्माण न करें या प्रदाताओं के बीच क्रेडिट संतुलन का अनुवाद न करें। |

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

### यदि पहला अनुरोध विफल हो जाता है

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

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

<a id="workflow"></a>
## खोजें → संक्षिप्त सूची → समृद्ध → उद्धरण

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

10 खोज अनुरोध प्लस 50 मेटाडेटा और कैप्शन के साथ शॉर्टलिस्ट किए गए वीडियो को स्थानीय पुन: उपयोग से पहले 110 मानक अनुरोधों की आवश्यकता होती है। खोज लागत को संवर्धन से अलग करें। एक खोज परिणाम स्वयं एक अलग खोज अनुरोध नहीं है।

### खोज कोई ड्रॉप-इन कर्सर माइग्रेशन नहीं है

ScrapeCreators continuationToken के साथ कई प्रकार के परिणाम लौटा सकता है। FlashData की मानक खोज वीडियो परिणाम लौटाती है; इसकी विस्तारित खोज की अलग सीमाएँ और मूल्य निर्धारण हैं। पुराने कर्सर का पुन: उपयोग करने के बजाय एक नया डिस्कवरी रन प्रारंभ करें।

[YouTube संदर्भ खोजें](https://flashdata.dev/hi/docs/sources/youtube_search/reference.md)

### उत्तर के साथ साक्ष्य भी रखें

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

[टाइमस्टैम्प वाले कैप्शन का उदाहरण](https://flashdata.dev/hi/docs/guides/timestamped-captions-recipe/reference.md)

### Scale ID सूची अलग से

एक लुकअप काम करने के बाद, किसी सूची के लिए batch अनुरोधों या किसी फ़ाइल के लिए थोक प्रसंस्करण का उपयोग करें। कार्य ट्रैक करें IDs, completed आउटपुट सहेजें और केवल failed आइटम पुनः प्रयास करें। अपने धावक को शेड्यूल के लिए जिम्मेदार रखें।

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

<a id="agents"></a>
## माइग्रेशन को शेड्यूल करने से पहले उसे साबित करें

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

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

```text
Migrate only this app's YouTube metadata and native-caption calls to FlashData.
Read https://flashdata.dev/auth.md and https://flashdata.dev/agents.md first.
Reuse saved access; start an eligible trial only if needed. Keep credentials out of chat.
Inspect our current fields, language choice, original_audio behavior and cache freshness requirements.
Keep comments, other social platforms and unsupported fields on their existing path.
Run one known video with explicit language and caption origin. Save the raw response and usage.
Map timestamps from seconds to string milliseconds; preserve null counts and missing-track errors.
Reuse saved output before requesting it again. Do not retry an uncertain submission automatically.
Before recurring use, ask the owner to claim access and approve permissions and shared-balance use.
Persist the resulting credential and stop on revocation or insufficient balance.
```

[ट्रायल और खाते से लिंक करना](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>
## इससे पहले कि आप स्विच करें

### क्या ये मासिक सदस्यताएँ हैं?

ScrapeCreators Freelance और Business प्रीपेड पैक हैं, सदस्यता नहीं। दोनों का मासिक शुल्क $0 है। FlashData में पे-एज़-यू-गो क्रेडिट और वैकल्पिक मासिक योजनाएं हैं। अपने वर्तमान शेष से उपभोग किए गए उपयोग और आवश्यक खरीदारी की अलग-अलग तुलना करें।

### यदि मेरे अधिकांश ScrapeCreators अनुरोध कैश्ड हो जाएं तो क्या होगा?

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

### क्या अप्रयुक्त क्रेडिट समाप्त हो जाते हैं?

ScrapeCreators का कहना है कि खरीदे गए क्रेडिट इसकी वर्तमान नीति के तहत समाप्त नहीं होते हैं। इसका मुफ़्त 100-क्रेडिट आरंभिक ऑफर मासिक रीफ़िल नहीं है। FlashData का अस्थायी एजेंट परीक्षण समाप्त हो रहा है; इसके मूल्य निर्धारण और खाता पृष्ठ लागू स्वामी-शेष शर्तों का वर्णन करते हैं।

### क्या original_audio=true params.auto=true के रूप में काम करेगा?

नहीं, पहला व्यक्ति बोले गए ऑडियो के आधार पर एक भाषा चुनता है; दूसरा YouTube-जनरेटेड कैप्शन चुनता है। जानबूझकर एक भाषा और मूल निर्धारित करें। मिलान ट्रैक अनुपस्थित होने पर किसी भी सेवा का मूल-कैप्शन समापन बिंदु वाक्-से-पाठ नहीं बनाता है।

### क्या मैं अपनी सभी सामाजिक-डेटा कॉलें बदल सकता हूँ?

इस माइग्रेशन में YouTube वीडियो मेटाडेटा और मौजूदा कैप्शन शामिल हैं। टिप्पणियाँ, सामुदायिक पोस्ट, सामाजिक प्रोफ़ाइल और किसी भी अन्य असमर्थित प्रतिक्रिया फ़ील्ड को उनके मौजूदा पथ पर रखें। FlashData अपनी स्वयं की अनुमतियों और मूल्य निर्धारण के साथ Google खोजें और होस्ट किया गया YouTube डाउनलोड भी प्रदान करता है।

### क्या ScrapeCreators भी AI एजेंटों का समर्थन करता है?

हाँ. यह MCP, OAuth, एक CLI और एजेंट कौशल प्रदान करता है। FlashData का एजेंट प्रवाह एक योग्य अस्थायी परीक्षण, मालिक का दावा और निरंतर उपयोग के लिए सहेजे गए क्रेडेंशियल जोड़ता है। आपके कार्य के लिए आवश्यक API और वर्कफ़्लो चुनें; MCP अकेले समर्थन से कोई फर्क नहीं पड़ता।
