# Oxylabs YouTube डेटा के लिए वैकल्पिक | FlashData

YouTube मेटाडेटा और कैप्शन के लिए FlashData और Oxylabs की तुलना करें: बिलिंग इकाइयां, सदस्यता लागत, एजेंट पहुंच, और क्लासिक या वेब API से Python/Bash माइग्रेशन।

मासिक प्रतिबद्धता के बिना वीडियो अनुसंधान। भाषा, मूल और टाइमस्टैम्प को संरक्षित करते हुए मेटाडेटा और कैप्शन कार्यों को FlashData PAYG पर ले जाएं।

यह पेज YouTube डेटा को कवर करता है। [SERP के लिए Oxylabs का विकल्प](https://flashdata.dev/hi/compare/oxylabs/reference.md) कवर Google अलग से खोजें।

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

- [विशेषताएं](#features)
- [मूल्य निर्धारण](#pricing)
- [प्रवास](#migration)
- [Production और एजेंट](#production)
- [प्रश्न](#faq)

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

### वीडियो रिसर्च के लिए Flexible खर्च

| विशेषता | FlashData | Oxylabs YouTube |
| --- | --- | --- |
| मासिक सदस्यता के बिना भुगतान किया गया उपयोग | हाँ — PAYG; क्रेडिट टॉप-अप $10 से शुरू होता है | नहीं — वर्तमान सशुल्क स्व-सेवा के लिए सक्रिय सदस्यता की आवश्यकता होती है |
| मेटाडेटा-केवल लुकअप · 1,000 वीडियो | $0.50 — 1,000 मानक स्रोत अनुरोध · PAYG | समापन बिंदु दर की पुष्टि करें — सार्वजनिक वीडियो डेटा API मूल्य प्रति जीबी है, मेटाडेटा अनुरोध उद्धरण नहीं |
| केवल कैप्शन लुकअप · 1,000 वीडियो | $0.50 — प्रति वीडियो एक चयनित मौजूदा ट्रैक · PAYG | समर्पित उपशीर्षक समापन बिंदु — अपने खाते में इसकी बिलिंग इकाई की पुष्टि करें |
| साझा Google खोज और YouTube संतुलन | हाँ | हाँ — साझा उत्पाद क्रेडिट संतुलन |

### वीडियो ढूंढें और उनके मेटाडेटा को ताज़ा करें

| विशेषता | FlashData | Oxylabs YouTube |
| --- | --- | --- |
| कीवर्ड खोज और खोज सुझाव | हाँ — खोज, विस्तारित खोज और सुझाव स्रोत | हाँ — YouTube खोज, खोज/max और स्वत: पूर्ण समापन बिंदु |
| किसी ज्ञात वीडियो के लिए मेटाडेटा ID | हाँ — शीर्षक, चैनल, अवधि, थंबनेल और सहभागिता गणना | हाँ — समर्पित मेटाडेटा समापन बिंदु एक वीडियो स्वीकार करता है ID |
| अध्याय और उपलब्ध कैप्शन भाषाएँ | हाँ — वैकल्पिक अध्याय प्लस transcriptLanguages | हाँ — मेटाडेटा में अध्याय मार्कर और उपशीर्षक भाषाएँ |

### नियंत्रित करें कि कौन सा कैप्शन साक्ष्य आपके ऐप तक पहुंचता है

| विशेषता | FlashData | Oxylabs YouTube |
| --- | --- | --- |
| मेटाडेटा से स्वतंत्र रूप से कैप्शन पुनर्प्राप्त करें | हाँ — समर्पित प्रतिलेख और कैप्शन स्रोत | हाँ — समर्पित YouTube उपशीर्षक समापन बिंदु |
| कैप्शन भाषा और मूल का चयन करें | हाँ — स्पष्ट भाषा और स्वत: चयन | हाँ — language_code और subtitle_origin |
| एक अनुरोध में कई भाषाएँ | 10 तक चयनित भाषाएँ — एक स्पष्ट भाषा सरणी ट्रैक और त्रुटियाँ लौटाती है | एक चयनित भाषा या सभी — सभी भाषाओं के लिए language_code हटा दें; दोनों मूलों के लिए subtitle_origin को छोड़ दें |
| स्रोत उद्धरणों के लिए पाठ और समय | सामान्यीकृत खंड + fullText — सेकंड में JSON प्रारंभ/end बार | YouTube उपशीर्षक ट्रैक पेलोड — पाठ और समय को भाषा और मूल के आधार पर समूहीकृत किया गया |
| अनुपलब्ध अनुरोधित ट्रैक | सरणी अनुरोधों में प्रति-भाषा त्रुटियाँ — सफल ट्रैक रखें; स्थिति done होने पर भी त्रुटियों का निरीक्षण करें | गुम ट्रैक के लिए ख़ाली परिणाम — मिलान के बिना एक वैध भाषा कोड लौटाता है {} |
| किसी एप्लिकेशन या एलएलएम के लिए डेटा तैयार करें | JSON, सादा पाठ या Markdown — API प्रतिक्रिया और सामग्री प्रारूप का चयन करें | डेटा या कस्टम JSON निष्कर्षण को ट्रैक करें — उपशीर्षक निष्कर्षण एक संकेत या एक स्कीमा स्वीकार करता है |

### सूचियों को संसाधित करें और एजेंट की पहुंच को पुन: प्रयोज्य रखें

| विशेषता | FlashData | Oxylabs YouTube |
| --- | --- | --- |
| इंटरएक्टिव, async और batch मोड | हाँ — निष्पादन मोड में समान स्रोत अनुरोध आकार | हाँ — वेब API मेटाडेटा और उपशीर्षक सिंक का समर्थन करते हैं, async और batch |
| एक तैयार वीडियो सूची जमा करें | ID फ़ाइल Bulk Jobs में — कंसोल या API; प्रगति की निगरानी करें और परिणाम भागों को पुनः प्राप्त करें | बैच में ID सरणी API — साझा पैरामीटर batch में हर नौकरी पर लागू होते हैं |
| अपने भंडारण में एक बड़ा संग्रह सहेजें | थोक प्रकट और परिणाम भाग — थोक आउटपुट के लिए प्रबंधित या ग्राहक भंडारण | Async भंडारण वितरण — S3, S3-संगत भंडारण, GCS और TOS |
| मालिक खाता सेटअप से पहले एजेंट परीक्षण | हाँ — योग्य एजेंट: 100 तक मानक अनुरोध, फिर मालिक का दावा | पहले एक खाता पंजीकृत करें — $5 प्रति टीम एकमुश्त स्वागत क्रेडिट |
| स्टैंडअलोन CLI बिना Node.js या Python | हाँ — Linux, macOS और Windows | HTTP API, MCP और कौशल — समीक्षा किए गए सेटअप दस्तावेज़ों में कोई समकक्ष स्टैंडअलोन बाइनरी सत्यापित नहीं है |
| एक एजेंट होस्ट के लिए MCP और कौशल | हाँ — चल रहे कार्यों के लिए स्वीकृत स्वामी पहुंच का पुन: उपयोग करें | हाँ — वेब API MCP सर्वर और एजेंट कौशल |

### सामयिक शोध को किफायती रखें

FlashData भुगतान करते समय कोई मासिक शुल्क नहीं है। अपने कार्य के लिए आवश्यक वीडियो प्राप्त करें और Google खोजें और YouTube के लिए एक संतुलन रखें।

### स्रोत अनुरोधों में बजट

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

### केवल सारांश नहीं, बल्कि साक्ष्य भी रखें

कैप्शन टेक्स्ट को उसकी भाषा, मूल और टाइमस्टैम्प के साथ सहेजें। माइग्रेशन उदाहरण प्रत्येक खंड के लिए स्रोत लिंक बनाते हैं और मूल प्रतिक्रिया और उपयोग को संरक्षित करते हैं।

<a id="pricing"></a>
## योजनाओं और बिलिंग इकाइयों की तुलना करें

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

| Oxylabs योजना | मासिक शुल्क | साझा संतुलन शामिल है | प्रकाशित वीडियो डेटा API दर | मेटाडेटा/caption अनुरोध शामिल हैं |
| --- | --- | --- | --- | --- |
| Starter | $15.00 | $15.00 | $2.00/GB | कोई निश्चित गिनती प्रकाशित नहीं |
| Basic | $100.00 | $100.00 | $2.00/GB | कोई निश्चित गिनती प्रकाशित नहीं |
| Flexible | $500.00 | $500.00 | $1.60/GB | कोई निश्चित गिनती प्रकाशित नहीं |

उद्यम अनुरूप शर्तों के साथ $2,500/माह से शुरू होता है। USD; कर, अन्य उत्पाद उपयोग और कस्टम अनुबंध शामिल नहीं हैं।

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

Oxylabs सशुल्क स्व-सेवा एक सक्रिय सदस्यता और एक साझा मासिक क्रेडिट शेष का उपयोग करती है। अप्रयुक्त शेष राशि नवीकरण पर समाप्त हो जाती है; टॉप-अप या अपग्रेड होने तक सेवा शून्य पर रुक जाती है। $5 स्वागत क्रेडिट एक बार का टीम भत्ता है, मासिक कोटा नहीं। मौजूदा क्लासिक या कस्टम अनुबंधों की शर्तें अलग-अलग हो सकती हैं।

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

<a id="migration"></a>
## एक मौजूदा कैप्शन ट्रैक माइग्रेट करें

### 1. मौजूदा अनुरोध को पहचानें

ये उसी अंग्रेजी, YouTube-जनरेटेड ट्रैक के लिए संदर्भ अनुरोध हैं। दोनों एक वीडियो ID का उपयोग करते हैं, URL का नहीं। क्लासिक संदर्भ प्रविष्टियों का उपयोग करता है; वेब API शीर्ष-स्तरीय विकल्पों का उपयोग करता है।

```bash
# Existing Classic request; use your current credential environment.
curl --fail-with-body --silent --show-error \
  --user "$OXYLABS_USERNAME:$OXYLABS_PASSWORD" \
  --header 'Content-Type: application/json' \
  --data '{
    "source": "youtube_subtitles",
    "query": "FUfGcZ092b0",
    "context": [
      {"key": "language_code", "value": "en"},
      {"key": "subtitle_origin", "value": "auto_generated"}
    ]
  }' \
  'https://realtime.oxylabs.io/v1/queries'
```

```bash
# Newer Web API request; query is a video ID, not a URL.
curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $OXYLABS_API_KEY" \
  --header 'Content-Type: application/json' \
  --data '{
    "query": "FUfGcZ092b0",
    "language_code": "en",
    "subtitle_origin": "auto_generated"
  }' \
  'https://webapi.oxylabs.io/v1/scrape/media/youtube/subtitles'
```

### 2. FlashData सेट करें और फ़ाइलें सहेजें

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

यूट्यूब-माइग्रेशन/ बनाएं और इसे यूट्यूब-माइग्रेशन/request.json: के रूप में सहेजें

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

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

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

import requests

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

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

if not (out / "http-status.txt").exists():
    raise SystemExit("Incomplete attempt. Keep the folder and check History before retrying.")
status = (out / "http-status.txt").read_text().strip()
if status != "200":
    raise SystemExit(f"HTTP {status}: inspect {out}/result.json and response-headers.txt")
try:
    data = json.loads((out / "result.json").read_bytes())
except ValueError:
    raise SystemExit("Invalid JSON; inspect the saved result.json")
request = json.loads((out / "request.json").read_bytes())
if not isinstance(data, dict) or data.get("source") != "youtube_captions" or data.get("status") != "done":
    raise SystemExit("Caption request did not finish successfully; inspect result.json")
tracks = data.get("results")
if not isinstance(tracks, list) or len(tracks) != 1 or not isinstance(tracks[0], dict):
    raise SystemExit("Expected one caption track; inspect result.json")
track = tracks[0]
language = request["params"]["language"]
allowed_languages = [language]
if request["params"]["auto"] and not language.endswith("-orig"):
    allowed_languages.append(language + "-orig")
if (track.get("videoId") != request["video_id"]
        or track.get("languageCode") not in allowed_languages
        or track.get("requestedLanguageCode", track.get("languageCode")) != language
        or track.get("isAutoGenerated") is not request["params"]["auto"]):
    raise SystemExit("Returned video, language or caption origin does not match the request")
if not isinstance(track.get("segments"), list):
    raise SystemExit("Expected a segments array; inspect result.json")
segments = []
for cue in track["segments"]:
    if not isinstance(cue, dict):
        raise SystemExit("Expected caption segment objects")
    start, end, text = cue.get("start"), cue.get("end"), cue.get("text")
    if (type(start) not in (int, float) or not math.isfinite(start) or start < 0
            or type(end) not in (int, float) or not math.isfinite(end) or end < start
            or not isinstance(text, str)):
        raise SystemExit("Invalid caption timing or text; inspect result.json")
    segments.append({**cue, "url": f"https://www.youtube.com/watch?v={track['videoId']}&t={math.floor(start)}s"})
captions = {**track, "segments": segments}
record = {"request": request, "requested_at": (out / "requested-at.txt").read_text().strip(),
          "usage": data.get("usage"), "segment_count": len(segments), "result_file": "result.json"}
for filename, value in (("captions.json", captions), ("record.json", record)):
    (out / filename).write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
print(f"Saved {len(segments)} segments to {out}/captions.json")
if not any(cue["text"].strip() for cue in segments):
    print("No caption text to cite. Keep the empty track and report the gap.")

```

यूट्यूब-माइग्रेशन/ के अंदर से, चलाएँ:

```bash
python captions.py track-001
python -m json.tool track-001/captions.json
python -m json.tool track-001/record.json
```

वैकल्पिक रूप से, Bash, cURL 7.76+ और jq 1.6+ का उपयोग करें। संपूर्ण स्क्रिप्ट को youtube-migration/captions.sh: के रूप में सहेजें

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

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

if [[ ! -f "$out/http-status.txt" ]] || [[ "$(cat "$out/http-status.txt")" != 200 ]]; then
  printf 'Incomplete or failed attempt. Inspect the saved files and History before retrying.\n' >&2
  exit 1
fi
captions=$(jq -e --slurpfile request "$out/request.json" '
  if .source != "youtube_captions" or .status != "done"
  then error("Expected a successful youtube_captions response") else . end
  | .results
  | if type != "array" then error("Expected a results array")
    elif length != 1 then error("Expected exactly one track") else .[0] end
  | $request[0].params.language as $language
  | if type != "object" then error("Expected a caption object")
    elif .videoId != $request[0].video_id or (.requestedLanguageCode // .languageCode) != $language
      or (.languageCode != $language and ($request[0].params.auto != true
        or ($language | endswith("-orig")) or .languageCode != ($language + "-orig")))
      or .isAutoGenerated != $request[0].params.auto
    then error("Returned video, language or caption origin does not match the request") else . end
  | if (.segments | type) != "array" then error("Expected a segments array") else . end
  | .videoId as $id
  | .segments |= map(
      if type != "object" then error("Expected caption segment objects") else . end
      | if (.start | type) != "number" or (.end | type) != "number" or (.text | type) != "string"
        then error("Invalid caption timing or text")
        elif (.start | isfinite | not) or (.end | isfinite | not) or .start < 0 or .end < .start
        then error("Invalid caption timing")
        else . + {url: ("https://www.youtube.com/watch?v=" + $id + "&t=" + (.start | floor | tostring) + "s")} end
    )' "$out/result.json")
printf '%s\n' "$captions" > "$out/captions.json"
jq --slurpfile request "$out/request.json" --slurpfile captions "$out/captions.json" \
  --arg requested_at "$(tr -d '\r\n' < "$out/requested-at.txt")" \
  '{request: $request[0], requested_at: $requested_at, usage,
    segment_count: ($captions[0].segments | length), result_file: "result.json"}' \
  "$out/result.json" > "$out/record.json"
printf 'Saved %s segments to %s/captions.json\n' "$(jq '.segments | length' "$out/captions.json")" "$out"
if ! jq -e 'any(.segments[]; .text | test("\\S"))' "$out/captions.json" > /dev/null; then
  printf 'No caption text to cite. Keep the empty track and report the gap.\n'
fi

```

यूट्यूब-माइग्रेशन/ के अंदर से, चलाएँ:

```bash
bash captions.sh track-001
jq . track-001/captions.json
jq . track-001/record.json
```

एक नया फ़ोल्डर एक अनुरोध सबमिट करता है। API कॉल के बिना इसकी सहेजी गई प्रतिक्रिया को पढ़ने के लिए उसी कमांड को दोहराएं। प्रत्येक फ़ोल्डर का अपना अनुरोध होता है; request.json बदलने से मौजूदा रन नहीं बदलता है। दूसरा फ़ोल्डर बनाने से पहले अधूरे प्रयासों का समाधान करें।

### 3. इसका हवाला देने से पहले ट्रैक की जाँच करें

ट्रैक-001/captions.json में स्रोत लिंक के साथ चेक किए गए सेगमेंट शामिल हैं; record.json अनुरोध, समय और उपयोग रखता है; result.json कच्ची प्रतिक्रिया है। स्क्रिप्ट वीडियो, भाषा और मूल को सत्यापित करती है, एक मेल खाते ऑटो-कैप्शन-मूल संस्करण को स्वीकार करती है, और ओवरलैपिंग सेगमेंट को संरक्षित करती है। खंड समय सेकंड हैं. गुम या खाली कैप्शन एक डेटा गैप है, जेनरेटेड ट्रांसक्रिप्ट नहीं।

उदाहरणात्मक captions.json अंश:

```json
{
  "videoId": "FUfGcZ092b0",
  "languageCode": "en",
  "isAutoGenerated": true,
  "segments": [
    {
      "start": 12.5,
      "end": 16.2,
      "text": "Illustrative caption text; the actual track varies.",
      "url": "https://www.youtube.com/watch?v=FUfGcZ092b0&t=12s"
    }
  ]
}
```

| चिंता | मौजूदा Oxylabs एकीकरण | FlashData परिवर्तन |
| --- | --- | --- |
| प्रमाणीकरण | क्लासिक: HTTP Basic उपयोगकर्ता नाम/password. वेब API: बियरर API कुंजी। | X-API-Key: FLASHDATA_API_KEY. मौजूदा Oxylabs क्रेडेंशियल स्थानांतरित नहीं होते हैं। |
| मेटाडेटा | क्लासिक youtube_metadata; वेब API /media/youtube/metadata. क्वेरी वीडियो ID है। | स्रोत: youtube_metadata, video_id: वही 11-वर्ण ID। |
| कैप्शन | क्लासिक youtube_subtitles; वेब API /media/youtube/subtitles. | स्रोत: पाठ और समय के लिए youtube_captions; youtube_transcript जब आपके पार्सर को भी fullText की आवश्यकता हो। |
| भाषा और उत्पत्ति | क्लासिक संदर्भ प्रविष्टियाँ; वेब API language_code और subtitle_origin। उन्हें छोड़ने से एकाधिक ट्रैक वापस आ सकते हैं। | params.language और params.auto को स्पष्ट रूप से सेट करें। ऑटो: true = YouTube-उत्पन्न; false = अपलोडर द्वारा प्रदान किया गया। कभी भी किसी ट्रैक को चुपचाप प्रतिस्थापित न करें। |
| प्रतिक्रिया पार्सर | क्लासिक और वेब API में अलग-अलग परिणाम लिफाफे और समूहीकृत उपशीर्षक आउटपुट हैं। | स्थिति जांचें: done, फिर परिणाम[].videoId, languageCode, isAutoGenerated और खंड। खंड प्रारंभ/end सेकंड हैं। |
| एसिंक IDs | वेब API metadata.request_id; क्लासिक कार्य IDs अपने स्वयं के परिणाम समापन बिंदुओं का उपयोग करें। | FlashData सबमिशन रसीद सहेजें और इसके प्रबंधन कार्य समापन बिंदु का उपयोग करें। प्रदाता IDs को अलग रखें; Oxylabs मतदान URL का पुन: उपयोग न करें। |

### वैकल्पिक मेटाडेटा कार्य

अनुदान youtube_metadata अनुमति. POST इस शरीर को https://data.flashdata.dev/v1/queries/realtime के साथ X-API-Key तक। यह एक अलग मानक अनुरोध है. स्थिति जांचें: परिणाम पढ़ने से पहले done[0]।

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

[कैप्शन फ़ील्ड](https://flashdata.dev/hi/docs/sources/youtube_captions/reference.md) · [मेटाडेटा फ़ील्ड](https://flashdata.dev/hi/docs/sources/youtube_metadata/reference.md).

<a id="production"></a>
## आवर्ती कार्य और पुनर्प्राप्ति

एक बार इकट्ठा करो, कई बार विश्लेषण करो। सारांश और एम्बेडिंग के लिए सहेजे गए ट्रैक का पुन: उपयोग करें; स्रोत डेटा को केवल तभी ताज़ा करें जब कार्य को इसकी आवश्यकता हो।

| स्थिति | क्या करें? |
| --- | --- |
| एक चयनित ट्रैक अनुपस्थित है | Oxylabs बिना मिलान वाले उपशीर्षक के एक वैध भाषा के लिए एक खाली वस्तु लौटा सकता है। गुम या खाली कैप्शन टेक्स्ट को डेटा गैप के रूप में मानें; प्रतिलेख का निर्माण न करें. |
| एक बड़ा batch आंशिक रूप से स्वीकार किया जाता है | Oxylabs वेब API दस्तावेज़ प्रति batch तक 5,000 नौकरियों तक और अलग स्वीकृत/rejected प्रविष्टियाँ। स्वीकृत IDs बरकरार रखें. FlashData के लिए, खाते के maxBatchSize को काट लें और प्रत्येक लौटाई गई नौकरी ID को बरकरार रखें। |
| एक realtime कॉल का समय समाप्त | अनुरोध फ़ोल्डर रखें और किसी अन्य सबमिशन से पहले इतिहास का निरीक्षण करें। लंबी-running कतारों के लिए, async सबमिशन का उपयोग करें, इसकी रसीद तुरंत सहेजें और मौजूदा कार्य को पोल करें। |
| एक खाता या क्रेडेंशियल परिवर्तन | मेज़बान के गुप्त स्टोर में API कुंजी रखें। 401/403 पर रुकें; 402 पर शेष राशि का समाधान करें; सम्मान Retry-After पर 429. ख़त्म हो चुके संतुलन को दरकिनार करने के लिए नए सिरे से परीक्षण शुरू न करें। |

| 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) · [त्रुटियाँ](https://flashdata.dev/hi/docs/errors/reference.md).

योग्य एजेंट 72 घंटों के लिए 1 क्रेडिट (100 मानक अनुरोध तक) के साथ शुरुआत कर सकते हैं।

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

```text
Migrate one Oxylabs YouTube subtitle task to FlashData.
Read https://flashdata.dev/auth.md and reuse existing access first.
Use youtube_captions with the same video ID, language and caption origin.
Keep the source request, raw response, usage and timestamped segments.
Check the video, language and origin; report an absent track instead of inventing text.
Save the script before running it, and reuse a completed output folder.
For recurring work, finish owner claiming and store its credential securely.
Stop on revoked access or depleted balance. Never paste credentials into chat.
```

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

### क्या FlashData एक ड्रॉप-इन प्रतिस्थापन है?

नहीं, प्रमाणीकरण, अनुरोध फ़ील्ड, प्रतिक्रिया पार्सिंग और कार्य पुनर्प्राप्ति बदलें। उदाहरण एक कैप्शन कार्य को एक स्थिर एप्लिकेशन रिकॉर्ड में अनुकूलित करते हैं; वे Oxylabs प्रतिक्रिया लिफाफे की नकल नहीं करते हैं।

### क्या मैं प्रवास के दौरान अपना क्लासिक Oxylabs एकीकरण बनाए रख सकता हूँ?

हाँ. एक समय में एक कार्य को आगे बढ़ाएं, सहेजे गए क्लासिक परिणामों को बनाए रखें और प्रदाता द्वारा क्रेडेंशियल्स और नौकरी IDs को अलग रखें। मैपिंग में क्लासिक स्रोत/context अनुरोध और नए वेब API एंडपॉइंट अनुरोध दोनों शामिल हैं।

### क्या कैप्शन गायब होने पर FlashData एक प्रतिलेख उत्पन्न करता है?

ये स्रोत मौजूदा YouTube कैप्शन पुनर्प्राप्त करते हैं। ऑटो: true YouTube-जनरेटेड उपशीर्षक का चयन करता है; यह ताज़ा भाषण-से-पाठ का अनुरोध नहीं करता है। गुम हुए ट्रैक की रिपोर्ट करें, या ट्रांसक्रिप्शन को एक अलग वर्कफ़्लो के रूप में प्रबंधित करें।

### वास्तविक वीडियो डाउनलोड करने के बारे में क्या ख्याल है?

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

### मेरे मौजूदा Oxylabs वर्कफ़्लो में क्या रहना चाहिए?

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

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