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.
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 | FlashData | Apify YouTube actors |
|---|---|---|
| Keep targeted lookups economical | ||
| Paid usage with no monthly subscription | YesPay-as-you-go credits; top-ups from $10 | Free 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 lookup | YesOne explicit video_id | Actor-dependentStreamers supports it; API Dojo currently excludes single-video URLs |
| Find and enrich the videos your app needs | ||
| Keyword discovery with search filters | YesDate, duration, type and sorting filters | YessearchQueries plus sorting, date and video filters |
| Title, channel and engagement data | YesDedicated metadata lookup by video ID | YesVideo records in the Actor dataset |
| Refresh metadata separately from captions | YesRequest only youtube_metadata for the refresh | YesRun with transcriptionAndSubtitle=NONE |
| Prepare caption evidence for your application | ||
| Choose several existing caption languages | Up to 10 explicit languagesTracks plus per-language errors in one transcript request | Main actor: one language or anyDifferent actors can expose different inputs |
| Select a strict caption origin | Uploader or YouTube-generatedparams.auto selects one origin; no cross-origin fallback | Main actor: origin preferencepreferAutoGeneratedSubtitles is a preference, not the same contract |
| Timestamped text for source citations | Normalized JSON segmentsText with start/end times in seconds | SRT, VTT or XML subtitlesParse the selected subtitle format for citation timings |
| Plain text for summarization | fullText alongside segments | plaintext subtitle formatOr parse and join the timed subtitle output |
| Videos without an existing transcript | Report the missing trackNo speech-to-text generation | Optional AI transcriptionFallback or always-transcribe modes; separate usage charges |
| Run the workflow with less integration code | ||
| Direct result without managing Actor resources | Realtime results[] + usageNo Actor ID, build or memory setting | Actor run + input schemaSync endpoint can also return results in one HTTP call |
| Process a saved list in a browser console | Bulk Jobs with a video-ID fileTrack progress and retrieve the manifest and result parts | Actor console with URL inputsSupports CSV or Google Sheet imports |
| Background results after the client disconnects | Saved async or Bulk job IDResume status checks and retrieve completed outputs | Saved Actor run and dataset IDsInspect the run and retrieve its dataset items |
| Application and agent output formats | JSON, plain text or Markdown | Dataset exportsJSON, CSV, Excel and other formats |
| Recurring collection | Your scheduler or agent hostReuse the owner credential and saved job state | Hosted Actor schedulesCron, timezone settings and optional webhooks |
| Metadata, captions and Google Search in one API contract | One query API, source-specific permissionsShared account balance; source-specific prices | Shared platform; Actor-specific schemasChoose and maintain the relevant Actor inputs and outputs |
| CLI, SDKs and MCP for automation | YesStandalone CLI; Python, TypeScript and Go SDKs; MCP | YesApify 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.
| Actor | Free / 1,000 videos | Starter | Scale | Business | Choose it for |
|---|---|---|---|---|---|
| streamers/youtube-scraper | $4.00 | $3.00 | $2.60 | $2.40 | Video URLs, discovery and optional existing subtitles. This is the calculator’s actor. |
| streamers/youtube-channel-scraper | $1.30 | $1.00 | $0.80 | $0.50 | Channel 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.50 | Discovery 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
| Apify plan | Monthly fee | Included usage / month | Main Actor / 1,000 videos | Videos within this budget |
|---|---|---|---|---|
| Free | $0.00 | $5.00 | $4.00 | 1,250 |
| Starter | $19.00 | $19.00 | $3.00 | 6,333 |
| Scale | $199.00 | $199.00 | $2.60 | 76,538 |
| Business | $999.00 | $999.00 | $2.40 | 416,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 plan | Per 1,000 requests | Monthly fee | Included requests / month |
|---|---|---|---|
| Pay As You Go | $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 |
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.
# 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}'{
"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.
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.
python video-lookup.py FUfGcZ092b0 video-001Reusing 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.
[
{
"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"
]
}
]| Existing Actor field | FlashData metadata | Migration action |
|---|---|---|
| id / url | videoId | Keep id and construct the canonical YouTube watch URL. |
| title / text | title / description | Map description to text if your reader expects the Actor’s field name. |
| channelName / channelId | channel / channelId | Preserve the name and ID. Do not infer a channel handle from its display name. |
| likes / commentsCount / viewCount | likeCount / commentCount / viewCount | Keep missing values as null. A missing metric is not zero. |
| duration, often HH:MM:SS | duration in seconds | The example converts seconds into an HH:MM:SS string, retaining null. |
| date, which may be absolute or relative | uploadDate | The example keeps uploadDateRaw. Add your own date parser before populating a normalized date. |
| subtitles[] / transcriptionUrl | A separate youtube_transcript or youtube_captions request | Existing tracks and generated speech-to-text are different inputs to your app. |
| Actor-only enrichment fields | No automatic equivalent | Keep a separate enrichment step for comments, channel expansion and AI-generated analysis. |
Carry over subtitle intent, not just a boolean
| Current Actor setting | FlashData change |
|---|---|
| ALWAYS_SUBTITLES | Add a separate youtube_transcript or youtube_captions request for an existing track. |
| subtitlesLanguage: en | Set params.language to en. An array of up to 10 languages returns tracks plus per-language errors. |
| preferAutoGeneratedSubtitles | This 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_TRANSCRIBE | Keep a separate speech-to-text step. FlashData does not generate a track when existing captions are missing. |
| subtitles[].srt / transcriptionUrl | Adapt timestamped segments for your reader, or format a caption file explicitly. Do not treat a plain generated transcript URL as segment data. |
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.
| Concern | Apify | FlashData |
|---|---|---|
| Request | Actor ID + build/input options; optional saved Task | source + video_id + params; no Actor build or memory options |
| Synchronous result | run-sync-get-dataset-items returns an item array; its documented HTTP limit is 300 seconds | Realtime response has status, results[] and usage; extract results before mapping fields |
| Long-running work | Start a run, save run ID, wait for a terminal status, read defaultDatasetId | Submit an async or batch job, save its ID, poll its status and retrieve its result |
| Output storage | Dataset items plus optional key-value records referenced by URL | Save the response or export to your own durable storage; an Apify dataset ID is not a FlashData job ID |
| Recurring work | Apify Schedule starts Actors/Tasks; webhooks notify downstream consumers | Use 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
- Record the Actor ID, pinned build, saved Task input, billable events and output fields your consumer actually reads.
- 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.
- Run the new adapter against a saved list of IDs. Verify output IDs, nulls, date handling and caption origin before switching the reader.
- 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.
- 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.
- Inspect the existing Actor integration.
Identify the source of video IDs, output consumer and schedule. Keep unrelated Actor workloads separate.
- Prove one lookup.
Use the CLI, SDK or MCP, save the raw response and map only the fields your app needs.
- 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.
- Reuse the owner credential.
Keep one persistent profile, save results by run and stop after revocation. Recurring calls use the owner’s balance.
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.