Skip to content
EN
Get API key

YouTube Data API comparison

Oxylabs Alternative for YouTube Data

Video research without a monthly commitment.

Move metadata and caption tasks to FlashData’s pay-as-you-go API. Keep the language, timing and evidence your app needs, with a practical migration path from Oxylabs Classic or Web API.

Read as Markdown · Looking for Google Search? See the SERP comparison →

01 · A focused YouTube workflow

Feature-by-feature comparison

Choose the spending model and tools that suit your video research.

Feature-by-feature comparison: FlashData and Oxylabs YouTube
FeatureFlashDataOxylabs YouTube
Flexible spending for video research
Paid use without a monthly subscriptionYesPAYG; credit top-ups start at $10NoCurrent paid self-service requires an active subscription
Metadata-only lookup · 1,000 videos$0.501,000 standard source requests · PAYGConfirm the endpoint ratePublic Video data API price is per GB, not a metadata request quote
Caption-only lookup · 1,000 videos$0.50One selected existing track per video · PAYGDedicated subtitles endpointConfirm its billing unit in your account
Shared Google Search and YouTube balanceYesYesShared product credit balance
Find videos and refresh their metadata
Keyword discovery and search suggestionsYesSearch, Extended Search and Suggestions sourcesYesYouTube search, search/max and autocomplete endpoints
Metadata for a known video IDYesTitle, channel, duration, thumbnails and engagement countsYesDedicated metadata endpoint accepts a video ID
Chapters and available caption languagesYesOptional chapters plus transcriptLanguagesYesChapter markers and subtitle languages in metadata
Control which caption evidence reaches your app
Retrieve captions independently of metadataYesDedicated transcript and caption sourcesYesDedicated YouTube subtitles endpoint
Select caption language and originYesExplicit language and auto selectionYeslanguage_code and subtitle_origin
Several languages in one requestUp to 10 selected languagesAn explicit language array returns tracks plus errorsOne selected language or allOmit language_code for all languages; omit subtitle_origin for both origins
Text and timing for source citationsNormalized segments + fullTextJSON start/end times in secondsYouTube subtitle track payloadsText and timings grouped by language and origin
Unavailable requested tracksPer-language errors in array requestsKeep successful tracks; inspect errors even when status is doneEmpty result for a missing trackA valid language code without a match returns {}
Prepare data for an application or LLMJSON, plain text or MarkdownSelect the API response and content formatTrack data or custom JSON extractionSubtitle extraction accepts a prompt or a schema
Process lists and keep agent access reusable
Interactive, async and batch modesYesSame source request shape across execution modesYesWeb API metadata and subtitles support sync, async and batch
Submit a prepared video listID file in Bulk JobsConsole or API; monitor progress and retrieve result partsID array in the Batch APIShared parameters apply to every job in the batch
Save a large collection to your storageBulk manifests and result partsManaged or customer storage for bulk outputAsync storage deliveryS3, S3-compatible storage, GCS and TOS
Agent trial before owner account setupYesEligible agents: up to 100 standard requests, then owner claimingRegister an account first$5 one-time welcome credit per team
Standalone CLI without Node.js or PythonYesLinux, macOS and WindowsHTTP API, MCP and skillsNo equivalent standalone binary verified in the reviewed setup docs
MCP and skills for an agent hostYesReuse approved owner access for ongoing tasksYesWeb API MCP server and agent skills

Keep occasional research affordable

FlashData pay as you go has no monthly fee. Fetch the videos your task needs and keep one balance for Google Search and YouTube.

Budget in source requests

Count metadata and caption retrieval separately. A metadata refresh does not require another caption request; a saved caption track can serve later analysis.

Keep the evidence, not just the summary

Save caption text with its language, origin and timestamps. The migration examples create source links for each segment and preserve the raw response and usage.

02 · Compare the billing unit first

Requests, subscriptions and shared balances.

FlashData prices standard YouTube Data by source request. Oxylabs’ current public Video data API row is priced in GB. Select a plan on each side to compare the published terms.

FlashData · standard YouTube Data

$0.50per 1,000 source requests

Monthly fee
$0.00
Included shared usage value
$0.00
Included standard requests
0
Metadata + captions / 1,000 videos
$1.00 · 2,000 requests

Included counts allocate the full plan balance to YouTube Data. Extended Search and Download use separate rates. PAYG starts with a credit top-up, not a monthly quota.

Oxylabs · published Video data API

$2.00per GB · a different billing unit

Monthly fee
$15.00
Included shared credit balance
$15.00
Included metadata / caption requests
No fixed count published
After the balance is spent
Top up or upgrade to resume

This is the public Video data API rate, not a confirmed metadata/subtitle request price. Use the billing unit and rate shown for your account’s endpoint.

Why there is no savings percentage

Oxylabs lists Video data API in GB. Its public table does not establish a per-request price for the metadata and subtitles endpoints. Use your account’s billing unit and rate for those calls; the generic Scrape ‘from’ price is not a YouTube quote. A GB allowance cannot be converted into a fixed number of videos. USD; tax, trials, other product usage and custom contracts are excluded.

Oxylabs public pricing reviewed 2026-11-10; Enterprise starts at $2,500/month with tailored terms. FlashData amounts load from its public pricing catalog.

All FlashData YouTube Data plans
FlashData YouTube Data plans
FlashData planPer 1,000 requestsMonthly feeIncluded requests / month
Pay As You Go$0.50$0.000
Micro$0.40$49.00125,000
Starter$0.35$199.00571,428
Pro$0.30$499.001,666,666
Scale$0.25$999.004,000,000
Business$0.20$1,999.0010,000,000

One metadata lookup plus one caption lookup uses two requests per video. Included counts allocate the full shared plan balance to standard YouTube Data.

Full YouTube Data pricing →

Start with FlashData

Eligible verified signups can receive an initial allowance of up to 4,000 standard YouTube Data requests. This is a starting balance, not a monthly reset. Paid top-ups start at $10.

Agent trial and claiming →

Understand the Oxylabs balance

Oxylabs paid self-service uses an active subscription and a shared monthly credit balance. Unused balance expires at renewal; service pauses at zero until a top-up or upgrade. The $5 welcome credit is a one-time team allowance, not a monthly quota. Existing Classic or custom contracts may have different terms.

03 · Preserve the caption track

From an Oxylabs subtitle request to a cited result.

The first task retrieves one existing English, YouTube-generated track. Its output keeps second-based timestamps, source links and usage. It does not download media or generate new speech-to-text.

1 Identify the request you are replacing

Both Oxylabs versions use a video ID. Classic puts language and origin in context; Web API uses top-level fields. These are reference requests for your existing integration.

Oxylabs Classic
# 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'
Oxylabs Web API
# 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 Set up FlashData and save the files

Create or reuse a key with youtube_captions permission in API Keys and check available credits. Use your secret store or the hidden prompt; keep credentials out of source control and agent chat.

Use Python 3.10+; install python -m pip install requests. Create a working folder named youtube-migration/. Save both files below there.

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

Save the complete script as youtube-migration/captions.py. It reads FLASHDATA_API_KEY from your environment or a hidden prompt.

captions.py
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.")

From inside youtube-migration/, run the saved script. A new output folder submits one caption request.

Run and inspect
python captions.py track-001
python -m json.tool track-001/captions.json
python -m json.tool track-001/record.json

Repeat the same command to read the saved response without an API call. Each folder owns its saved request: use a new folder for a different video, language or origin after resolving any incomplete attempt.

3 Verify the track before citing it

track-001/captions.json contains the checked track and segment links. record.json records the request, time and usage; result.json preserves the raw response.

The script checks the video ID, selected language and origin. It accepts a matching auto-caption -orig language variant, preserves overlapping segments and reports empty text. It never substitutes another language.

Run against a video with the requested track. Missing or unavailable captions are a data gap to handle, not a successful transcript.

Caption response fields →
Illustrative captions.json · excerpt
{
  "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"
    }
  ]
}
Oxylabs to FlashData request and parser mapping
ConcernExisting Oxylabs integrationFlashData change
AuthenticationClassic: HTTP Basic username/password. Web API: Bearer API key.X-API-Key: FLASHDATA_API_KEY. Existing Oxylabs credentials do not transfer.
MetadataClassic youtube_metadata; Web API /media/youtube/metadata. query is the video ID.source: youtube_metadata, video_id: the same 11-character ID.
CaptionsClassic youtube_subtitles; Web API /media/youtube/subtitles.source: youtube_captions for text and timing; youtube_transcript when your parser also needs fullText.
Language and originClassic context entries; Web API language_code and subtitle_origin. Omitting them can return multiple tracks.Set params.language and params.auto explicitly. auto: true = YouTube-generated; false = uploader-provided. Never silently substitute a track.
Response parserClassic and Web API have different result envelopes and grouped subtitle output.Check status: done, then results[].videoId, languageCode, isAutoGenerated and segments. Segment start/end are seconds.
Async IDsWeb API metadata.request_id; Classic job IDs use their own result endpoints.Save the FlashData submission receipt and use its management job endpoints. Keep provider IDs separate; do not reuse an Oxylabs polling URL.
Fetch metadata separately

Grant youtube_metadata permission and send this body with X-API-Key to POST https://data.flashdata.dev/v1/queries/realtime. It is a separate standard request. Read results[0] after checking status: done.

Metadata request body
{
  "source": "youtube_metadata",
  "video_id": "FUfGcZ092b0",
  "params": {
    "include_chapters": true,
    "include_formats": false
  }
}
Metadata fields and runnable playground →

04 · Keep recurring tasks predictable

Save results, preserve identity, recover deliberately.

Separate collecting a caption track from analyzing it. Reuse the saved track across summaries, embeddings and recurring reports; refresh only when the task needs new source data.

Production migration checklist
SituationWhat to do
A selected track is absentOxylabs can return an empty object for a valid language with no matching subtitles. Treat missing or empty caption text as a data gap; do not manufacture a transcript.
A large batch is partly acceptedOxylabs Web API documents up to 5,000 jobs per batch and separate accepted/rejected entries. Retain accepted IDs. For FlashData, chunk to the account’s maxBatchSize and retain each returned job ID.
A realtime call times outKeep the request folder and inspect History before another submission. For long-running queues, use async submission, save its receipt immediately and poll the existing job.
An account or credential changesKeep API keys in the host’s secret store. Stop on 401/403; resolve balance on 402; honor Retry-After on 429. Do not start fresh trials to bypass an exhausted balance.

FlashData submission limits

Current FlashData account limits
PlanConcurrent queriesQueries per Batch request
Pay As You Go25100
Micro50100
Starter100200
Pro200300
Scale300400
Business400500

Concurrency is not requests per second. For file-sized datasets, use Bulk processing instead of placing every ID in one Batch call.

For coding and personal agents

Eligible agents can start with 1 credit (up to 100 standard requests) for 72 hours. Reuse existing access first. Before recurring use, the owner claims the connection and approves permissions and shared-balance access. Unused temporary credits do not transfer.

Agent migration task
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.

05 · Before moving traffic

Migration questions

Is FlashData a drop-in replacement?

No. Change authentication, request fields, response parsing and job retrieval. The examples adapt one caption task into a stable application record; they do not imitate an Oxylabs response envelope.

Can I keep my Classic Oxylabs integration while migrating?

Yes. Move one task at a time, retain saved Classic results and keep credentials and job IDs separated by provider. The mapping covers both Classic source/context requests and newer Web API endpoint requests.

Does FlashData generate a transcript when captions are missing?

These sources retrieve existing YouTube captions. auto: true selects YouTube-generated subtitles; it does not request fresh speech-to-text. Report missing tracks, or handle transcription as a separate workflow.

What about downloading the actual video?

YouTube Download is a separate FlashData product with its own permission and byte-based pricing. This comparison and the examples cover metadata and captions; they do not download video or audio files.

What should stay in my existing Oxylabs workflow?

Keep proxy infrastructure, other social platforms and any custom extraction, callback or storage-delivery contracts your application still requires. Both providers support async work, batch collection, MCP and skills; those capabilities alone are not a reason to migrate.

Start with a known caption track

Bring timestamped evidence into your app.

Run one task, verify the track and keep the result.