# Oxylabs Alternatif untuk YouTube Data | FlashData

Bandingkan FlashData dan Oxylabs untuk YouTube metadata dan keterangan: unit penagihan, biaya berlangganan, akses agen, dan Python/Bash migrasi dari Klasik atau Web API.

Riset video tanpa komitmen bulanan. Pindahkan tugas metadata dan teks ke FlashData PAYG sambil mempertahankan bahasa, asal, dan stempel waktu.

Halaman ini mencakup YouTube Data. [Oxylabs Alternatif SERP](https://flashdata.dev/id/compare/oxylabs/reference.md) mencakup Google Cari secara terpisah.

Oxylabs fakta ditinjau 2026-11-10; FlashData harga dan tunjangan menggunakan katalog publik saat ini.

- [Fitur](#features)
- [Harga](#pricing)
- [Migrasi](#migration)
- [Production & agen](#production)
- [Pertanyaan](#faq)

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

### Flexible pengeluaran untuk penelitian video

| Fitur | FlashData | Oxylabs YouTube |
| --- | --- | --- |
| Penggunaan berbayar tanpa berlangganan bulanan | Ya — PAYG; isi ulang pulsa mulai dari $10 | Tidak — Layanan mandiri berbayar saat ini memerlukan langganan aktif |
| Pencarian hanya metadata · 1,000 video | $0.50 — 1,000 permintaan sumber standar · PAYG | Konfirmasikan tingkat titik akhir — Harga data Video Publik API adalah per GB, bukan penawaran permintaan metadata |
| Pencarian hanya teks · 1,000 video | $0.50 — Satu trek yang ada dipilih per video · PAYG | Titik akhir subtitle khusus — Konfirmasikan unit penagihannya di akun Anda |
| Berbagi Google Pencarian dan YouTube saldo | Ya | Ya — Saldo kredit produk bersama |

### Temukan video dan segarkan metadatanya

| Fitur | FlashData | Oxylabs YouTube |
| --- | --- | --- |
| Penemuan kata kunci dan saran pencarian | Ya — Sumber Pencarian, Pencarian Diperluas, dan Saran | Ya — YouTube pencarian, pencarian/max dan titik akhir pelengkapan otomatis |
| Metadata untuk video yang dikenal ID | Ya — Judul, saluran, durasi, gambar mini, dan jumlah keterlibatan | Ya — Titik akhir metadata khusus menerima video ID |
| Bab dan bahasa teks yang tersedia | Ya — Bab opsional ditambah transcriptLanguages | Ya — Penanda bab dan bahasa subtitle dalam metadata |

### Kontrol bukti teks mana yang mencapai aplikasi Anda

| Fitur | FlashData | Oxylabs YouTube |
| --- | --- | --- |
| Ambil teks secara terpisah dari metadata | Ya — Sumber transkrip dan teks khusus | Ya — Titik akhir subtitel YouTube khusus |
| Pilih bahasa teks dan asal | Ya — Bahasa eksplisit dan pemilihan otomatis | Ya — language_code dan subtitle_origin |
| Beberapa bahasa dalam satu permintaan | Hingga 10 bahasa yang dipilih — Array bahasa eksplisit mengembalikan trek ditambah kesalahan | Satu bahasa yang dipilih atau semuanya — Hilangkan language_code untuk semua bahasa; hilangkan subtitle_origin untuk kedua asal |
| Teks dan waktu untuk kutipan sumber | Segmen yang dinormalisasi + fullText — JSON mulai/end kali dalam hitungan detik | YouTube muatan lagu subtitle — Teks dan pengaturan waktu dikelompokkan berdasarkan bahasa dan asal |
| Trek yang diminta tidak tersedia | Kesalahan per bahasa dalam permintaan array — Pertahankan jalur yang sukses; periksa kesalahan bahkan ketika statusnya done | Hasil kosong untuk trek yang hilang — Kode bahasa yang valid tanpa kecocokan akan mengembalikan {} |
| Siapkan data untuk aplikasi atau LLM | JSON, teks biasa atau Markdown — Pilih respons API dan format konten | Lacak data atau ekstraksi JSON khusus — Ekstraksi subtitle menerima prompt atau skema |

### Memproses daftar dan menjaga akses agen dapat digunakan kembali

| Fitur | FlashData | Oxylabs YouTube |
| --- | --- | --- |
| Mode interaktif, async dan batch | Ya — Bentuk permintaan sumber yang sama di seluruh mode eksekusi | Ya — Metadata dan subtitle web API mendukung sinkronisasi, async dan batch |
| Kirimkan daftar video yang sudah disiapkan | ID berkas di Bulk Jobs — Konsol atau API; memantau kemajuan dan mengambil bagian hasil | ID susunan dalam Batch API — Parameter bersama berlaku untuk setiap pekerjaan di batch |
| Simpan banyak koleksi ke penyimpanan Anda | Manifes massal dan bagian hasil — Penyimpanan terkelola atau pelanggan untuk keluaran massal | Pengiriman penyimpanan asinkron — S3, S3 penyimpanan yang kompatibel, GCS dan TOS |
| Uji coba agen sebelum penyiapan akun pemilik | Ya — Agen yang memenuhi syarat: hingga 100 permintaan standar, lalu pemilik mengklaim | Daftarkan akun terlebih dahulu — $5 kredit sambutan satu kali per tim |
| Mandiri CLI tanpa Node.js atau Python | Ya — Linux, macOS dan Windows | HTTP API, MCP dan keterampilan — Tidak ada biner mandiri yang setara yang diverifikasi dalam dokumen pengaturan yang telah ditinjau |
| MCP dan keterampilan untuk agen host | Ya — Gunakan kembali akses pemilik yang disetujui untuk tugas yang sedang berlangsung | Ya — Keterampilan server dan agen web API MCP |

### Jaga agar penelitian sesekali tetap terjangkau

FlashData bayar sesuai pemakaian tidak dikenakan biaya bulanan. Ambil video yang dibutuhkan tugas Anda dan simpan satu saldo untuk Google Pencarian dan YouTube.

### Anggaran dalam permintaan sumber

Hitung pengambilan metadata dan teks secara terpisah. Penyegaran metadata tidak memerlukan permintaan teks lainnya; trek teks yang disimpan dapat menyajikan analisis nanti.

### Simpan buktinya, bukan hanya ringkasannya

Simpan teks keterangan beserta bahasa, asal, dan stempel waktunya. Contoh migrasi membuat tautan sumber untuk setiap segmen dan mempertahankan respons dan penggunaan mentah.

<a id="pricing"></a>
## Bandingkan paket dan unit penagihan

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

FlashData menghitung satu pencarian metadata ditambah satu pencarian teks sebagai dua permintaan per video. Hitungan yang disertakan mengalokasikan seluruh saldo bersama ke data standar YouTube; Pencarian dan Pengunduhan yang Diperluas menggunakan tarif terpisah. PAYG isi ulang dimulai dari $10. [Harga penuh](https://flashdata.dev/id/pricing/youtube-data).

| Oxylabs rencana | Biaya bulanan | Termasuk saldo bersama | Kecepatan data Video yang Diterbitkan API | Termasuk permintaan metadata/caption |
| --- | --- | --- | --- | --- |
| Starter | $15.00 | $15.00 | $2.00/GB | Tidak ada jumlah tetap yang dipublikasikan |
| Basic | $100.00 | $100.00 | $2.00/GB | Tidak ada jumlah tetap yang dipublikasikan |
| Flexible | $500.00 | $500.00 | $1.60/GB | Tidak ada jumlah tetap yang dipublikasikan |

Perusahaan dimulai pada $2,500/bulan dengan ketentuan yang disesuaikan. USD; pajak, penggunaan produk lainnya, dan kontrak khusus tidak termasuk.

Oxylabs mencantumkan data Video API dalam GB. Tabel publiknya tidak menetapkan harga per permintaan untuk titik akhir metadata dan subtitel. Gunakan unit penagihan akun Anda dan tarif untuk panggilan tersebut; harga umum Scrape 'dari' bukanlah penawaran YouTube. Tunjangan GB tidak dapat dikonversi menjadi jumlah video yang tetap.

Oxylabs layanan mandiri berbayar menggunakan langganan aktif dan saldo kredit bulanan bersama. Saldo yang tidak terpakai akan habis masa berlakunya saat perpanjangan; layanan berhenti di titik nol hingga dilakukan pengisian ulang atau peningkatan. Kredit selamat datang $5 adalah tunjangan tim satu kali, bukan kuota bulanan. Kontrak Klasik atau kontrak khusus yang ada mungkin memiliki ketentuan berbeda.

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

<a id="migration"></a>
## Migrasikan satu track teks yang ada

### 1. Identifikasi permintaan yang ada

Ini adalah permintaan referensi untuk lagu berbahasa Inggris yang sama yang dibuat oleh YouTube. Keduanya menggunakan video ID, bukan URL. Klasik menggunakan entri konteks; Web API menggunakan opsi tingkat atas.

```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. Siapkan FlashData dan simpan file

Buat atau gunakan kembali kunci dengan izin youtube_captions. [API Kunci](https://flashdata.dev/app/api-keys) · [Kredit yang tersedia](https://flashdata.dev/app/billing). Baca FLASHDATA_API_KEY dari penyimpanan rahasia atau gunakan perintah tersembunyi skrip. Jauhkan kredensial dari obrolan dan kontrol sumber.

Buat youtube-migration/ dan simpan ini sebagai youtube-migration/request.json:

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

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

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

```

Dari dalam youtube-migration/, jalankan:

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

Alternatifnya, gunakan Bash, cURL 7.76+ dan jq 1.6+. Simpan skrip lengkap sebagai 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

```

Dari dalam youtube-migration/, jalankan:

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

Folder baru mengirimkan satu permintaan. Ulangi perintah yang sama untuk membaca respons tersimpannya tanpa panggilan API. Setiap folder memiliki permintaannya sendiri; mengubah request.json tidak mengubah proses yang sudah ada. Selesaikan upaya yang tidak lengkap sebelum membuat folder lain.

### 3. Periksa treknya sebelum mengutipnya

track-001/captions.json berisi segmen yang diperiksa dengan link sumber; record.json menyimpan permintaan, waktu dan penggunaan; result.json adalah respon mentah. Skrip memverifikasi video, bahasa dan asal, menerima sebuah judul otomatis yang cocok -orig varian, dan mempertahankan segmen tumpang tindih. Waktu segmen adalah detik. Hilang atau kosong takarir adalah kesenjangan data, bukan sebuah transkrip yang dihasilkan.

Kutipan ilustratif 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"
    }
  ]
}
```

| Kekhawatiran | Integrasi Oxylabs yang ada | FlashData perubahan |
| --- | --- | --- |
| Otentikasi | Klasik: HTTP Basic nama pengguna/password. Web API: Kunci pembawa API. | X-API-Key: FLASHDATA_API_KEY. Kredensial Oxylabs yang ada tidak ditransfer. |
| Metadata | Klasik youtube_metadata; Permintaan web API /media/youtube/metadata. adalah video ID. | sumber: youtube_metadata, video_id: karakter 11 yang sama ID. |
| Keterangan | Klasik youtube_subtitles; Web API /media/youtube/subtitles. | sumber: youtube_captions untuk teks dan pengaturan waktu; youtube_transcript ketika parser Anda juga membutuhkan fullText. |
| Bahasa dan asal | Entri konteks klasik; Web API language_code dan subtitle_origin. Menghilangkannya dapat menghasilkan beberapa track. | Tetapkan params.language dan params.auto secara eksplisit. otomatis: true = YouTube dihasilkan; false = disediakan oleh pengunggah. Jangan pernah mengganti trek secara diam-diam. |
| Pengurai respons | Klasik dan Web API memiliki sampul hasil dan keluaran subtitel yang dikelompokkan berbeda. | Periksa status: done, lalu hasil[].videoId, languageCode, isAutoGenerated dan segmen. Awal segmen/end adalah detik. |
| Asinkron IDs | Web API metadata.request_id; Pekerjaan klasik IDs menggunakan titik akhir hasil mereka sendiri. | Simpan tanda terima penyerahan FlashData dan gunakan titik akhir tugas manajemennya. Pisahkan penyedia IDs; jangan menggunakan kembali Oxylabs polling URL. |

### Tugas metadata opsional

Berikan izin youtube_metadata. POST tubuh ini menjadi https://data.flashdata.dev/v1/queries/realtime dengan X-API-Key. Ini adalah permintaan standar yang terpisah. Periksa status: done sebelum membaca hasil[0].

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

[Bidang keterangan](https://flashdata.dev/id/docs/sources/youtube_captions/reference.md) · [Bidang metadata](https://flashdata.dev/id/docs/sources/youtube_metadata/reference.md).

<a id="production"></a>
## Tugas berulang dan pemulihan

Kumpulkan sekali, analisis berkali-kali. Gunakan kembali jalur yang disimpan untuk ringkasan dan penyematan; menyegarkan data sumber hanya ketika tugas memerlukannya.

| Situasi | Apa yang harus dilakukan |
| --- | --- |
| Trek yang dipilih tidak ada | Oxylabs dapat mengembalikan objek kosong untuk bahasa yang valid tanpa subtitle yang cocok. Perlakukan teks teks yang hilang atau kosong sebagai kesenjangan data; jangan membuat transkrip. |
| batch yang besar diterima sebagian | Oxylabs Web API mendokumentasikan hingga 5,000 pekerjaan per batch dan memisahkan entri yang diterima/rejected. Tetap diterima IDs. Untuk FlashData, gabungkan ke maxBatchSize akun dan simpan setiap pekerjaan yang dikembalikan ID. |
| Waktu panggilan realtime habis | Simpan folder permintaan dan periksa Riwayat sebelum pengiriman lainnya. Untuk antrian panjang running, gunakan penyerahan async, segera simpan tanda terimanya dan lakukan polling pada pekerjaan yang ada. |
| Perubahan akun atau kredensial | Simpan kunci API di penyimpanan rahasia host. Berhenti di 401/403; selesaikan saldo pada 402; kehormatan Retry-After pada 429. Jangan memulai uji coba baru untuk melewati saldo yang habis. |

| 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. Untuk kumpulan data berukuran file, gunakan pemrosesan massal. [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) · [Titik akhir massal](https://flashdata.dev/id/docs/reference/bulk-processing/reference.md) · [Kesalahan](https://flashdata.dev/id/docs/errors/reference.md).

Agen ellivible dapat mulai dengan 1 kredit (terserah 100 permintaan standar) untuk 72 Jam.

Gunakan kembali akses yang ada terlebih dahulu. Untuk penggunaan berulang, pemilik mengklaim koneksi dan menyetujui izin dan akses saldo bersama. Kredit sementara yang tidak digunakan tidak dapat ditransfer. Pertahankan kredensial di antara proses berjalan dan berhenti saat pencabutan atau saldo terkuras.

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

[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 FlashData merupakan pengganti drop-in?

Tidak. Ubah autentikasi, bidang permintaan, penguraian respons, dan pengambilan pekerjaan. Contoh-contoh ini mengadaptasi satu tugas teks ke dalam catatan aplikasi yang stabil; mereka tidak meniru amplop tanggapan Oxylabs.

### Bisakah saya mempertahankan integrasi Klasik Oxylabs saat bermigrasi?

Ya. Pindahkan tugas satu per satu, pertahankan hasil Klasik yang disimpan dan pisahkan kredensial dan pekerjaan IDs berdasarkan penyedia. Pemetaan mencakup permintaan sumber/context Klasik dan permintaan titik akhir Web API yang lebih baru.

### Apakah FlashData menghasilkan transkrip ketika teksnya hilang?

Sumber-sumber ini mengambil keterangan YouTube yang ada. otomatis: true memilih subtitle yang dihasilkan YouTube; itu tidak meminta ucapan-ke-teks yang segar. Laporkan trek yang hilang, atau tangani transkripsi sebagai alur kerja terpisah.

### Bagaimana dengan mengunduh video sebenarnya?

YouTube Unduhan adalah produk FlashData terpisah dengan izinnya sendiri dan harga berbasis byte. Perbandingan ini dan contohnya mencakup metadata dan keterangan; mereka tidak mengunduh file video atau audio.

### Apa yang harus tetap ada dalam alur kerja Oxylabs saya yang sudah ada?

Pertahankan infrastruktur proxy, platform sosial lainnya, dan kontrak ekstraksi khusus, callback, atau pengiriman penyimpanan apa pun yang masih diperlukan aplikasi Anda. Kedua penyedia mendukung async pekerjaan, batch pengumpulan, MCP dan keterampilan; kemampuan tersebut saja bukan alasan untuk bermigrasi.

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