# Bright Data Alternatif untuk YouTube Data

Bandingkan permintaan FlashData YouTube dengan Bright Data catatan scraper: tarif yang dibayar, tunjangan bulanan, batasan pekerjaan, dan migrasi Python/Bash dari snapshot ke pekerjaan yang disimpan.

Bangun penelitian video seputar permintaan sumber. Bandingkan seluruh tugas, lalu pindahkan alur kerja snapshot ke pekerjaan yang disimpan dan dapat dilanjutkan.

Ini adalah perbandingan YouTube. [Bright Data Alternatif untuk Google Pencarian](https://flashdata.dev/id/compare/brightdata/reference.md) adalah halaman terpisah.

Bright Data fakta meninjau 2026-11-10. FlashData tarif dan tunjangan menggunakan katalog publik saat ini.

- [Fitur](#features)
- [Harga](#pricing)
- [Kuota & batasan](#limits)
- [Migrasikan pekerjaan](#migration)
- [Alur kerja agen](#agents)
- [Pertanyaan Umum](#faq)

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

### Menurunkan biaya berbayar untuk pencarian video terfokus

| Fitur | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Pencarian metadata berbayar · 1,000 video | $0.50 — 1,000 permintaan sumber · PAYG | $1.50 — 1,000 mengirimkan rekaman video · PAYG |
| Metadata + keterangan yang ada · 1,000 video | $1.00 — 2,000 permintaan sumber · PAYG | $1.50 — 1,000 rekaman video saat kolom teks disertakan |
| Paket masuk bulanan | $49.00 — Micro/bulan; saldo penggunaan bersama termasuk | $499 — Scale/bulan · 384,000 catatan termasuk |
| Bayar sesuai pemakaian tanpa berlangganan bulanan | Ya | Ya |

### Temukan video dan bangun perpustakaan penelitian

| Fitur | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Temukan video berdasarkan kata kunci | Ya — Cari dengan filter tanggal, durasi, jenis dan pengurutan | Ya — Mode penemuan kata kunci dan filter pencarian |
| Metadata untuk video yang dikenal | Ya — Judul, saluran, durasi, gambar mini, dan jumlah keterlibatan | Ya — Rekaman video dengan bidang identitas, saluran, dan keterlibatan |
| Penanda bab untuk navigasi | Ya — include_chapters; kali bab dalam hitungan detik | Ya — Judul bab, pratinjau, dan waktu mulai dalam milidetik |
| Temukan bahasa teks yang tersedia | Daftar bahasa dalam metadata | Daftar lagu dalam rekaman video — Termasuk informasi bahasa dan teks otomatis |

### Jadikan keterangan dapat digunakan sebagai bukti

| Fitur | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Minta teks tanpa menyegarkan metadata | Sumber transkrip khusus — Satu permintaan standar per video | Bidang keterangan dalam rekaman video — YouTube Pengikis video |
| Minta beberapa bahasa teks | Hingga 10 bahasa eksplisit — Trek ditambah kesalahan per bahasa | Satu bahasa yang dipilih — Pilih bahasa saat mengumpulkan rekaman video |
| Pilih pengunggah atau asal teks otomatis | Ya — params.auto memilih satu asal tanpa fallback lintas asal | Asal ditampilkan dalam metadata trek — Tidak ada masukan pilihan asal yang tercantum untuk pengikis Video yang ditinjau |
| Kutipan teks lengkap dan stempel waktu | Teks lengkap + segmen berwaktu — Start/end kali dalam detik | Teks lengkap + segmen berwaktu — Segmentasikan awal, akhir, dan durasi dalam milidetik |

### Jalankan pengumpulan di aplikasi atau agen Anda

| Fitur | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Koleksi interaktif dan latar belakang | Waktu nyata atau async — Pilih modenya; simpan pekerjaan ID untuk pekerjaan latar belakang | Pengikisan sinkronisasi atau pemicu async — Pekerjaan sinkronisasi yang melebihi satu menit berlanjut sebagai snapshot |
| Proses daftar besar yang sudah disiapkan | Bulk Jobs dengan file video-ID — Konsol atau API; bagian kemajuan, manifes dan hasil | Kumpulan masukan asinkron — Memicu koleksi dan mengambil atau mengirimkan cuplikannya |
| Output untuk aplikasi dan LLM | JSON, teks biasa atau Markdown | Format ekspor cuplikan — JSON, NDJSON dan CSV |
| Simpan hasil completed untuk analisis nanti | Simpan hasil atau gunakan penyimpanan massal — Simpan data mentah dan manifes di penyimpanan Anda sendiri | Snapshot dan pengiriman penyimpanan — Snapshot disimpan selama 30 hari |
| Klien terminal mandiri | Asli CLI — Linux, macOS dan Windows; tidak ada waktu proses Node/Python | Node.js CLI — perintah bdata yang diinstal npm |
| MCP, keterampilan dan SDK akses | Ya | Ya |

Tarif berbayar tidak termasuk tunjangan gratis. Keduanya menawarkan async pekerjaan, pengumpulan massal, dan alat agen. Pertahankan pengumpulan komentar, platform sosial lainnya, kumpulan data terkelola, dan integrasi penyimpanan-pengiriman yang ada jika diperlukan.

### Bayar untuk bidang yang dibutuhkan tugas Anda

Ambil metadata untuk daftar pilihan Anda. Minta teks hanya untuk video yang akan Anda analisis. Penyegaran metadata tidak perlu mengulangi langkah transkrip.

### Pilih trek teks secara eksplisit

Minta bahasa dan pilih teks yang disediakan pengunggah atau teks yang dibuat oleh YouTube. Jaga agar kesalahan bahasa tetap terlihat daripada mengubah masukan penelitian secara diam-diam.

### Pertahankan pekerjaan di seluruh sesi agen

Simpan pekerjaan yang diterima ID sebelum pemungutan suara. Proses selanjutnya melanjutkan pekerjaan yang sama dan menggunakan kembali hasil yang diunduh tanpa mengirimkan kueri lain.

<a id="pricing"></a>
## Bandingkan tugas video lengkap

Rekaman video Bright Data dapat menyertakan metadata dan teks. FlashData menggunakan satu permintaan metadata dan permintaan teks terpisah. Satu masukan penemuan dapat menghasilkan banyak catatan yang dapat ditagih; kalkulator ini hanya mencakup pencarian video yang diketahui.

| Penawaran Bright Data YouTube | Biaya bulanan | Termasuk catatan | Tarif berbayar / catatan 1,000 |
| --- | --- | --- | --- |
| Kolam renang gratis yang memenuhi syarat | $0 | Hingga 5,000/bulan dibagikan ke seluruh produk yang memenuhi syarat | Sesuai tunjangan |
| Bayar sesuai penggunaan | $0.00 | Tidak ada tunjangan rencana berbayar | $1.50 |
| Scale · $499/month | $499.00 | 384,000 | $1.30 additional |
| Perusahaan | Adat | Adat | Adat |

Scale mencakup 384,000 catatan untuk $499/bulan; catatan tambahan biaya $1.30 per 1,000. Perusahaan Kustom dan pencocokan setoran promosi tidak dimodelkan.

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

Jumlah permintaan yang disertakan mengalokasikan seluruh saldo paket bersama ke Data standar YouTube. Pencarian dan Pengunduhan yang Diperluas memiliki tarif terpisah. [Harga penuh](https://flashdata.dev/id/pricing/youtube-data).

### 10,000 video: bayar sesuai perjalanan di kedua sisi

| Tugas | FlashData permintaan | FlashData tagihan model | Bright Data catatan gratis diterapkan | Bright Data tagihan model |
| --- | --- | --- | --- | --- |
| Metadata video | 10,000 | $5.00 | 0 | $15.00 |
| Metadata video | 10,000 | $5.00 | 5,000 | $7.50 |
| Metadata + keterangan yang ada | 20,000 | $10.00 | 0 | $15.00 |
| Metadata + keterangan yang ada | 20,000 | $10.00 | 5,000 | $7.50 |

USD selama satu bulan pencarian video berhasil. Satu rekaman video Bright Data yang dikembalikan dapat berisi metadata dan keterangan yang ada; tugas gabungan FlashData menggunakan dua permintaan sumber. Penemuan, komentar, transkripsi AI, Pencarian Diperluas, dan pengunduhan media tidak termasuk. Masukkan hanya Bright Data kredit gratis yang masih tersedia untuk catatan ini; kumpulan kredit 5,000 dibagikan, dan kredit gratis berulang tidak ditumpuk dengan Scale. FlashData harga berasal dari katalog publik terkini; seluruh saldo paket yang dipilih dialokasikan di sini sebelum penggunaan tambahan. FlashData saldo awal dan pendaftaran/agent uji coba tidak termasuk. Tagihan yang dimodelkan mengukur penggunaan ditambah biaya bulanan apa pun, bukan pembelian dompet baru: FlashData isi ulang dimulai dari $10. Tidak termasuk pajak, promosi pencocokan setoran, tarif khusus, atau diskon tahunan.

### Memulai penawaran

Diterifikasi oleh FlashData tanda tangan dapat menerima tunjangan awal hingga permintaan Data 4,000 standar YouTube. Ini adalah saldo awal, bukan kuota bulanan berulang.

Akun Bright Data yang memenuhi syarat menerima 5,000 kredit gratis per bulan yang dibagikan ke seluruh produk yang memenuhi syarat, termasuk Scraper API. Satu rekaman YouTube yang dikirimkan menghabiskan satu kredit. Kredit gratis yang tidak digunakan tidak dapat diperpanjang; akun pra-komitmen tidak menerima kredit gratis berulang. Jangan menumpuk kumpulan gratis bulanan dengan Scale.

<a id="limits"></a>
## Tunjangan, batch ukuran dan running pekerjaan

| Kekhawatiran | FlashData | Bright Data Pengikis API |
| --- | --- | --- |
| Apa yang menghabiskan tunjangan tersebut? | Setiap permintaan sumber; metadata dan keterangan terpisah | Catatan berhasil dikirimkan; satu masukan penemuan dapat menghasilkan banyak masukan |
| Satu permintaan interaktif | POST /v1/queries/realtime; pilih async untuk pekerjaan latar belakang | POST /datasets/v3/scrape; setelah 1 menit, HTTP 202 mengembalikan snapshot ID dan pekerjaan dilanjutkan |
| Masukan yang lebih besar | Ukuran batch tergantung pada paket; gunakan pemrosesan Massal untuk file IDs | Async /trigger menerima input hingga 1 GB; jumlah input minimum tergantung pada scraper |
| Menjalankan pekerjaan | Konkurensi akun bergantung pada paket yang dipilih, seperti yang ditunjukkan di bawah ini | 5,000 pekerjaan aktif/snapshots; melebihi batas pengembalian 429 |
| Mundur | Kehormatan Retry-After; uji coba agen sementara mengizinkan satu permintaan per detik | Kehormatan Retry-After; 25 HTTP 429 tanggapan per IP dalam 5 menit dapat memicu blok 1-jam API |
| Hasil yang disimpan | Unduh dan simpan JSON di penyimpanan tugas Anda sendiri | Snapshot disimpan selama 30 hari; permintaan unduhan mendukung hingga 5 GB, dengan pengambilan berbasis bagian untuk hasil yang lebih besar |

| FlashData rencana | Kueri serentak | Kueri per permintaan Batch |
| --- | --- | --- |
| Bayar sesuai penggunaan | 25 | 100 |
| Micro | 50 | 100 |
| Starter | 100 | 200 |
| Pro | 200 | 300 |
| Scale | 300 | 400 |
| Business | 400 | 500 |

Konkurensi bukanlah permintaan per detik. Kredit masih berlaku untuk setiap kueri. [Waktu nyata dan async](https://flashdata.dev/id/docs/reference/realtime-and-async/reference.md) · [Batch dan massal](https://flashdata.dev/id/docs/reference/batch-and-bulk/reference.md) · [Referensi pemrosesan massal](https://flashdata.dev/id/docs/reference/bulk-processing/reference.md).

<a id="migration"></a>
## Dari snapshot hingga pekerjaan yang disimpan

### 1. Siapkan akses dan petakan permintaan

Buat atau gunakan kembali kunci dengan izin youtube_metadata. [API Kunci](https://flashdata.dev/app/api-keys) · [Kredit yang tersedia](https://flashdata.dev/app/billing). Simpan FLASHDATA_API_KEY di penyimpanan rahasia atau masukkan di prompt tersembunyi skrip.

Pengiriman Bright Data yang ada, untuk referensi migrasi:

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

FlashData POST https://data.flashdata.dev/v1/queries dengan X-API-Key:

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

### 2. Simpan skrip sebelum running itu

Memerlukan Python 3.10+. Instal dependensi dengan python -m pip install requests. Di folder kerja baru, simpan skrip lengkap di bawah sebagai migrate-video.py sebelum menjalankannya.

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

import requests

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

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

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

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

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

```

Jalankan dari folder yang sama:

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

Alternatifnya, gunakan Bash, cURL 7.76+ dan jq 1.6+. Simpan skrip lengkap di bawah ini sebagai migrate-video.sh di folder kerja baru.

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

```

Jalankan dari folder yang sama:

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

Jika masih running, ulangi perintah yang sama untuk melanjutkan pekerjaan yang disimpan. Proses yang selesai menggunakan kembali result.json tanpa panggilan API. Folder baru mengirimkan permintaan baru; periksa Riwayat sebelum mencoba kembali pengiriman yang tidak pasti. Jauhkan kunci dari obrolan dan jangan pernah meneruskannya ke penyimpanan bertanda tangan URLs.

### 3. Baca catatan yang dipetakan

video001/video-records.json mempertahankan nama ruas video umum; result.json mempertahankan data mentah dan penggunaan. Metrik hilang tetap null. channelName adalah nama tampilan, bukan penanganan; uploadDateRaw bukan tanggal normalisasi. bidang transkrip dan media tidak dibuat.

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

| Kekhawatiran | Integrasi yang ada | FlashData perubahan |
| --- | --- | --- |
| Pilihan pengikis | dataset_id=gd_lk56epmy2i5g7lzu0k | sumber=youtube_metadata; keterangan gunakan youtube_transcript secara terpisah |
| Masukan | Jam tangan URL dalam larik masukan | Sebuah 11-karakter video_id |
| Otentikasi | Otorisasi: Pembawa | X-API-Key dengan izin sumber yang diminta |
| Kirim | POST /datasets/v3/trigger → snapshot_id | POST /v1/queries → nomor identitas; simpan tanda terimanya |
| Lacak | Kemajuan cuplikan → ready | GET /v2/jobs/{id} → job.status=completed |
| Ambil | Unduh cuplikan sebagai JSON, NDJSON atau CSV | GET /v2/jobs/{id}/results → penyimpanan bertanda tangan URL; ambil tanpa kunci API |
| Bidang video | video_id, title, description, views, likes, num_comments, video_length | videoId, judul, deskripsi, viewCount, likeCount, commentCount, durasi (detik) |
| Saluran dan tanggal | youtuber adalah pegangan; date_posted adalah tanggal | Pertahankan channelName, channelId dan uploadDateRaw; jangan mengganti nama tampilan menjadi pegangan |
| Transkrip | Dapat disertakan sebagai transkrip dan formatted_transcript dalam rekaman video | Permintaan trek terpisah; fullText dan segmen menggunakan detik. Petakan stempel waktu jika parser yang ada mengharapkan milidetik |
| Media langsung URL | video_url adalah streaming URL | Gunakan alur kerja YouTube Unduh terpisah untuk pengiriman ke penyimpanan Anda |

### Keterangan opsional

Berikan izin youtube_transcript. Kirimkan badan ini ke POST https://data.flashdata.dev/v1/queries dengan X-API-Key dan simpan pekerjaannya sendiri ID. Ini menambahkan satu permintaan standar per video:

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

auto=false memilih teks yang disediakan pengunggah. Pertahankan bahasa dan asal usulnya. Bright Data waktu transkrip yang diformat menggunakan milidetik; FlashData segmen menggunakan detik. Kalikan dengan 1,000 untuk parser yang mengharapkan milidetik. [Resep teks dengan stempel waktu yang dapat dijalankan](https://flashdata.dev/id/docs/guides/timestamped-captions-recipe/reference.md).

### Pemulihan

- Ditunda/processing: lanjutkan yang disimpan ID. Polling dibatasi dan kehormatan numerik Retry-After.
- 401/403: tuntaskan otentikasi atau izin; berhenti saat pembatalan.
- 402: pulihkan saldo pemilik yang tersedia sebelum melanjutkan.
- 429: berhenti mengirim dan hormati Retry-After; jangan secara otomatis mencoba kembali kiriman.
- Batas waktu tanpa tanda terima: periksa Riwayat sebelum membuat folder lain.

[Kesalahan dan kode status](https://flashdata.dev/id/docs/errors/reference.md).

<a id="agents"></a>
## Satu koneksi, tugas yang dapat digunakan kembali

Agen-agen elakubility dapat mulai dengan kredit 1 (hingga 100 standar YouTube Data permintaan) untuk jam 72. Reuse menyimpan akses pertama; metadata dan takarsi berbagi tunjangan.

1. Temukan video dan daftar pendek sebelum memperkaya.
2. Ambil satu video, verifikasi bidang dan pilihan teks, dan simpan keluaran mentah.
3. Minta pemilik menyelesaikan pendaftaran/sign-in dan menyetujui cakupan dan saldo bersama. Kredit sementara yang tidak digunakan tidak dapat ditransfer.
4. Simpan kredensial dan jalankan folder di seluruh tugas berulang. Gunakan kembali hasil dan hentikan pada pencabutan atau saldo terkuras.

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

[Uji coba dan klaim](https://flashdata.dev/id/docs/guides/agent-onboarding/reference.md) · [Tugas berulang](https://flashdata.dev/id/docs/guides/recurring-tasks/reference.md) · [Simpan hasil](https://flashdata.dev/id/docs/guides/save-results/reference.md).

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

### Apakah ini perbandingan pencarian Bright Data Google?

Halaman ini mencakup YouTube Scraper API. Google Pencarian menggunakan produk SERP Bright Data, dengan unit harga dan konfigurasi permintaan yang berbeda. Perbandingan pencarian Google memiliki halamannya sendiri.

### Apakah Bright Data mengenakan biaya dua kali untuk metadata dan transkrip?

Skema video YouTube mencakup bidang metadata dan teks dalam rekaman video yang dikembalikan. Jangan menghitung dua catatan secara otomatis. FlashData menggunakan metadata dan kueri transkrip terpisah; beban kerja gabungan di kalkulator menghitung dua permintaan FlashData per video. Bidang teks mungkin tidak tersedia untuk video tertentu.

### Penyedia mana yang memiliki tunjangan gratis lebih besar?

Bright Data menawarkan akun yang memenuhi syarat 5,000 kredit bersama setiap bulan. Tunjangan pendaftaran FlashData yang memenuhi syarat adalah saldo awal, dan uji coba agen sementaranya terpisah. Penawaran ini memiliki aturan perpanjangan yang berbeda. Gunakan sisa masukan rekaman bebas untuk memodelkan Bright Data PAYG secara akurat.

### Bisakah saya mengganti setiap pengikis Bright Data?

Pindahkan alur kerja metadata, pencarian, saluran, dan teks YouTube yang didukung yang Anda perlukan. Pertahankan pengumpulan komentar, platform sosial lainnya, kumpulan data terkelola, dan integrasi penyimpanan-pengiriman yang ada di mana aplikasi Anda masih bergantung padanya.

### Apakah kedua penyedia mendukung agen AI?

Ya. Keduanya menawarkan MCP, CLI dan keterampilan agen. FlashData yang berdiri sendiri CLI, izin sumber, dan keseimbangan Google/YouTube yang dibagikan berguna untuk alur kerja penelitian yang terfokus. Gunakan kembali akses tersimpan dan minta pemilik untuk menyetujui kelanjutan akses akun sebelum menjadwalkan pekerjaan berulang.

### Bisakah saya menggunakan kembali snapshot ID setelah bermigrasi?

Tidak. Simpan snapshot Bright Data dan pekerjaan baru FlashData ID sebagai pengidentifikasi terpisah. Contoh ini hanya menggunakan kembali tanda terima FlashData yang disimpan dan memeriksa apakah video yang dikembalikan cocok dengan ID yang diminta.

[Dapatkan kunci API](https://flashdata.dev/signup) · [Google Perbandingan pencarian](https://flashdata.dev/id/compare/brightdata/reference.md).
