# Supadata Alternatif untuk YouTube Data

Bandingkan biaya transkrip dan metadata YouTube, fitur teks asli, dan akses agen. Bermigrasi dari Supadata dengan contoh Python dan Bash yang dapat dijalankan.

Supadata fakta ditinjau 2026-11-10. FlashData harga dan tunjangan uji coba menggunakan katalog publik saat ini.

- [Fitur](#features)
- [Bandingkan biaya](#costs)
- [Migrasikan transkrip](#migration)
- [Metadata & massal](#workflows)
- [Untuk agen AI](#agents)
- [Pertanyaan Umum](#faq)

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

Untuk aplikasi dan agen yang mengumpulkan YouTube keterangan dan metadata yang ada.

### Tetap dibayar YouTube pengambilan ekonomis

| Fitur | FlashData | Supadata |
| --- | --- | --- |
| Penggunaan berbayar tanpa berlangganan | Ya — Kredit bayar sesuai pemakaian; pembelian mulai $10 | Paket berbayar — Basic: $60/tahun · Pro: $17/bulan |
| Transkrip atau metadata asli · harga per 1,000 | $0.50 — Bayar sesuai pemakaian · tanpa biaya bulanan | $5.67 pada Pro — $17 / 3,000 included credits; full allowance digunakan |
| Batch tanpa paket bulanan | Hingga 100 kueri / Batch — Kunci pemilik bayar sesuai pemakaian; batas percobaannya terpisah | Pro dan lebih tinggi — Video dan transkrip batch titik akhir |

### Temukan video dan bangun perpustakaan penelitian

| Fitur | FlashData | Supadata |
| --- | --- | --- |
| Temukan video berdasarkan topik | Ya — Pencarian kata kunci dengan filter tanggal, durasi, jenis dan pengurutan | Ya — Pencarian video, saluran, dan daftar putar dengan filter |
| Segarkan metadata video tanpa mengambil teks | Ya — Judul, saluran, durasi, gambar mini, dan jumlah keterlibatan | Ya — Pisahkan titik akhir metadata dengan bidang penulis, media, dan statistik |
| Bahasa teks dalam metadata video | Ya — hasTranscripts dan transcriptLanguages | Dalam transkrip tanggapan — availableLangs; skema metadata terpisah |

### Jaga agar transkrip tetap berguna untuk kutipan dan analisis

| Fitur | FlashData | Supadata |
| --- | --- | --- |
| Teks dengan stempel waktu untuk kutipan sumber | JSON segmen dalam hitungan detik — Teks dengan waktu mulai dan berakhir | JSON potongan dalam milidetik — Teks dengan offset dan durasi |
| Teks lengkap dan stempel waktu dari respons yang sama | Ya — fullText dan segmen dikembalikan bersama-sama | Pilih teks atau potongan — text=true mengembalikan string; jika tidak, gabunglah dengan bagian-bagian di aplikasi Anda |
| Beberapa bahasa teks yang ada dalam satu permintaan | Hingga 10 bahasa — Trek dan kesalahan per bahasa | Satu bahasa pilihan — parameter lang pada titik akhir transkrip |
| Pilih teks yang disediakan pengunggah atau teks yang dibuat oleh YouTube | Ya — Eksplisit params.auto=false atau true | Tidak ada pemilih asal yang didokumentasikan — mode memilih pengambilan asli versus generasi AI |
| Tangani teks yang tidak tersedia secara eksplisit | Hanya trek yang ada — Array bahasa mengembalikan trek ditambah kesalahan; tidak ada transkripsi baru | Pilih pengganti asli atau AI — mode=auto dapat menghasilkan ucapan-ke-teks; bawaan membatasi pengambilan teks yang ada |

### Beralih dari satu permintaan ke alur kerja berulang

| Fitur | FlashData | Supadata |
| --- | --- | --- |
| Permintaan interaktif dan latar belakang | Waktu nyata atau async — Pilih mode eksekusi dan simpan pekerjaan ID | Hasil atau transkrip pekerjaan — HTTP 200 mengembalikan data; HTTP 202 mengembalikan pekerjaan ID |
| Proses daftar video yang sudah disiapkan | Konsol batch API atau Bulk Jobs — Unggah file ID; simpan bagian manifes dan hasil | Asinkron batch API · Pro+ — Menerima daftar video, daftar putar, atau saluran |
| Kumpulkan seluruh daftar putar atau saluran | Sediakan video eksplisit IDs — Siapkan daftar sebelum pemrosesan batch atau massal | Video Masukan daftar putar atau saluran batch — Regular videos; excludes Shorts and live |
| Output untuk aplikasi dan LLM | JSON, teks biasa atau Markdown — Pilih respons dan format konten | JSON dengan teks atau potongan — Gunakan konten transkrip dalam aplikasi atau perintah Anda |
| SDK Bahasa | Python, TypeScript dan Pergi | Python dan JavaScript / TypeScript |
| MCP akses untuk host agen | Ya — Jarak jauh MCP dengan tombol OAuth atau API | Ya — MCP server dengan kredensial Supadata |
| Uji coba terprogram sebelum pemilik mendaftar | Ya — Hingga 100 permintaan transkrip asli · 72 jam | Kunci akun API terlebih dahulu — 100 kredit gratis setiap bulan setelah pendaftaran |

Supadata mendukung transkripsi yang dihasilkan AI dan berbagai platform sosial. Titik akhir keterangan FlashData mengambil trek YouTube yang ada. Kedua layanan menawarkan MCP dan SDK.

### Jaga agar beban kerja penelitian kecil tetap terjangkau

Bayar untuk YouTube permintaan data yang Anda gunakan. Tambahkan langganan nanti jika tarif yang lebih rendah dan saldo yang disertakan sesuai dengan volume Anda.

[Hargai beban kerja Anda](#costs)

### Jaga agar sumber teks tetap eksplisit

Pilih teks yang dibuat YouTube atau yang disediakan pengunggah, pertahankan bahasa yang dikembalikan dan pertahankan stempel waktu untuk kutipan. Minta trek yang ada dalam beberapa bahasa tanpa menghasilkan ucapan-ke-teks baru.

[Petakan pembaca transkrip Anda](#migration)

### Berkembang dari satu video ke saluran pipa

Gunakan bentuk permintaan yang sama untuk pekerjaan realtime, async dan batch. Tambahkan Google Pencarian ke alur kerja penelitian menggunakan akun dan saldo bersama yang sama.

[Bangun langkah selanjutnya](#workflows)

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

USD. Satu transkrip asli dalam satu bahasa atau satu pencarian metadata berarti satu permintaan dan satu kredit Supadata. Metadata ditambah transkrip asli adalah dua permintaan per video. FlashData menggunakan katalog data YouTube langsungnya, menerapkan nilai kredit yang disertakan sebelum penggunaan tambahan. Tarif satuan yang ditampilkan adalah tarif penggunaan; Supadata adalah biaya paket dibagi dengan tunjangan bulanan penuh. Basic hanya bersifat tahunan: $60 dibayar di muka, ditampilkan sebagai $5/bulan setara dengan 300 kredit setiap bulan, bukan 3,600 tersedia segera. Paket Supadata lainnya menggunakan daftar harga bulanan. Isi Ulang Otomatis tidak aktif dalam perkiraan ini hingga dipilih; ketika dipilih, keseluruhan paket terkecil yang diterbitkan menutupi kekurangan tersebut. Waktu isi ulang otomatis yang sebenarnya dapat dibeli lebih awal. Jumlah pembelian mengasumsikan tidak ada saldo awal. FlashData isi ulang mulai dari $10; pembelian mungkin menyisakan dana untuk nanti. Supadata kredit bulanan tidak diperpanjang. Kredit percobaan, pajak, penggunaan API lainnya, diskon tahunan untuk paket lain, pembuatan dan terjemahan AI tidak termasuk. Jika tidak ada permintaan, biaya paket yang dipilih tetap ada, dan tarif efektif tidak ditentukan.

### FlashData YouTube Paket data

| FlashData rencana | Per 1,000 permintaan | Biaya bulanan | Permintaan yang termasuk per bulan |
| --- | --- | --- | --- |
| Bayar sesuai 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 |

[Penuh YouTube Harga data](https://flashdata.dev/id/pricing/youtube-data)

### Supadata rencana yang diterbitkan

| Supadata rencana | Rencanakan pembayaran | Kredit / bulan | Per 1,000 dengan tunjangan penuh | Paket Isi Ulang Otomatis |
| --- | --- | --- | --- | --- |
| Gratis | $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 ditambah transkrip asli untuk setiap video

FlashData bayar sesuai pemakaian versus Supadata Mega bulanan, termasuk Isi Ulang Otomatis. Ini adalah perbandingan rencana yang eksplisit; pilih paket lain secara mandiri di kalkulator HTML.

| Video / bulan | Permintaan data | FlashData penggunaan model | Supadata Mega + seluruh paket isi ulang | Paket isi ulang |
| --- | --- | --- | --- | --- |
| 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 gratis dan generasi AI

Supadata Isi ulang gratis 100 kredit bulanan. Transkrip aslinya menggunakan satu kredit; Generasi AI menggunakan dua kredit per menit. Oleh karena itu, transkrip yang dihasilkan 30 menit menggunakan kredit 60. Mode otomatis default dapat memicu pembangkitan; mode=native menghindari fallback itu. Pembuatan, terjemahan, dan Pencarian Diperluas tidak termasuk dalam perbandingan ini.

Pendaftaran FlashData terverifikasi yang memenuhi syarat dapat menerima tunjangan awal hingga 4,000 standar YouTube Permintaan data. Ini bukan tingkat gratis bulanan.

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

| Perubahan | Supadata | FlashData | Apa yang harus dilakukan |
| --- | --- | --- | --- |
| Permintaan | GET /v1/transcript dengan url, bahasa, teks dan mode | POST /v1/queries/realtime dengan sumber, video_id dan params | Ekstrak karakter 11 YouTube ID. Kunci Supadata tidak mengautentikasi ke FlashData. |
| Otentikasi | x-api-key: kunci Supadata Anda | X-API-Key: kunci FlashData Anda | Buat atau gunakan kembali kredensial dengan izin youtube_transcript. Nama header tidak peka huruf besar-kecil; kredensial berubah. |
| Asli versus dihasilkan | mode=native mengambil teks yang ada; otomatis dapat kembali ke AI; menghasilkan selalu menggunakan AI | youtube_transcript membaca keterangan YouTube yang ada | Pindahkan pengambilan asli terlebih dahulu. Buat langkah ucapan-ke-teks terpisah untuk video yang memerlukan transkripsi baru. |
| Asal teks | mode memilih pengambilan versus pembuatan | params.auto=true memilih teks yang dihasilkan YouTube; false memilih teks yang disediakan pengunggah | Pengaturan otomatis ini tidak setara. FlashData otomatis tidak pernah memulai ucapan-ke-teks. |
| Bahasa | lang lebih disukai; bahasa yang tidak tersedia dapat dikembalikan ke bahasa pertama yang tersedia | params.language eksplisit; auto=true mencoba varian -orig lalu kode yang diminta | Centang languageCode dan requestedLanguageCode. FlashData tidak diam-diam memilih bahasa atau asal teks lain. |
| Segmen | konten[]: teks, offset dan durasi dalam milidetik | hasil[0].segmen[]: teks, mulai dan berakhir dalam hitungan detik | offset = bulat(mulai × 1000); durasi = putaran((akhir − awal) × 1000). Pertahankan tumpang tindih daripada menggeser isyarat. |
| Teks biasa | text=true mengembalikan konten sebagai string | hasil[0].fullText | Baca fullText untuk ringkasan dan simpan segmen untuk kutipan stempel waktu. |
| Penemuan bahasa | availableLangs dalam respons transkrip | transcriptLanguages di youtube_metadata | Ambil metadata saat aplikasi Anda memerlukan daftar bahasa lengkap. Jangan menciptakan availableLangs dari satu jalur yang dikembalikan. |
| Penyelesaian | HTTP 200 hasil, atau HTTP 202 + jobId | Status waktu nyata=done; async kiriman dikembalikan FlashData pekerjaan IDs | Tangani setiap negara bagian penyedia secara terpisah. Selesaikan Supadata pekerjaan yang ada di sana sebelum memigrasikan pekerjaan baru. |

### 1. Siapkan akses

Buat atau gunakan kembali kunci FlashData dengan izin youtube_transcript di [API Kunci](https://flashdata.dev/app/api-keys). Tambahkan youtube_metadata untuk tugas metadata opsional. Centang [kredit yang tersedia](https://flashdata.dev/app/billing) atau gunakan [akses uji coba agen yang memenuhi syarat](#agents). Simpan kunci di lingkungan atau penyimpanan rahasia.

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, lalu jalankan

Pilih Python atau Bash. Setiap folder keluaran baru mengirimkan satu permintaan; menggunakan kembali folder akan membaca keluaran yang disimpan tanpa panggilan API lainnya. Versi-versi tersebut berbagi format file yang disimpan. Pilih video dengan trek teks yang diminta.

#### Python

Memerlukan Python 3.10+. Instal dependensi dengan python -m pip install requests. Di folder kerja baru, 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
```

Tindakan ini akan memilih teks bahasa Inggris yang dihasilkan YouTube. Tambahkan --origin manual untuk trek yang disediakan pengunggah, atau --language CODE untuk memilih bahasa.

Permintaan metadata terpisah opsional:

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

#### Bash

Membutuhkan Bash, cURL 7.76+ dan jq 1.6+. Simpan skrip lengkap ini sebagai youtube-migrate.sh di folder kerja Anda sebelum running:

```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 opsional setelah folder adalah bahasa dan asal; misalnya en manual memilih teks bahasa Inggris yang disediakan pengunggah.

Permintaan metadata terpisah opsional:

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

Untuk akses uji coba sementara, jalankan permintaan secara berurutan dengan jarak setidaknya satu detik.

### 3. Baca hasilnya

response.json mempertahankan hasil mentah dan penggunaan. normalized.json mengubah detik segmen transkrip menjadi offset/duration milidetik. Ini adalah adaptor segmen, bukan respons lengkap yang kompatibel dengan Supadata: availableLangs tidak dibuat-buat. Output metadata mempertahankan nilai nullable. Permintaan yang gagal atau terputus menyimpan buktinya dan berhenti.

Ilustrasi normalized.json:

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

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

<a id="workflows"></a>
## Metadata dan alur kerja massal

| Data | Supadata /v1/metadata | FlashData youtube_metadata |
| --- | --- | --- |
| Identitas video | id | hasil[0].videoId |
| Judul dan deskripsi | judul, deskripsi | hasil[0].judul, hasil[0].deskripsi |
| Saluran | author.displayName; additionalData.channelId | hasil[0].saluran; hasil[0].channelId |
| Keterlibatan | stats.views, stats.likes, stats.comments | hasil[0].viewCount, likeCount, commentCount |
| Durasi | media.duration (detik) | hasil[0].durasi (detik) |
| gambar kecil | media.thumbnailUrl | hasil[0].thumbnail[]; pilih ukuran yang dibutuhkan aplikasi Anda |
| Tanggal publikasi | createdAt | hasil[0].uploadDate; normalkan formatnya di aplikasi Anda |
| Penemuan teks | Baca availableLangs dari tanggapan transkrip | hasil[0].hasTranscripts dan transcriptLanguages |

### Beberapa bahasa yang ada dalam satu permintaan

Kirim larik bahasa untuk menerima trek dan kesalahan, bahkan untuk larik yang berisi satu bahasa. Periksa kesalahan bahkan ketika statusnya done. Ini adalah trek yang sudah ada, bukan teks yang diterjemahkan atau dibuat.

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

### Memperkaya perpustakaan penelitian

Ambil metadata satu kali, simpan videonya ID dan bahasa teks yang tersedia, lalu ambil trek yang Anda perlukan. Pertahankan jumlah keterlibatan yang dapat dibatalkan sebagai null daripada mengubahnya menjadi nol.

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

### Memproses daftar video IDs

Perluas masukan Anda menjadi video eksplisit IDs, lalu gunakan Batch atau file massal. FlashData tidak menerima Supadata playlistId sebagai masukan drop-in batch. Simpan status dan keluaran per item sebelum mencoba kembali failed item.

[Referensi pemrosesan massal](https://flashdata.dev/id/docs/reference/bulk-processing/reference.md)

### Jalankan penelitian sesuai jadwal

Pertahankan kredensial pemilik, pos pemeriksaan completed video dan baca keluaran tersimpan saat restart. Berhenti karena akses dicabut atau saldo tidak mencukupi; jangan membuat uji coba lain untuk melanjutkan pekerjaan yang dijadwalkan.

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

### Production keputusan migrasi

- Selesaikan input playlist/channel ke video eksplisit IDs sebelum FlashData Pemrosesan file batch atau massal; Supadata playlistId bukan masukan drop-in.
- Pencarian Supadata dikenakan biaya satu kredit per halaman hasil 20, atau ceil(limit/20) dengan batas. FlashData standar YouTube Pencarian mendukung hingga 20 hasil; Pencarian Diperluas memiliki tarif terpisah. Filter peta dan jangan mentransfer token halaman.
- Supadata mendokumentasikan jendela hasil pekerjaan transkrip completed satu jam. Hapus pekerjaan yang ada di sana dan simpan hasilnya sebelum memigrasikan pekerjaan baru. Pisahkan pekerjaan khusus penyedia IDs.
- Pertahankan media lintas platform, ekstraksi AI, terjemahan, dan transkripsi audio pada jalur yang ada kecuali alur kerja yang setara telah diterapkan.

<a id="agents"></a>
## Uji coba agen, klaim, dan penggunaan berulang

Agen yang memenuhi syarat dapat memulai dengan 1 kredit, hingga 100 permintaan transkrip asli selama 72 jam. Metadata dan transkrip berbagi tunjangan ini.

1. Gunakan kembali akses yang ada terlebih dahulu; jika tidak, mulailah satu uji coba yang memenuhi syarat hanya dengan izin yang diperlukan.
2. Kembalikan hasil yang bermanfaat, simpan keluaran dan penggunaan mentah, serta pertahankan profil dan direktori status yang sama.
3. Pemilik masuk atau mendaftar, memverifikasi email dan menyetujui klaim, cakupan, dan akses saldo bersama.
4. Gunakan kembali kredensial pemilik untuk tugas berulang. Kredit percobaan yang tidak digunakan tidak ditransfer. Berhenti setelah pencabutan atau saldo tidak mencukupi; jangan pernah membuat uji coba lain untuk melanjutkan.

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

[Uji coba dan klaim](https://flashdata.dev/id/docs/guides/agent-onboarding/reference.md) · [Mandiri CLI](https://flashdata.dev/id/docs/guides/flashdata-cli/reference.md) · [koneksi MCP](https://flashdata.dev/id/docs/integrations/mcp-clients/reference.md)

<a id="faq"></a>
## Pertanyaan tentang migrasi

### Bisakah FlashData menggantikan transkripsi AI Supadata?

Transkrip dan sumber teks FlashData mengambil teks yang sudah ada di YouTube. Mereka tidak menyalin audio, menerjemahkan teks atau melakukan analisis visual. Pindahkan pengambilan YouTube asli ke FlashData; sediakan layanan terpisah untuk ekstraksi ucapan-ke-teks, video lintas platform, atau AI saat aplikasi Anda membutuhkannya.

### Apa yang dibeli oleh satu permintaan?

Kalkulator mencakup satu transkrip yang ada dalam satu bahasa atau satu pencarian metadata video. Mengambil keduanya menggunakan dua permintaan per video. Supadata menagih setiap operasi ini dengan satu kredit. FlashData menggunakan kecepatan data YouTube dari paket yang dipilih. Pencarian yang Diperluas, transkripsi AI, terjemahan, dan pengiriman media berada di luar perkiraan ini.

### Apakah FlashData selalu lebih murah?

Bandingkan beban kerja Anda yang sebenarnya dan rencana yang dipilih. Supadata termasuk kredit 100 setiap bulan secara Gratis. Uji coba agen sementara FlashData terbatas dan berakhir; ini bukan tingkat gratis bulanan. Pada volume rendah, tunjangan gratis dapat mencakup keseluruhan tugas. Biaya paket berbayar, paket isi ulang, dan saldo yang belum terpakai memengaruhi jumlah yang Anda bayarkan.

### Apakah Supadata sudah mendukung MCP dan SDK?

Ya. Kedua layanan mendukung integrasi MCP dan Python/JavaScript. FlashData juga menyediakan Go SDK, mandiri CLI dan uji coba agen sementara yang dapat diklaim untuk akses berulang. Pilih antarmuka yang didukung host Anda; MCP saja bukanlah alasan untuk beralih.

### Apa yang terjadi jika trek teks hilang?

Perlakukan itu sebagai kesenjangan data. FlashData tidak beralih antara teks yang disediakan pengunggah dan yang dibuat YouTube atau menyatukan transkrip. Untuk susunan bahasa, periksa kesalahan meskipun permintaannya adalah done. Supadata dapat menghasilkan transkrip dalam mode otomatis, sedangkan mode asli dapat mengembalikan HTTP 206 untuk transkrip yang tidak tersedia; dokumentasinya menagih yang ditanggapi dengan satu kredit.

### Bisakah saya mempertahankan bentuk respons aplikasi yang ada?

Simpan adaptor Anda sendiri. Contoh ini mengonversi FlashData segmen menjadi entri konten dengan offset dan durasi dalam milidetik, namun tidak mengklaim respons lengkap yang kompatibel dengan Supadata. Baca metadata FlashData jika Anda memerlukan bahasa yang tersedia, dan migrasikan status pekerjaan, penanganan kesalahan dan penggunaan secara eksplisit.

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