# Oxylabs Alternatif untuk YouTube Data | FlashData

Bandingkan FlashData dan Oxylabs untuk YouTube metadata dan kapsyen: unit pengebilan, kos langganan, akses ejen dan Python/Bash pemindahan daripada Klasik atau Web API.

Penyelidikan video tanpa komitmen bulanan. Alihkan tugas metadata dan kapsyen ke FlashData PAYG sambil mengekalkan bahasa, asal dan cap masa.

Halaman ini merangkumi YouTube Data. [Oxylabs SERP Alternatif](https://flashdata.dev/ms/compare/oxylabs/reference.md) meliputi Google Cari secara berasingan.

Fakta Oxylabs ditinjau 2026-11-10; Harga dan tunjangan FlashData menggunakan katalog publiknya saat ini.

- [Ciri-ciri](#features)
- [penentuan harga](#pricing)
- [Penghijrahan](#migration)
- [Production & ejen](#production)
- [Soalan](#faq)

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

### Flexible perbelanjaan untuk penyelidikan video

| Ciri | FlashData | Oxylabs YouTube |
| --- | --- | --- |
| Penggunaan berbayar tanpa langganan bulanan | ya — PAYG; tambah nilai kredit bermula pada $10 | Tidak — Layan diri berbayar semasa memerlukan langganan aktif |
| Carian metadata sahaja · 1,000 video | $0.50 — 1,000 permintaan sumber standard · PAYG | Sahkan kadar titik akhir — Harga API data Video Awam adalah setiap GB, bukan petikan permintaan metadata |
| Carian kapsyen sahaja · 1,000 video | $0.50 — Satu lagu sedia ada yang dipilih setiap video · PAYG | Titik akhir sari kata khusus — Sahkan unit pengebilannya dalam akaun anda |
| Dikongsi Google Carian dan YouTube baki | ya | ya — Baki kredit produk kongsi |

### Cari video dan muat semula metadata mereka

| Ciri | FlashData | Oxylabs YouTube |
| --- | --- | --- |
| Penemuan kata kunci dan cadangan carian | ya — Sumber Carian, Carian Lanjutan dan Cadangan | ya — YouTube carian, carian/max dan autolengkap titik akhir |
| Metadata untuk video yang diketahui ID | ya — Tajuk, saluran, tempoh, lakaran kecil dan kiraan penglibatan | ya — Titik akhir metadata khusus menerima video ID |
| Bab dan bahasa kapsyen yang tersedia | ya — Bab pilihan tambah transcriptLanguages | ya — Penanda bab dan bahasa sari kata dalam metadata |

### Kawal bukti kapsyen yang mencapai apl anda

| Ciri | FlashData | Oxylabs YouTube |
| --- | --- | --- |
| Dapatkan kapsyen secara bebas daripada metadata | ya — Sumber transkrip dan kapsyen khusus | ya — Dedikasi YouTube sarikata titik akhir |
| Pilih bahasa kapsyen dan asal | ya — Bahasa eksplisit dan pemilihan automatik | ya — language_code dan subtitle_origin |
| Beberapa bahasa dalam satu permintaan | Sehingga 10 bahasa yang dipilih — Tatasusunan bahasa eksplisit mengembalikan runut serta ralat | Satu bahasa yang dipilih atau semua — Abaikan language_code untuk semua bahasa; tinggalkan subtitle_origin untuk kedua-dua asal usul |
| Teks dan masa untuk petikan sumber | Segmen biasa + fullText — JSON mula/end kali dalam beberapa saat | YouTube muatan lagu sari kata — Teks dan masa dikumpulkan mengikut bahasa dan asal |
| Lagu yang diminta tidak tersedia | Ralat setiap bahasa dalam permintaan tatasusunan — Kekalkan jejak yang berjaya; periksa ralat walaupun status adalah done | Keputusan kosong untuk trek yang hilang — Kod bahasa yang sah tanpa padanan mengembalikan {} |
| Sediakan data untuk aplikasi atau LLM | JSON, teks biasa atau Markdown — Pilih API respons dan format kandungan | Jejak data atau pengekstrakan JSON tersuai — Pengekstrakan sari kata menerima gesaan atau skema |

### Proses senarai dan pastikan akses ejen boleh diguna semula

| Ciri | FlashData | Oxylabs YouTube |
| --- | --- | --- |
| Mod interaktif, async dan batch | ya — Bentuk permintaan sumber yang sama merentas mod pelaksanaan | ya — Web API metadata dan sari kata menyokong penyegerakan, async dan batch |
| Hantar senarai video yang disediakan | ID fail dalam Bulk Jobs — Konsol atau API; memantau kemajuan dan mendapatkan bahagian hasil | ID array dalam Batch API — Parameter yang dikongsi digunakan untuk setiap kerja dalam batch |
| Simpan koleksi yang besar ke storan anda | Manifes pukal dan bahagian hasil — Storan terurus atau pelanggan untuk keluaran pukal | Penghantaran storan async — S3, S3-storan serasi, GCS dan TOS |
| Percubaan ejen sebelum persediaan akaun pemilik | ya — Ejen yang layak: sehingga 100 permintaan standard, kemudian pemilik menuntut | Daftar akaun dahulu — $5 kredit alu-aluan sekali bagi setiap pasukan |
| Berdiri sendiri CLI tanpa Node.js atau Python | ya — Linux, macOS dan Windows | HTTP API, MCP dan kemahiran — Tiada perduaan kendiri setara yang disahkan dalam dokumen persediaan yang disemak |
| MCP dan kemahiran untuk hos ejen | ya — Gunakan semula akses pemilik yang diluluskan untuk tugasan yang berterusan | ya — Web API MCP kemahiran pelayan dan ejen |

### Pastikan penyelidikan sekali-sekala berpatutan

FlashData bayar semasa anda pergi tiada yuran bulanan. Ambil video yang diperlukan oleh tugas anda dan simpan satu baki untuk Google Carian dan YouTube.

### Belanjawan dalam permintaan sumber

Kira metadata dan pengambilan kapsyen secara berasingan. Muat semula metadata tidak memerlukan permintaan kapsyen lain; runut kapsyen yang disimpan boleh menyampaikan analisis kemudian.

### Simpan bukti, bukan hanya ringkasan

Simpan teks kapsyen dengan bahasa, asal dan cap masanya. Contoh migrasi mencipta pautan sumber untuk setiap segmen dan mengekalkan tindak balas dan penggunaan mentah.

<a id="pricing"></a>
## Bandingkan pelan dan unit pengebilan

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

FlashData mengira satu carian metadata ditambah satu carian kapsyen sebagai dua permintaan setiap video. Kiraan yang disertakan memperuntukkan baki penuh yang dikongsi kepada standard YouTube Data; Carian dan Muat Turun Lanjutan menggunakan kadar yang berasingan. PAYG tambah nilai bermula pada $10. [Harga penuh](https://flashdata.dev/ms/pricing/youtube-data).

| Oxylabs pelan | Yuran bulanan | Termasuk baki bersama | Kadar API data Video yang diterbitkan | Termasuk permintaan metadata/caption |
| --- | --- | --- | --- | --- |
| Starter | $15.00 | $15.00 | $2.00/GB | Tiada kiraan tetap diterbitkan |
| Basic | $100.00 | $100.00 | $2.00/GB | Tiada kiraan tetap diterbitkan |
| Flexible | $500.00 | $500.00 | $1.60/GB | Tiada kiraan tetap diterbitkan |

Perusahaan bermula pada $2,500/bulan dengan syarat yang disesuaikan. USD; cukai, penggunaan produk lain dan kontrak tersuai dikecualikan.

Oxylabs menyenaraikan data Video API dalam GB. Jadual awamnya tidak menetapkan harga setiap permintaan untuk titik akhir metadata dan sari kata. Gunakan unit pengebilan akaun anda dan kadar untuk panggilan tersebut; harga 'dari' Scrape generik bukan sebut harga YouTube. Elaun GB tidak boleh ditukar kepada bilangan video tetap.

Oxylabs layan diri berbayar menggunakan langganan aktif dan baki kredit bulanan dikongsi. Baki yang tidak digunakan akan luput semasa pembaharuan; perkhidmatan dijeda pada sifar sehingga tambah nilai atau naik taraf. Kredit $5 adalah elaun pasukan sekali sahaja, bukan kuota bulanan. Kontrak Klasik atau kontrak tersuai sedia ada mungkin mempunyai syarat yang berbeza.

Signup FlashData yang dapat diverifikasi secara tidak sengaja dapat menerima tunjangan awal hingga permintaan Data 4,000 standar YouTube. Ini adalah saldo awal, bukan kuota bulanan.

<a id="migration"></a>
## Pindahkan satu runut kapsyen sedia ada

### 1. Kenal pasti permintaan sedia ada

Ini adalah permintaan rujukan untuk lagu Inggeris yang sama, YouTube-dijana. Kedua-duanya menggunakan video ID, bukan URL. Klasik menggunakan entri konteks; Web API menggunakan pilihan peringkat teratas.

```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. Sediakan FlashData dan simpan fail

Cipta atau gunakan semula kunci dengan kebenaran youtube_captions. [API Kunci](https://flashdata.dev/app/api-keys) · [Kredit yang ada](https://flashdata.dev/app/billing). Baca FLASHDATA_API_KEY dari kedai rahsia atau gunakan gesaan tersembunyi skrip. Jauhkan bukti kelayakan daripada sembang dan kawalan 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+. Pasang kebergantungan dengan python -m pip install requests. Dalam folder kerja baharu, 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
```

Sebagai alternatif, 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 baharu menyerahkan satu permintaan. Ulangi arahan yang sama untuk membaca respons yang disimpan tanpa panggilan API. Setiap folder memiliki permintaannya; menukar request.json tidak mengubah larian sedia ada. Selesaikan percubaan yang tidak lengkap sebelum membuat folder lain.

### 3. Semak trek sebelum memetiknya

Trek Perancis-001/captions.json planed berisi segmen yang dicontreng dengan sumber link; record.json Dia menyimpan permintaan, waktu dan penggunaannya; result.json Dia adalah respon mentah. Naskah ini memverifikasi video, bahasa dan asal, menerima varian auto-caption -orig yang cocok, dan menjaga segmen yang saling tumpang tindih. Saat-saat segmen adalah detik. Hilang atau kosong kapsi adalah celah data, bukan transkrip yang dihasilkan.

Petikan captions.json ilustrasi:

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

| Kebimbangan | Penyepaduan Oxylabs sedia ada | FlashData perubahan |
| --- | --- | --- |
| Pengesahan | Klasik: HTTP Basic nama pengguna/password. Web API: Kunci pembawa API. | X-API-Key: FLASHDATA_API_KEY. Bukti kelayakan Oxylabs sedia ada tidak dipindahkan. |
| Metadata | Klasik youtube_metadata; Pertanyaan Web API /media/youtube/metadata. ialah video ID. | sumber: youtube_metadata, video_id: sama 11-watak ID. |
| Kapsyen | Klasik youtube_subtitles; Web API /media/youtube/subtitles. | sumber: youtube_captions untuk teks dan masa; youtube_transcript apabila penghurai anda juga memerlukan fullText. |
| Bahasa dan asal usul | Entri konteks klasik; Web API language_code dan subtitle_origin. Mengabaikan mereka boleh mengembalikan berbilang trek. | Tetapkan params.language dan params.auto secara eksplisit. auto: true = YouTube-dijana; false = pemuat naik-disediakan. Jangan sekali-kali menggantikan trek secara senyap. |
| Penghurai respons | Klasik dan Web API mempunyai sampul hasil yang berbeza dan output sari kata berkumpulan. | Semak status: done, kemudian hasil[].videoId, languageCode, isAutoGenerated dan segmen. Permulaan segmen/end ialah saat. |
| Async IDs | Web API metadata.request_id; Kerja klasik IDs menggunakan titik akhir hasil mereka sendiri. | Simpan FlashData resit penyerahan dan gunakan titik akhir tugas pengurusannya. Simpan pembekal IDs berasingan; jangan gunakan semula undian Oxylabs URL. |

### Tugas metadata pilihan

Berikan youtube_metadata kebenaran. POST badan ini kepada https://data.flashdata.dev/v1/queries/realtime dengan X-API-Key. Ia adalah permintaan standard yang berasingan. Semak status: done sebelum membaca keputusan[0].

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

[Medan kapsyen](https://flashdata.dev/ms/docs/sources/youtube_captions/reference.md) · [Medan metadata](https://flashdata.dev/ms/docs/sources/youtube_metadata/reference.md).

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

Kumpul sekali, analisa berkali-kali. Gunakan semula runut yang disimpan untuk ringkasan dan benam; muat semula data sumber hanya apabila tugas itu memerlukannya.

| Situasi | apa nak buat |
| --- | --- |
| Lagu yang dipilih tiada | Oxylabs boleh mengembalikan objek kosong untuk bahasa yang sah tanpa sari kata yang sepadan. Anggap teks kapsyen yang tiada atau kosong sebagai jurang data; jangan buat transkrip. |
| batch yang besar diterima sebahagiannya | Oxylabs Web API dokumen sehingga 5,000 pekerjaan setiap batch dan berasingan diterima/rejected penyertaan. Kekal diterima IDs. Untuk FlashData, potong ke maxBatchSize akaun dan kekalkan setiap kerja yang dikembalikan ID. |
| Masa panggilan realtime tamat | Simpan folder permintaan dan periksa Sejarah sebelum penyerahan lain. Untuk beratur panjang-running, gunakan penyerahan async, simpan resitnya dengan segera dan undi kerja sedia ada. |
| Akaun atau bukti kelayakan berubah | Simpan API kunci dalam stor rahsia hos. Berhenti pada 401/403; selesaikan baki pada 402; penghormatan Retry-After pada 429. Jangan mulakan percubaan baru untuk memintas baki yang habis. |

| FlashData pelan | Pertanyaan serentak | Pertanyaan setiap permintaan Kelompok |
| --- | --- | --- |
| Bayar mengikut penggunaan | 25 | 100 |
| Micro | 50 | 100 |
| Starter | 100 | 200 |
| Pro | 200 | 300 |
| Scale | 300 | 400 |
| Business | 400 | 500 |

Concurrency bukan permintaan sesaat. Untuk set data bersaiz fail, gunakan pemprosesan Pukal. [Masa nyata dan async](https://flashdata.dev/ms/docs/reference/realtime-and-async/reference.md) · [Kelompok dan pukal](https://flashdata.dev/ms/docs/reference/batch-and-bulk/reference.md) · [Titik akhir pukal](https://flashdata.dev/ms/docs/reference/bulk-processing/reference.md) · [Kesilapan](https://flashdata.dev/ms/docs/errors/reference.md).

Agen-agen yang Eligable dapat dimulai dengan kredit 1 (hingga permintaan standar 100) untuk jam 72.

Guna semula akses sedia ada dahulu. Untuk penggunaan berulang, pemilik menuntut sambungan dan meluluskan kebenaran serta akses baki kongsi. Kredit sementara yang tidak digunakan tidak dipindahkan. Kekalkan kelayakan antara larian dan berhenti pada pembatalan atau baki habis.

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

[Perbicaraan dan tuntutan](https://flashdata.dev/ms/docs/guides/agent-onboarding/reference.md) · [Tugasan berulang](https://flashdata.dev/ms/docs/guides/recurring-tasks/reference.md) · [Simpan hasil carian](https://flashdata.dev/ms/docs/guides/save-results/reference.md).

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

### Adakah FlashData pengganti drop-in?

Tidak. Tukar pengesahan, medan permintaan, penghuraian respons dan perolehan kerja. Contoh-contoh tersebut menyesuaikan satu tugasan kapsyen ke dalam rekod aplikasi yang stabil; mereka tidak meniru sampul surat respons Oxylabs.

### Bolehkah saya mengekalkan penyepaduan Oxylabs Klasik saya semasa berhijrah?

ya. Alihkan satu tugas pada satu masa, kekalkan keputusan Klasik yang disimpan dan simpan bukti kelayakan dan kerja IDs dipisahkan oleh pembekal. Pemetaan merangkumi kedua-dua permintaan sumber Klasik/context dan permintaan titik akhir Web API yang lebih baharu.

### Adakah FlashData menjana transkrip apabila kapsyen tiada?

Sumber ini mendapatkan semula YouTube kapsyen sedia ada. auto: true memilih sari kata yang dijana YouTube; ia tidak meminta pertuturan-ke-teks baharu. Laporkan runut yang hilang atau kendalikan transkripsi sebagai aliran kerja yang berasingan.

### Bagaimana pula dengan memuat turun video sebenar?

YouTube Muat turun ialah produk FlashData berasingan dengan kebenarannya sendiri dan harga berasaskan bait. Perbandingan ini dan contoh merangkumi metadata dan kapsyen; mereka tidak memuat turun fail video atau audio.

### Apakah yang perlu kekal dalam aliran kerja Oxylabs saya yang sedia ada?

Kekalkan infrastruktur proksi, platform sosial lain dan sebarang kontrak pengekstrakan tersuai, panggilan balik atau penghantaran storan yang masih diperlukan oleh aplikasi anda. Kedua-dua pembekal menyokong async kerja, batch koleksi, MCP dan kemahiran; keupayaan itu sahaja bukanlah alasan untuk berhijrah.

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