# Supadata Alternatif untuk YouTube Data

Bandingkan YouTube kos transkrip dan metadata, ciri kapsyen asli dan akses ejen. Berhijrah dari Supadata dengan contoh runnable Python dan Bash.

Supadata fakta disemak 2026-11-10. FlashData harga dan elaun percubaan menggunakan katalog awam semasanya.

- [Ciri-ciri](#features)
- [Bandingkan kos](#costs)
- [Pindahkan transkrip](#migration)
- [Metadata & pukal](#workflows)
- [Untuk ejen AI](#agents)
- [Soalan Lazim](#faq)

<a id="features"></a>
## Perbandingan ciri

Untuk apl dan ejen yang mengumpul YouTube kapsyen dan metadata sedia ada.

### Simpan berbayar YouTube penjimatan pengambilan

| Ciri | FlashData | Supadata |
| --- | --- | --- |
| Penggunaan berbayar tanpa langganan | ya — Kredit bayar semasa anda pergi; pembelian dari $10 | Pelan berbayar — Basic: $60/tahun · Pro: $17/bulan |
| Transkrip atau metadata asli · harga setiap 1,000 | $0.50 — Bayar semasa anda pergi · tiada yuran bulanan | $5.67 pada Pro — $17 / 3,000 included credits; full allowance digunakan |
| Batch tanpa pelan bulanan | Sehingga 100 pertanyaan / Kelompok — Kunci pemilik bayar semasa anda pergi; had percubaan adalah berasingan | Pro dan ke atas — Video dan transkrip batch titik tamat |

### Cari video dan bina perpustakaan penyelidikan

| Ciri | FlashData | Supadata |
| --- | --- | --- |
| Cari video mengikut topik | ya — Carian kata kunci dengan tarikh, tempoh, jenis dan penapis pengisihan | ya — Carian video, saluran dan senarai main dengan penapis |
| Muat semula metadata video tanpa mengambil kapsyen | ya — Tajuk, saluran, tempoh, lakaran kecil dan kiraan penglibatan | ya — Asingkan titik akhir metadata dengan medan pengarang, media dan statistik |
| Bahasa kapsyen dalam metadata video | ya — hasTranscripts dan transcriptLanguages | Dalam respons transkrip — availableLangs; skema metadata berasingan |

### Simpan transkrip berguna untuk petikan dan analisis

| Ciri | FlashData | Supadata |
| --- | --- | --- |
| Teks bercap masa untuk petikan sumber | JSON segmen dalam beberapa saat — Teks dengan masa mula dan tamat | JSON ketulan dalam milisaat — Teks dengan ofset dan tempoh |
| Teks penuh dan cap masa daripada respons yang sama | ya — fullText dan segmen dikembalikan bersama | Pilih teks atau ketulan — text=true mengembalikan rentetan; jika tidak sertai bahagian dalam apl anda |
| Berbilang bahasa kapsyen sedia ada dalam satu permintaan | Sehingga 10 bahasa — Ralat trek dan setiap bahasa | Satu bahasa pilihan — lang pada titik akhir transkrip |
| Pilih kapsyen yang disediakan oleh pemuat naik atau YouTube yang dihasilkan | ya — Eksplisit params.auto=false atau true | Tiada pemilih asal didokumenkan — mod memilih perolehan asli berbanding penjanaan AI |
| Mengendalikan kapsyen yang tidak tersedia secara eksplisit | Trek sedia ada sahaja — Tatasusunan bahasa mengembalikan trek ditambah ralat; tiada transkripsi baharu | Pilih sandaran asli atau AI — mod=auto boleh menjana ucapan-ke-teks; had asal pengambilan semula kepada kapsyen sedia ada |

### Beralih daripada satu permintaan kepada aliran kerja yang boleh diulang

| Ciri | FlashData | Supadata |
| --- | --- | --- |
| Permintaan interaktif dan latar belakang | Masa nyata atau async — Pilih mod pelaksanaan dan simpan kerja ID | Keputusan atau kerja transkrip — HTTP 200 mengembalikan data; HTTP 202 mengembalikan pekerjaan ID |
| Memproses senarai video yang disediakan | Konsol kelompok API atau Bulk Jobs — Muat naik fail ID; simpan bahagian nyata dan hasil | Async batch API · Pro+ — Menerima senarai video, senarai main atau saluran |
| Kumpulkan keseluruhan senarai main atau saluran | Bekalkan video eksplisit IDs — Sediakan senarai sebelum pemprosesan Kumpulan atau pukal | Video Senarai main atau saluran batch input — Regular videos; excludes Shorts and live |
| Output untuk aplikasi dan LLM | JSON, teks biasa atau Markdown — Pilih jawapan dan format kandungan | JSON dengan teks atau ketulan — Gunakan kandungan transkrip dalam aplikasi atau gesaan anda |
| SDK Bahasa | Python, TypeScript dan Pergi | Python dan JavaScript / TypeScript |
| MCP akses untuk hos ejen | ya — Jauh MCP dengan OAuth atau kunci API | ya — MCP pelayan dengan Supadata kelayakan |
| Percubaan terprogram sebelum pendaftaran pemilik | ya — Sehingga 100 permintaan transkrip asli · 72 jam | Kunci akaun API dahulu — 100 kredit percuma setiap bulan selepas pendaftaran |

Supadata menyokong transkripsi yang dijana AI dan berbilang platform sosial. Titik akhir kapsyen FlashData mendapatkan semula runut YouTube sedia ada. Kedua-dua perkhidmatan menawarkan MCP dan SDK.

### Pastikan beban kerja penyelidikan yang kecil mampu milik

Bayar untuk YouTube permintaan data yang anda gunakan. Tambahkan langganan kemudian jika kadar yang lebih rendah dan baki yang disertakan sesuai dengan volum anda.

[Harga beban kerja anda](#costs)

### Pastikan sumber kapsyen jelas

Pilih kapsyen YouTube yang dihasilkan atau disediakan oleh pemuat naik, simpan bahasa yang dikembalikan dan simpan cap masa untuk petikan. Minta runut sedia ada dalam beberapa bahasa tanpa menghasilkan pertuturan-ke-teks baharu.

[Petakan pembaca transkrip anda](#migration)

### Tumbuh daripada satu video kepada saluran paip

Gunakan bentuk permintaan yang sama untuk realtime, async dan batch kerja. Tambahkan Google Cari pada aliran kerja penyelidikan menggunakan akaun yang sama dan baki yang dikongsi.

[Bina langkah seterusnya](#workflows)

<a id="costs"></a>
## Harga aliran kerja video yang lengkap

USD. Satu transkrip asli dalam satu bahasa atau satu carian metadata ialah satu permintaan dan satu Supadata kredit. Metadata serta transkrip asli ialah dua permintaan bagi setiap video. FlashData menggunakan katalog data YouTube langsungnya, menggunakan nilai kredit yang disertakan sebelum penggunaan tambahan. Kadar unit yang dipaparkan ialah kadar penggunaan; Supadata ialah yuran pelan dibahagikan dengan elaun bulanan penuh. Basic adalah tahunan sahaja: $60 dibayar pendahuluan, ditunjukkan sebagai $5/bulan bersamaan dengan 300 kredit setiap bulan, bukan 3,600 tersedia serta-merta. Pelan Supadata lain menggunakan harga senarai bulanan. Auto Recharge dimatikan dalam anggaran ini sehingga dipilih; apabila dipilih, keseluruhan pek diterbitkan terkecil menampung kekurangan. Masa cas semula automatik sebenar mungkin membeli lebih awal. Jumlah pembelian menganggap tiada baki permulaan. FlashData tambah nilai bermula pada $10; pembelian boleh meninggalkan dana untuk kemudian. Supadata kredit bulanan tidak berguling. Kredit percubaan, cukai, penggunaan API lain, diskaun tahunan pada pelan lain, penjanaan AI dan terjemahan dikecualikan. Pada permintaan sifar, yuran pelan yang dipilih kekal, dan kadar efektif tidak ditentukan.

### FlashData YouTube Pelan data

| FlashData pelan | Setiap 1,000 permintaan | Yuran bulanan | Permintaan disertakan sebulan |
| --- | --- | --- | --- |
| Bayar mengikut penggunaan | $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 |

[Harga YouTube Data penuh](https://flashdata.dev/ms/pricing/youtube-data)

### Supadata rancangan diterbitkan

| Supadata pelan | Pelan pembayaran | Kredit / bulan | Setiap 1,000 pada elaun penuh | Pek Auto Recharge |
| --- | --- | --- | --- | --- |
| Percuma | $0.00 / bulan | 100 | $0.00 | Tidak tersedia |
| Basic · annual only | $60.00 / tahun ($5.00 / setara bulan) | 300 | $16.67 | $10.00 / 1,000 kredit |
| Pro · monthly | $17.00 / bulan | 3,000 | $5.67 | $10.00 / 1,000 kredit |
| Mega · monthly | $47.00 / bulan | 30,000 | $1.57 | $10.00 / 5,000 kredit |
| Giga · monthly | $297.00 / bulan | 300,000 | $0.99 | $20.00 / 20,000 kredit |
| Supa · monthly | $897.00 / bulan | 1,000,000 | $0.90 | $20.00 / 20,000 kredit |

### Contoh: metadata serta transkrip asli untuk setiap video

FlashData bayar semasa anda pergi berbanding Supadata Mega bulanan, termasuk Auto Recharge. Ini adalah satu perbandingan pelan yang jelas; pilih pelan lain secara bebas dalam kalkulator HTML.

| Video / bulan | Permintaan data | FlashData penggunaan model | Supadata Mega + pek cas semula keseluruhan | Pek cas semula |
| --- | --- | --- | --- | --- |
| 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 |

### Akses percuma dan penjanaan AI

Supadata Isi semula percuma 100 kredit setiap bulan. Transkrip aslinya menggunakan satu kredit; Penjanaan AI menggunakan dua kredit seminit. Oleh itu, transkrip yang dijana selama 30-minit menggunakan 60 kredit. Mod auto lalai boleh mencetuskan penjanaan; mod=asli mengelakkan sandaran itu. Penjanaan, terjemahan dan Carian Lanjutan dikecualikan daripada perbandingan ini.

FlashData pendaftaran yang disahkan layak boleh menerima elaun permulaan sehingga 4,000 standard YouTube Permintaan data. Ia bukan peringkat percuma bulanan.

<a id="migration"></a>
## Pindahkan pembaca transkrip asli

| Berubah | Supadata | FlashData | apa nak buat |
| --- | --- | --- | --- |
| Permintaan | GET /v1/transcript dengan url, lang, teks dan mod | POST /v1/queries/realtime dengan sumber, video_id dan params | Ekstrak 11-watak YouTube ID. Kunci Supadata tidak mengesahkan kepada FlashData. |
| Pengesahan | kunci-x-api: kunci Supadata anda | X-API-Key: kunci FlashData anda | Cipta atau gunakan semula bukti kelayakan dengan kebenaran youtube_transcript. Nama pengepala tidak peka huruf besar-besaran; perubahan tauliah. |
| Asli berbanding dijana | mod=native mendapatkan semula kapsyen sedia ada; auto boleh kembali kepada AI; jana sentiasa menggunakan AI | youtube_transcript membaca kapsyen YouTube sedia ada | Alihkan pengambilan asli dahulu. Simpan langkah pertuturan ke teks yang berasingan untuk video yang memerlukan transkripsi baharu. |
| Asal kapsyen | mod memilih perolehan semula berbanding penjanaan | params.auto=true memilih kapsyen yang dihasilkan YouTube; false memilih kapsyen yang disediakan oleh pemuat naik | Tetapan auto ini tidak setara. FlashData auto tidak pernah memulakan pertuturan ke teks. |
| Bahasa | lang diutamakan; bahasa yang tidak tersedia boleh kembali kepada bahasa pertama yang tersedia | params.language adalah jelas; auto=true mencuba varian -orig kemudian kod yang diminta | Semak languageCode dan requestedLanguageCode. FlashData tidak memilih bahasa lain atau asal kapsyen secara senyap. |
| Segmen | kandungan[]: teks, mengimbangi dan tempoh dalam milisaat | keputusan[0].segmen[]: teks, mula dan tamat dalam beberapa saat | offset = bulat(mula × 1000); tempoh = pusingan((akhir − mula) × 1000). Kekalkan pertindihan daripada beralih isyarat. |
| Teks biasa | text=true mengembalikan kandungan sebagai rentetan | keputusan[0].fullText | Baca fullText untuk ringkasan dan simpan segmen untuk petikan cap masa. |
| Penemuan bahasa | availableLangs dalam respons transkrip | transcriptLanguages dalam youtube_metadata | Ambil metadata apabila apl anda memerlukan senarai bahasa penuh. Jangan cipta availableLangs dari satu lagu yang dikembalikan. |
| penyiapan | HTTP 200 keputusan, atau HTTP 202 + jobId | Status masa nyata=done; async penyerahan pulangan FlashData pekerjaan IDs | Mengendalikan keadaan setiap pembekal secara berasingan. Selesaikan Supadata kerja sedia ada di sana sebelum memindahkan kerja baharu. |

### 1. Sediakan akses

Cipta atau gunakan semula kunci FlashData dengan kebenaran youtube_transcript dalam [API Kunci](https://flashdata.dev/app/api-keys). Tambahkan youtube_metadata untuk tugas metadata pilihan. Semak [kredit yang ada](https://flashdata.dev/app/billing) atau gunakan [akses percubaan ejen yang layak](#agents). Simpan kunci dalam persekitaran atau stor rahsia.

Supadata permintaan asli diganti:

```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 penggantian JSON badan untuk POST /v1/queries/realtime:

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

### 2. Simpan skrip, kemudian jalankannya

Pilih Python atau Bash. Setiap folder keluaran baharu menyerahkan satu permintaan; menggunakan semula folder membaca output yang disimpan tanpa panggilan API lagi. Versi berkongsi format fail yang disimpan. Pilih video dengan runut kapsyen yang diminta.

#### Python

Memerlukan Python 3.10+. Pasang kebergantungan dengan python -m pip install requests. Dalam folder kerja baharu, simpan skrip lengkap di bawah sebagai youtube-migrate.py sebelum menjalankannya.

```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'))}")

```

Jalankan dari folder kerja itu:

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

Ini memilih kapsyen Bahasa Inggeris yang dijana YouTube. Tambahkan --origin manual untuk trek yang disediakan pemuat naik, atau --language KOD untuk memilih bahasa.

Permintaan metadata berasingan pilihan:

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

#### Bash

Memerlukan Bash, cURL 7.76+ dan jq 1.6+. Simpan skrip lengkap ini sebagai youtube-migrate.sh dalam folder kerja anda sebelum running ia:

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

```

Jalankan dari folder kerja itu:

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

Argumen pilihan selepas folder ialah bahasa dan asal; contohnya en manual memilih kapsyen bahasa Inggeris yang disediakan oleh pemuat naik.

Permintaan metadata berasingan pilihan:

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

Untuk akses percubaan sementara, jalankan permintaan secara berurutan sekurang-kurangnya satu saat.

### 3. Baca output

response.json mengekalkan hasil mentah dan penggunaan. normalized.json menukarkan segmen transkrip saat kepada offset/duration milisaat. Ini ialah penyesuai segmen, bukan respons serasi Supadata lengkap: availableLangs tidak direka-reka. Output metadata mengekalkan nilai yang boleh dibatalkan. Permintaan yang gagal atau terganggu menyimpan buktinya dan berhenti.

Ilustrasi normalized.json:

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

[Skema transkrip](https://flashdata.dev/ms/docs/sources/youtube_transcript/reference.md)

<a id="workflows"></a>
## Metadata dan aliran kerja pukal

| Data | Supadata /v1/metadata | FlashData youtube_metadata |
| --- | --- | --- |
| Identiti video | id | keputusan[0].videoId |
| Tajuk dan huraian | tajuk, penerangan | keputusan[0].tajuk, keputusan[0].huraian |
| Saluran | author.displayName; additionalData.channelId | keputusan [0].saluran; keputusan[0].channelId |
| Pertunangan | stats.views, stats.likes, stats.comments | keputusan[0].viewCount, likeCount, commentCount |
| Tempoh | media.duration (saat) | keputusan[0].tempoh (saat) |
| Gambar kecil | media.thumbnailUrl | hasil[0].gambar kecil[]; pilih saiz yang diperlukan oleh apl anda |
| Tarikh penerbitan | createdAt | keputusan[0].uploadDate; normalkan formatnya dalam apl anda |
| Penemuan kapsyen | Baca availableLangs daripada respons transkrip | keputusan[0].hasTranscripts dan transcriptLanguages |

### Beberapa bahasa sedia ada dalam satu permintaan

Hantar tatasusunan bahasa untuk menerima runut dan ralat, walaupun untuk tatasusunan yang mengandungi satu bahasa. Periksa ralat walaupun status adalah done. Ini adalah runut sedia ada, bukan terjemahan atau kapsyen yang dijana.

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

### Memperkaya perpustakaan penyelidikan

Ambil metadata sekali, simpan videonya ID dan bahasa kapsyen yang tersedia, kemudian dapatkan semula trek yang anda perlukan. Pastikan penglibatan boleh batal dikira sebagai null dan bukannya menukarnya kepada sifar.

[YouTube Amalan terbaik data](https://flashdata.dev/ms/docs/guides/youtube-data-guide/reference.md)

### Proses senarai video IDs

Kembangkan input anda ke dalam video eksplisit IDs, kemudian gunakan Batch atau fail pukal. FlashData tidak menerima Supadata playlistId sebagai input batch lungsur masuk. Simpan status dan output setiap item sebelum mencuba semula failed item.

[Rujukan pemprosesan pukal](https://flashdata.dev/ms/docs/reference/bulk-processing/reference.md)

### Jalankan penyelidikan mengikut jadual

Kekalkan bukti kelayakan pemilik, pusat pemeriksaan completed video dan baca output yang disimpan semasa dimulakan semula. Berhenti untuk akses yang dibatalkan atau baki tidak mencukupi; jangan buat percubaan lain untuk meneruskan kerja yang dijadualkan.

[Tugas ejen berulang](https://flashdata.dev/ms/docs/guides/recurring-tasks/reference.md)

### Production keputusan migrasi

- Selesaikan senarai main/channel input kepada video eksplisit IDs sebelum FlashData Pemprosesan fail kelompok atau pukal; Supadata playlistId bukan input drop-in.
- Kos carian Supadata satu kredit setiap halaman 20-hasil, atau siling(had/20) dengan had. FlashData standard YouTube Carian menyokong sehingga 20 hasil; Carian Lanjutan mempunyai kadar yang berasingan. Penapis peta dan jangan pindahkan token halaman.
- Supadata mendokumenkan tetingkap hasil kerja transkrip completed satu jam. Toskan kerja sedia ada di sana dan simpan hasil sebelum memindahkan kerja baharu. Simpan tugas khusus pembekal IDs berasingan.
- Simpan media merentas platform, pengekstrakan AI, terjemahan dan transkripsi audio pada laluan sedia ada mereka melainkan aliran kerja yang setara telah dilaksanakan.

<a id="agents"></a>
## Percubaan ejen, tuntutan dan penggunaan berulang

Ejen yang layak boleh bermula dengan 1 kredit, sehingga 100 permintaan transkrip asli untuk 72 jam. Metadata dan transkrip berkongsi elaun ini.

1. Guna semula akses sedia ada dahulu; sebaliknya mulakan satu percubaan yang layak dengan hanya kebenaran yang diperlukan.
2. Kembalikan hasil yang berguna, simpan output mentah dan penggunaan, dan simpan profil dan direktori keadaan yang sama.
3. Pemilik log masuk atau mendaftar, mengesahkan e-mel dan meluluskan tuntutan, skop dan akses baki dikongsi.
4. Gunakan semula bukti kelayakan pemilik untuk tugasan berulang. Kredit percubaan yang tidak digunakan tidak dipindahkan. Berhenti selepas pembatalan atau baki tidak mencukupi; jangan buat percubaan lain untuk diteruskan.

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

[Perbicaraan dan tuntutan](https://flashdata.dev/ms/docs/guides/agent-onboarding/reference.md) · [Berdiri sendiri CLI](https://flashdata.dev/ms/docs/guides/flashdata-cli/reference.md) · [MCP sambungan](https://flashdata.dev/ms/docs/integrations/mcp-clients/reference.md)

<a id="faq"></a>
## Soalan migrasi

### Bolehkah FlashData menggantikan transkripsi AI Supadata?

Sumber transkrip dan kapsyen FlashData mendapatkan semula kapsyen yang sudah ada pada YouTube. Mereka tidak menyalin audio, menterjemah teks atau melakukan analisis visual. Pindahkan perolehan YouTube asli ke FlashData; simpan perkhidmatan yang berasingan untuk pertuturan-ke-teks, video merentas platform atau pengekstrakan AI apabila aplikasi anda memerlukannya.

### Apa yang dibeli oleh satu permintaan?

Kalkulator meliputi satu transkrip sedia ada dalam satu bahasa atau satu carian metadata video. Mengambil kedua-duanya menggunakan dua permintaan setiap video. Supadata mengebil setiap operasi ini pada satu kredit. FlashData menggunakan kadar data YouTube pelan yang dipilih. Carian Lanjutan, transkripsi AI, terjemahan dan penghantaran media adalah di luar anggaran ini.

### Adakah FlashData sentiasa lebih murah?

Bandingkan beban kerja sebenar anda dan rancangan yang dipilih. Supadata termasuk 100 kredit setiap bulan secara Percuma. Percubaan ejen sementara FlashData adalah terhad dan tamat tempoh; ia bukan peringkat percuma bulanan. Pada volum rendah, elaun percuma mungkin meliputi keseluruhan tugas. Yuran pelan berbayar, pek caj semula dan baki yang tidak digunakan mempengaruhi jumlah yang anda bayar.

### Adakah Supadata sudah menyokong MCP dan SDK?

ya. Kedua-dua perkhidmatan menyokong penyepaduan MCP dan Python/JavaScript. FlashData juga menyediakan Go SDK, CLI kendiri dan percubaan ejen sementara yang boleh dituntut untuk akses berulang. Pilih antara muka yang disokong oleh hos anda; MCP sahaja bukan sebab untuk bertukar.

### Apakah yang berlaku jika runut kapsyen tiada?

Anggap ia sebagai jurang data. FlashData tidak bertukar antara kapsyen yang disediakan pemuat naik dan YouTube yang dijana atau mensintesis transkrip. Untuk tatasusunan bahasa, periksa ralat walaupun permintaan ialah done. Supadata boleh menjana transkrip dalam mod auto, manakala mod asli boleh mengembalikan HTTP 206 untuk transkrip yang tidak tersedia; dokumentasinya membilkan respons itu pada satu kredit.

### Bolehkah saya mengekalkan bentuk respons aplikasi sedia ada?

Simpan penyesuai anda sendiri. Contoh menukar FlashData segmen kepada entri kandungan dengan mengimbangi dan tempoh dalam milisaat, tetapi tidak menuntut respons serasi Supadata yang lengkap. Baca FlashData metadata jika anda memerlukan bahasa yang tersedia, dan pindahkan status kerja, ralat dan pengendalian penggunaan secara eksplisit.

[Dapatkan kunci API](https://flashdata.dev/signup)
