Skip to content
EN
Get API key

YouTube Data API comparison

Apify Alternative

From Actor runs to direct video lookups.

Already have the video IDs? Fetch metadata and existing captions with FlashData, then feed your app the fields it needs. Compare the exact Actor, separate discovery from enrichment and migrate one lookup before changing your pipeline.

Read as Markdown

01 · For video apps and agents

Feature-by-feature comparison

Focus on the lookup your application needs, without carrying over an Actor’s runtime and storage model.

Feature-by-feature comparison: FlashData and Apify YouTube actors
FeatureFlashDataApify YouTube actors
Keep targeted lookups economical
Paid usage with no monthly subscriptionYesPay-as-you-go credits; top-ups from $10Free budget, then a paid plan$5/month on Free; Starter $19/month with $19 usage
Metadata for 1,000 known video IDs$0.50Pay-as-you-go usage rate$3.00streamers/youtube-scraper · Starter rate, deducted from the plan’s budget
One-video lookupYesOne explicit video_idActor-dependentStreamers supports it; API Dojo currently excludes single-video URLs
Find and enrich the videos your app needs
Keyword discovery with search filtersYesDate, duration, type and sorting filtersYessearchQueries plus sorting, date and video filters
Title, channel and engagement dataYesDedicated metadata lookup by video IDYesVideo records in the Actor dataset
Refresh metadata separately from captionsYesRequest only youtube_metadata for the refreshYesRun with transcriptionAndSubtitle=NONE
Prepare caption evidence for your application
Choose several existing caption languagesUp to 10 explicit languagesTracks plus per-language errors in one transcript requestMain actor: one language or anyDifferent actors can expose different inputs
Select a strict caption originUploader or YouTube-generatedparams.auto selects one origin; no cross-origin fallbackMain actor: origin preferencepreferAutoGeneratedSubtitles is a preference, not the same contract
Timestamped text for source citationsNormalized JSON segmentsText with start/end times in secondsSRT, VTT or XML subtitlesParse the selected subtitle format for citation timings
Plain text for summarizationfullText alongside segmentsplaintext subtitle formatOr parse and join the timed subtitle output
Videos without an existing transcriptReport the missing trackNo speech-to-text generationOptional AI transcriptionFallback or always-transcribe modes; separate usage charges
Run the workflow with less integration code
Direct result without managing Actor resourcesRealtime results[] + usageNo Actor ID, build or memory settingActor run + input schemaSync endpoint can also return results in one HTTP call
Process a saved list in a browser consoleBulk Jobs with a video-ID fileTrack progress and retrieve the manifest and result partsActor console with URL inputsSupports CSV or Google Sheet imports
Background results after the client disconnectsSaved async or Bulk job IDResume status checks and retrieve completed outputsSaved Actor run and dataset IDsInspect the run and retrieve its dataset items
Application and agent output formatsJSON, plain text or MarkdownDataset exportsJSON, CSV, Excel and other formats
Recurring collectionYour scheduler or agent hostReuse the owner credential and saved job stateHosted Actor schedulesCron, timezone settings and optional webhooks
Metadata, captions and Google Search in one API contractOne query API, source-specific permissionsShared account balance; source-specific pricesShared platform; Actor-specific schemasChoose and maintain the relevant Actor inputs and outputs
CLI, SDKs and MCP for automationYesStandalone CLI; Python, TypeScript and Go SDKs; MCPYesApify CLI, Python/JavaScript clients and MCP

The Actor-specific rows refer to streamers/youtube-scraper unless another Actor is named. Both services offer SDKs, CLI and MCP options. Apify also runs custom code, schedules and other websites’ scrapers.

Keep one-video lookups small

Pass a video ID and receive metadata directly. Use pay-as-you-go access when the job does not need a platform subscription or a channel crawl.

Keep your application’s data model

Map the fields your app actually reads. Preserve null counts, keep publication dates explicit and save a JSON array for consumers that previously read dataset items.

Keep discovery separate from enrichment

Continue a useful discovery workflow, deduplicate its video IDs, then enrich only the videos your product needs with FlashData.

02 · Know what you are replacing

There is no single “Apify YouTube price.”

Actor authors set their prices and inputs. These three actors charge per returned video, but their capabilities differ. Account tiers also change some event prices.

Published Actor result rates, USD per 1,000 videos
ActorFree / 1,000 videosStarterScaleBusinessChoose it for
streamers/youtube-scraper$4.00$3.00$2.60$2.40Video URLs, discovery and optional existing subtitles. This is the calculator’s actor.
streamers/youtube-channel-scraper$1.30$1.00$0.80$0.50Channel discovery with basic video data. It is not a full metadata lookup for an arbitrary ID.
apidojo/youtube-scraper$0.50$0.50$0.50$0.50Discovery inputs. Its current README excludes single-video URLs and requires at least 10 videos per input. Free demo: 5 runs/month, at most 10 items/run.

Reviewed 2026-11-10. Self-serve monthly plans shown; Starter maps to Bronze, Scale to Silver and Business to Gold. The cheaper discovery actors are not substituted into the known-video calculator.

Check the billable event

Read the exact Actor ID and event breakdown in your current run. Pay-per-event, pay-per-usage and combined models all exist. For the main Actor here, count result events and enabled add-ons; do not add a second generic compute charge.

Separate captions from generated audio text

Existing subtitles can accompany a result. AI transcription is billed per started video minute: on Starter, a 10-minute video adds $0.41 before its $0.003 result event. FlashData retrieves existing tracks; it does not perform that generation.

Keep discovery costs visible

A channel crawl can return videos your app never uses. When you already have IDs, compare per-video enrichment. When you need discovery, budget the discovery step and any subsequent caption or metadata calls separately.

03 · Unit rates and platform fees

Compare the whole task, with plans on both sides.

The main Actor can include existing subtitles in its metadata result. FlashData uses two requests for that workflow. The calculator counts both and applies each plan’s shared usage allowance before adding extra usage.

1,000 FlashData requests · 1,000 Actor result events

Actor: streamers/youtube-scraper. One result per known video, with optional existing subtitles. Cheaper discovery actors have different inputs and are listed above.

FlashData · Pay As You Go

$0.50per 1,000 videos · selected workflow

$0.50 / 1,000 requests × 1 per video

Monthly fee
$0.00
Shared usage included / month
$0.00
Videos within included usage
0
Usage above included balance
$0.50
Modeled monthly cost
$0.50
Purchase from zero balance
$10.00
Effective cost / 1,000 videos
$0.50

No monthly subscription. The $10 minimum top-up can fund this and later requests.

Apify · Starter

$3.00per 1,000 videos · selected workflow

One result event per video; existing subtitles included

Monthly fee
$19.00
Shared usage included / month
$19.00
Videos within included usage
6,333
Usage above included balance
$0.00
Modeled monthly cost
$19.00
Effective cost / 1,000 videos
$19.00

The plan fee already includes the usage budget. Other Actors and platform usage reduce what remains for this task.

How the estimate works

USD, monthly list plans. This model uses the result event of streamers/youtube-scraper, one returned video per input ID, with date filtering and AI add-ons off. Existing subtitles use its ALWAYS_SUBTITLES setting; metadata plus captions is one Actor result but two FlashData requests. FlashData prices come from its current YouTube Data catalog. Each plan’s entire included balance is allocated to this workflow before extra usage is added. Apify Free stops at its $5 budget; paid plans add usage above the included budget. FlashData purchases from zero balance include its $10 minimum top-up when additional credit is needed. Taxes, annual discounts, other Actors, separate storage/export charges and failed attempts are excluded. At zero videos, a selected paid plan still has its monthly fee; effective cost per video is undefined.

Apify’s monthly platform plans

Plan budgets for streamers/youtube-scraper result events
Apify planMonthly feeIncluded usage / monthMain Actor / 1,000 videosVideos within this budget
Free$0.00$5.00$4.001,250
Starter$19.00$19.00$3.006,333
Scale$199.00$199.00$2.6076,538
Business$999.00$999.00$2.40416,250

These video counts allocate the full plan budget to result events, with no paid add-ons or other platform usage. If you keep Apify for other Actors, compare the incremental usage and remaining budget; that subscription does not disappear when one workload moves.

All FlashData YouTube Data plans
FlashData YouTube Data pricing
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

These are standard YouTube Data request rates. Extended Search and Download have separate prices.

Full YouTube Data pricing →
Free access and the first purchase

Apify Free has a shared $5 monthly usage budget; individual actors can impose demo restrictions. Eligible verified FlashData signups can receive an initial allowance of up to 4,000 standard YouTube Data requests. FlashData’s initial signup allowance does not reset monthly. Its separate agent trial is explained below.

FlashData pay-as-you-go usage can cost less than its $10 minimum credit purchase. The calculator shows both usage cost and the purchase from a zero balance.

04 · A runnable migration

Keep the dataset reader. Replace one lookup.

Start with a known public video ID from a completed run. This example maps selected Actor-style fields into a JSON array and preserves the full FlashData response separately.

1 Set up access and map the request

Create or reuse a key with youtube_metadata permission in API Keys and check available credits. An agent can reuse access or start an eligible trial. Keep the key in your environment or the script’s hidden prompt.

Existing Actor call · reference only
# The existing Actor call, shown for migration reference.
curl --fail-with-body --silent --show-error --max-time 310 \
  --request POST \
  'https://api.apify.com/v2/acts/streamers~youtube-scraper/run-sync-get-dataset-items' \
  --header "Authorization: Bearer $APIFY_TOKEN" \
  --header 'Content-Type: application/json' \
  --data '{"startUrls":[{"url":"https://www.youtube.com/watch?v=FUfGcZ092b0"}],
    "maxResults":1,"maxResultsShorts":0,"maxResultStreams":0,
    "transcriptionAndSubtitle":"NONE","aiVideoDescription":false,"aiVideoSummary":false}'
FlashData · POST /v1/queries/realtime
{
  "source": "youtube_metadata",
  "video_id": "FUfGcZ092b0",
  "params": {
    "include_formats": false,
    "include_chapters": true
  }
}

The Actor’s sync endpoint already returns data in one HTTP response. The change is the input, result envelope and field mapping—not a claim that every Actor lookup needs polling.

2 Save the script, then run it

Requires Python 3.10+ and requests. Install with python -m pip install requests. Save the complete script as video-lookup.py in a new working folder. It reads FLASHDATA_API_KEY from the environment or prompts privately.

video-lookup.py
import argparse
import getpass
import json
import math
import os
import re
from pathlib import Path

import requests

parser = argparse.ArgumentParser()
parser.add_argument("video_id")
parser.add_argument("folder", type=Path)
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")
body = {"source": "youtube_metadata", "video_id": args.video_id,
        "params": {"include_formats": False, "include_chapters": True}}
out = args.folder
if not out.exists():
    key = os.environ.get("FLASHDATA_API_KEY") or getpass.getpass("FlashData API key: ")
    if not key.strip():
        raise SystemExit("An API key is required")
    out.mkdir(parents=True)
    (out / "request.json").write_text(json.dumps(body), encoding="utf-8")
    try:
        response = requests.post(
            "https://data.flashdata.dev/v1/queries/realtime", json=body,
            headers={"X-API-Key": key, "Accept": "application/json"},
            timeout=120, allow_redirects=False,
        )
    except requests.RequestException:
        raise SystemExit("Outcome unknown. Keep this folder and check History before retrying.")
    (out / "response.json").write_bytes(response.content)
    (out / "http-status.txt").write_text(str(response.status_code), encoding="utf-8")
    (out / "retry-after.txt").write_text(response.headers.get("Retry-After", ""), encoding="utf-8")
else:
    print("Reading saved output; no API call.")

try:
    saved = json.loads((out / "request.json").read_text(encoding="utf-8"))
    status = (out / "http-status.txt").read_text(encoding="utf-8").strip()
except (OSError, ValueError):
    raise SystemExit("Incomplete attempt. Inspect this folder and History before retrying.")
if saved != body:
    raise SystemExit("This folder belongs to a different request. Use a new folder.")
if status != "200":
    raise SystemExit(f"HTTP {status}: inspect response.json and retry-after.txt")
data = json.loads((out / "response.json").read_text(encoding="utf-8"))
if not isinstance(data, dict) or data.get("status") != "done" or data.get("source") != body["source"]:
    raise SystemExit("Request did not complete successfully; inspect response.json")
items = data.get("results")
if not isinstance(items, list) or len(items) != 1 or not isinstance(items[0], dict):
    raise SystemExit("Expected one metadata result")
item = items[0]
if item.get("videoId") != args.video_id:
    raise SystemExit("Returned video does not match the request")
seconds = item.get("duration")
duration = None
if seconds is not None:
    if type(seconds) not in (int, float) or not math.isfinite(seconds) or seconds < 0:
        raise SystemExit("Invalid duration")
    whole = int(seconds)
    duration = f"{whole // 3600:02d}:{whole % 3600 // 60:02d}:{whole % 60:02d}"
mapped = [{
    "id": item["videoId"],
    "url": "https://www.youtube.com/watch?v=" + item["videoId"],
    "title": item.get("title"), "text": item.get("description"),
    "channelName": item.get("channel"), "channelId": item.get("channelId"),
    "viewCount": item.get("viewCount"), "likes": item.get("likeCount"),
    "commentsCount": item.get("commentCount"), "duration": duration,
    "uploadDateRaw": item.get("uploadDate"),
    "captionLanguages": item.get("transcriptLanguages"),
}]
(out / "dataset-items.json").write_text(
    json.dumps(mapped, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
)
print(f"Saved {out}/dataset-items.json; actual usage: {json.dumps(data.get('usage'))}")

Run from the folder where you saved the script. Replace the ID with a public video from your existing dataset.

One metadata lookup
python video-lookup.py FUfGcZ092b0 video-001

Reusing video-001 reads the saved response without another API call. Use a new folder only for an intentional new request. Failed or interrupted attempts stop for inspection; they are not automatically resubmitted.

3 Point your reader at the saved items

video-001/dataset-items.json contains one mapped item. response.json keeps the raw result and actual usage. Replace the dataset-fetching step with a file or storage reader.

This is a field adapter, not the Apify Dataset API. Missing counts stay null. The raw publication date stays in uploadDateRaw; the script does not invent date, comments, monetization status or generated transcript fields.

Metadata schema →
Illustrative dataset-items.json
[
  {
    "id": "FUfGcZ092b0",
    "url": "https://www.youtube.com/watch?v=FUfGcZ092b0",
    "title": "Example video",
    "text": "Example description",
    "channelName": "Example channel",
    "channelId": "UC_EXAMPLE",
    "viewCount": 1200,
    "likes": null,
    "commentsCount": null,
    "duration": "00:03:17",
    "uploadDateRaw": "2025-01-15",
    "captionLanguages": [
      "en",
      "es"
    ]
  }
]
Map fields your existing dataset consumer reads
Existing Actor fieldFlashData metadataMigration action
id / urlvideoIdKeep id and construct the canonical YouTube watch URL.
title / texttitle / descriptionMap description to text if your reader expects the Actor’s field name.
channelName / channelIdchannel / channelIdPreserve the name and ID. Do not infer a channel handle from its display name.
likes / commentsCount / viewCountlikeCount / commentCount / viewCountKeep missing values as null. A missing metric is not zero.
duration, often HH:MM:SSduration in secondsThe example converts seconds into an HH:MM:SS string, retaining null.
date, which may be absolute or relativeuploadDateThe example keeps uploadDateRaw. Add your own date parser before populating a normalized date.
subtitles[] / transcriptionUrlA separate youtube_transcript or youtube_captions requestExisting tracks and generated speech-to-text are different inputs to your app.
Actor-only enrichment fieldsNo automatic equivalentKeep a separate enrichment step for comments, channel expansion and AI-generated analysis.
Carry over subtitle intent, not just a boolean
Main Actor subtitle options and FlashData migration
Current Actor settingFlashData change
ALWAYS_SUBTITLESAdd a separate youtube_transcript or youtube_captions request for an existing track.
subtitlesLanguage: enSet params.language to en. An array of up to 10 languages returns tracks plus per-language errors.
preferAutoGeneratedSubtitlesThis Actor setting is a preference. FlashData params.auto is strict: true for YouTube-generated, false for uploader-provided. Choose intentionally; no cross-origin fallback.
TRANSCRIPTION_AS_FALLBACK / ALWAYS_TRANSCRIBEKeep a separate speech-to-text step. FlashData does not generate a track when existing captions are missing.
subtitles[].srt / transcriptionUrlAdapt timestamped segments for your reader, or format a caption file explicitly. Do not treat a plain generated transcript URL as segment data.
Timestamped captions recipe →

05 · Preserve the rest of the workflow

Move the producer, storage and schedule deliberately.

If your tools depend on Apify dataset IDs and schedules, keep a custom Actor as the orchestrator: call FlashData inside it and write the mapped items into its dataset. Budget that Actor’s runtime and storage alongside FlashData usage. The calculator above models direct FlashData calls.

From Actor infrastructure to an application workflow
ConcernApifyFlashData
RequestActor ID + build/input options; optional saved Tasksource + video_id + params; no Actor build or memory options
Synchronous resultrun-sync-get-dataset-items returns an item array; its documented HTTP limit is 300 secondsRealtime response has status, results[] and usage; extract results before mapping fields
Long-running workStart a run, save run ID, wait for a terminal status, read defaultDatasetIdSubmit an async or batch job, save its ID, poll its status and retrieve its result
Output storageDataset items plus optional key-value records referenced by URLSave the response or export to your own durable storage; an Apify dataset ID is not a FlashData job ID
Recurring workApify Schedule starts Actors/Tasks; webhooks notify downstream consumersUse your application, cron, CI or agent host to call FlashData; migrate the schedule and consumer together

Move an existing dataset

Export every page of the existing dataset before switching producers. Persist referenced subtitle files you still need. Do not rerun an Actor just to download output already collected.

Save and reuse results →

Refresh a video library

Deduplicate video IDs, checkpoint each result and keep input-to-output IDs. Use Batch or bulk processing for larger lists; retry failed items after inspecting their errors.

Bulk processing reference →

Keep scheduled work predictable

Carry over timezone, cadence, credentials and your output destination. Record one completed schedule window before retiring the old producer, so overlapping schedules do not create duplicate work.

Run recurring tasks →
Cutover checklist for an existing scheduled job
  1. Record the Actor ID, pinned build, saved Task input, billable events and output fields your consumer actually reads.
  2. Let existing runs finish and export every dataset page. With clean=true, a short page can reflect skipped items; use the pagination metadata to determine completion.
  3. Run the new adapter against a saved list of IDs. Verify output IDs, nulls, date handling and caption origin before switching the reader.
  4. Move the schedule’s timezone, cadence and destination to your runner. Add durable checkpoints and your own spending controls; maxTotalChargeUsd is not a FlashData key setting.
  5. Turn off the old producer when the new schedule owns the next time window. Keep existing exports, and stop recurring work on revoked credentials or insufficient balance.

06 · Coding and personal agents

Migrate one useful task before recurring use.

Eligible agents can start with 1 credit (up to 100 standard YouTube Data requests) for 72 hours. Reuse saved access first. Metadata and caption requests share the same allowance.

  1. Inspect the existing Actor integration.

    Identify the source of video IDs, output consumer and schedule. Keep unrelated Actor workloads separate.

  2. Prove one lookup.

    Use the CLI, SDK or MCP, save the raw response and map only the fields your app needs.

  3. Claim for continued use.

    The owner signs in or signs up, verifies email and approves scopes and shared-balance access. Unused trial credits do not transfer.

  4. Reuse the owner credential.

    Keep one persistent profile, save results by run and stop after revocation. Recurring calls use the owner’s balance.

Give this migration task to your agent
Replace this project's Apify YouTube metadata lookup with FlashData.
Read https://flashdata.dev/auth.md and https://flashdata.dev/docs/sources/youtube_metadata/reference.md.
Identify the exact Actor ID, build, input, output fields, schedule and storage consumer first.
Reuse a saved FlashData credential or start one eligible trial with youtube_metadata permission.
Run one known video ID. Save the raw response, actual usage and a mapped JSON item array.
Keep null metrics and preserve the raw publication date. Do not invent Actor-only fields.
Keep channel discovery, comments, AI transcription and hosted scheduling separate unless explicitly migrated.
Reuse saved results after restart. Ask the owner to claim before recurring use and store keys outside chat.
Stop after revocation or insufficient balance; never create more trials to continue.

07 · Migration questions

Before you switch

Is this a replacement for the Apify platform?

It replaces specific YouTube data calls in your workflow. Apify also provides an Actor marketplace, custom runtimes, hosted schedules and storage. Keep those parts where you use them, or move their responsibilities into your own application.

Why not compare every Actor at one price?

Actor developers choose different pricing models, outputs and input restrictions. The calculator uses streamers/youtube-scraper. The actor table also includes a cheaper discovery actor; its single-video restrictions matter when replacing an on-demand lookup.

Does an Apify subscription charge twice for the included usage?

No. The plan fee includes a prepaid usage budget. The calculator subtracts that budget before adding further Actor usage. It assumes the whole budget is available for this workflow. If other Actors consume it, less remains for YouTube.

Can I keep an Apify dataset consumer?

The example writes a JSON array with selected familiar field names. It does not create an Apify dataset or run ID. Read the new file directly, publish it through your own storage, or keep a custom Actor that writes these mapped items to its dataset for your existing consumer.

What happens to subtitles and AI transcription?

Apify’s main actor offers existing subtitles and optional AI transcription. FlashData retrieves existing YouTube tracks. Request metadata and captions separately, check the returned language and origin, and keep any speech-to-text or AI summary step separate.

Will my existing schedule or run spending cap transfer?

No. Recreate the schedule in your chosen runner, and add an application-level budget check. An Apify maxTotalChargeUsd setting is not a FlashData API-key spending cap. Owner keys use the shared account balance.

Start with one known video

Turn an Actor result into an application API call.

Keep the data you need and save the output your reader expects.