YouTube Data API comparison
ScrapeCreators Alternative
Fresh video data. A smaller starting spend.
Build video research, caption search and creator dashboards with FlashData. Compare fresh-request costs and free cache hits, then move your YouTube metadata and caption calls without rewriting the rest of your social-data integration.
01 · For video apps and agents
Feature-by-feature comparison
Focus on the cost and controls behind a YouTube research workflow.
| Feature | FlashData | Scrape |
|---|---|---|
| Lower the cost of fresh YouTube data | ||
| Entry paid rate / 1,000 metadata or caption calls | $0.50Pay-as-you-go usage | $1.88Freelance · fresh one-credit calls |
| Lowest listed unit rate / 1,000 calls | $0.20Optional monthly plan; its fee still applies | $0.994Business · $497 prepaid pack; custom Enterprise excluded |
| First paid credit purchase | From $10 | $4725,000-credit Freelance pack |
| Pay as you go without a monthly fee | Yes | Yes |
| Find videos and refresh the facts you need | ||
| Find videos by keyword and filters | YesDate, duration, type and sorting filters | YesSearch filters and continuation-token pagination |
| Metadata for a known video | YesTitle, channel, duration, thumbnails and engagement counts | YesVideo/Short Details endpoint |
| Chapter markers for navigation | Yesinclude_chapters; titles with start/end times when present | Yeschapters in the video response when present |
| Discover available caption tracks | Metadata language listhasTranscripts and transcriptLanguages | Metadata captionTracksLanguage codes and track details |
| Keep caption selection and evidence explicit | ||
| Text and timestamps from the same response | Full text + timed segmentsStart/end times in seconds | Full text + timed segmentsstartMs/endMs as millisecond strings |
| Several caption languages in one request | Up to 10 languagesExisting tracks plus per-language errors | One selected languagelanguage or original_audio selection per transcript call |
| Choose caption origin explicitly | Uploader or YouTube-generatedparams.auto selects one origin | Language and spoken-audio selectionoriginal_audio is not a caption-origin switch |
| Missing-caption handling | Existing tracks and explicit errorsLanguage arrays preserve successful tracks and report missing selections | Null transcript fieldsMissing requested tracks cost zero credits; no YouTube AI transcription |
| Choose how old reused data may be | Cache policy in your applicationSave retrieval times and decide when to fetch again | cache_max_age1–30-day options; cache hits cost zero credits and expose cached_at |
| Run a repeatable data workflow | ||
| Process a saved file of video IDs | Managed bulk jobsSubmit the file, track its job and retrieve outputs | Per-video endpoint callsManage the file loop and result storage in your integration |
| Move long collections into background jobs | Async, Batch and Bulk APIsPersist job IDs, track status and retrieve results | Synchronous YouTube callsQueue and checkpoint per-video calls in your worker |
| Structured and readable output | JSON, plain text or MarkdownSelected through API response headers | JSON API and CLI formatsCLI also exports CSV, tables and Markdown |
| Terminal installation | Standalone executableLinux, macOS and Windows; no Node/Python runtime | npm CLI@scrapecreators/cli |
| MCP and agent skills | Yes | Yes |
| Continue from data to hosted media delivery | YesYouTube Download to your storage; separate permission and GB-based pricing | Separate downloader workflowYouTube metadata and transcript APIs do not deliver media files |
Both offer prepaid access, MCP, a CLI and agent skills. ScrapeCreators also covers other social platforms and YouTube endpoints such as comments. Its supported cache hits are free; the calculator includes them.
Refresh the videos you care about
Lower per-request usage rates matter when you refresh changing metrics or collect captions for new videos. Keep saved transcripts and request metadata only when it needs updating.
Start with a smaller purchase
FlashData credit top-ups start at $10. Move one YouTube workload first, while your existing integration continues to handle comments and other social platforms.
Choose the exact caption track
Select uploader-provided or YouTube-generated captions explicitly. Request up to 10 existing languages in one transcript request and handle each language’s result separately.
02 · Pay for the calls you actually make
Compare fresh requests, cached results and upfront purchases.
Choose a FlashData plan and a ScrapeCreators prepaid pack. A metadata lookup and a caption request use one credit each on ScrapeCreators when served live. Fetching both requires two requests with either provider.
Metadata and one existing caption track are two requests on both sides.
Use 0 when you already have the video IDs.
Observed free hits, up to 2,000. Search hits are not included.
2,000 FlashData requests · 2,000 ScrapeCreators billable credits after 0 free cache hits.
FlashData · Pay As You Go
$0.50per 1,000 standard requests
- Monthly fee
- $0.00
- Included requests / month
- 0
- Value of this month’s API usage
- $1.00
- Usage above included balance
- $1.00
- Fee + usage above allowance
- $1.00
- Purchase from zero balance
- $10.00
Monthly plans share their included balance with other APIs. Additional credit purchases start at $10.
ScrapeCreators · Freelance
$1.88per 1,000 fresh one-credit requests
- Monthly fee
- $0.00
- Requests per prepaid pack
- 25,000
- One pack purchase
- $47.00
- Value of this month’s API usage
- $3.76
- Purchase from zero balance
- $47.00 · 1 pack
- Purchased credits left after task
- 23,000
No monthly pack renewal. Cached metadata and caption responses entered above use zero credits.
How the estimate works
USD, one month of requests. One fresh metadata lookup, native-caption result or standard search request uses one ScrapeCreators credit. Metadata plus captions uses two requests on both sides. Only metadata/transcript cache hits entered above are deducted; search caching is not assumed. This model counts returned captions, not missing-track attempts, and excludes AI generation. FlashData uses its current standard YouTube Data prices, allocating the entire selected plan allowance before extra usage. Extended Search and Download are priced separately. Starting balances, trials, bonus credits, taxes and other usage are excluded. Purchases start from zero balance: FlashData top-ups have a $10 minimum; ScrapeCreators purchases round up to whole selected packs. Unused purchased credits can serve later tasks. ScrapeCreators has no monthly pack renewal; a selected FlashData monthly plan still has its fee at zero requests.
ScrapeCreators sells packs, not monthly allowances.
| ScrapeCreators offer | One-time purchase | Credits | Per 1,000 fresh one-credit calls | Monthly fee |
|---|---|---|---|---|
| Initial free offer | $0 | 100 once | Free starting allowance | $0 |
| Freelance | $47.00 | 25,000 | $1.88 | $0 |
| Business | $497.00 | 500,000 | $0.994 | $0 |
| Enterprise | Custom | 1,000,000+ | Custom | $0 for prepaid credits |
Pricing reviewed 2026-11-10. Business works out to $0.994 per 1,000 one-credit calls; its displayed $0.99 rate is rounded. Purchased credits have no expiry under the current policy. Initial and earned bonus credits are excluded from the calculator.
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 |
The included-request count allocates the full shared plan balance to standard YouTube Data requests. Extended Search and Download have separate rates.
Full YouTube Data pricing →What changes when you use cached responses?
For supported ScrapeCreators metadata and transcript endpoints, cache_max_age accepts 1d, 3d, 7d, 14d or 30d. A matching cache hit costs zero credits and reports cached_at; a miss uses the normal endpoint rate. Search caching is not assumed here.
Enter observed hits, not an assumed discount on every request. Decide whether a saved transcript is reusable and whether view counts need refreshing. The example below saves responses locally so another task can reuse them without another API call.
Save and reuse results →Free access before a paid purchase
ScrapeCreators starts with 100 free credits. Eligible verified FlashData signups can receive an initial allowance of up to 4,000 standard YouTube Data requests. These starting offers do not reset monthly. FlashData’s separate temporary agent trial is described below.
03 · Preserve the fields your app reads
Migrate one video, including its caption timestamps.
Change the request and response adapter first. Keep comments and other social-platform calls on their existing path.
1 Set up access and choose the track
Create or reuse a key with youtube_transcript and, for metadata, youtube_metadata permission in API Keys. Check available credits. Agents can reuse access or start an eligible trial.
# Existing call, for mapping only; reuse your saved key.
curl --get --fail-with-body --silent --show-error \
'https://api.scrapecreators.com/v1/youtube/video/transcript' \
--header "x-api-key: $SCRAPECREATORS_API_KEY" \
--data-urlencode 'url=https://www.youtube.com/watch?v=FUfGcZ092b0' \
--data-urlencode 'language=en'{
"source": "youtube_transcript",
"video_id": "FUfGcZ092b0",
"params": {
"language": "en",
"auto": true
}
}original_audio=true chooses the spoken language. FlashData’s params.auto=true chooses YouTube-generated captions. They are different controls: specify the language and origin your application wants.
2 Save the script, then run the first task
Requires Python 3.10+. Install the dependency with python -m pip install requests. Save the complete script below as creator-research.py in a new working folder. It reads FLASHDATA_API_KEY from the environment or a hidden prompt.
import argparse
import getpass
import json
import math
import os
import re
from pathlib import Path
import requests
parser = argparse.ArgumentParser()
parser.add_argument("operation", choices=["transcript", "metadata"])
parser.add_argument("video_id")
parser.add_argument("folder", type=Path)
parser.add_argument("--language", default="en")
parser.add_argument("--origin", choices=["auto", "manual"], default="auto")
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")
source = "youtube_" + args.operation
params = ({"language": args.language, "auto": args.origin == "auto"}
if args.operation == "transcript"
else {"include_formats": False, "include_chapters": True})
body = {"source": source, "video_id": args.video_id, "params": params}
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_request = 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_request != 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") != source:
raise SystemExit("Request did not complete successfully; inspect response.json")
results = data.get("results")
if not isinstance(results, list) or len(results) != 1 or not isinstance(results[0], dict):
raise SystemExit("Expected one result; inspect response.json")
item = results[0]
if item.get("videoId") != args.video_id:
raise SystemExit("Returned video does not match the request")
if args.operation == "transcript":
allowed = {args.language}
if args.origin == "auto" and not args.language.endswith("-orig"):
allowed.add(args.language + "-orig")
if item.get("languageCode") not in allowed or item.get("isAutoGenerated") is not params["auto"]:
raise SystemExit("Returned caption language or origin does not match")
if not isinstance(item.get("segments"), list):
raise SystemExit("Expected caption segments")
transcript = []
for cue in item["segments"]:
if not isinstance(cue, dict):
raise SystemExit("Invalid caption segment")
start, end, text = cue.get("start"), cue.get("end"), cue.get("text")
if (type(start) not in (int, float) or type(end) not in (int, float)
or not math.isfinite(start) or not math.isfinite(end)
or start < 0 or end < start or not isinstance(text, str)):
raise SystemExit("Invalid caption segment")
transcript.append({"text": text,
"startMs": str(math.floor(start * 1000 + 0.5)),
"endMs": str(math.floor(end * 1000 + 0.5)),
"startTimeText": f"{int(start) // 60}:{int(start) % 60:02d}"})
normalized = {"videoId": item["videoId"],
"url": "https://www.youtube.com/watch?v=" + item["videoId"],
"transcript": transcript, "transcript_only_text": item.get("fullText"),
"language": item.get("languageName"), "languageCode": item["languageCode"],
"isAutoGenerated": item["isAutoGenerated"]}
else:
duration = item.get("duration")
if duration is not None and (type(duration) not in (int, float)
or not math.isfinite(duration) or duration < 0):
raise SystemExit("Invalid video duration")
normalized = {"id": item["videoId"], "title": item.get("title"),
"url": "https://www.youtube.com/watch?v=" + item["videoId"],
"description": item.get("description"),
"viewCountInt": item.get("viewCount"), "likeCountInt": item.get("likeCount"),
"commentCountInt": item.get("commentCount"),
"durationMs": None if duration is None else math.floor(duration * 1000 + 0.5),
"channel": {"id": item.get("channelId"), "title": item.get("channel")},
"uploadDateRaw": item.get("uploadDate")}
(out / "normalized.json").write_text(
json.dumps(normalized, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
)
print(f"Saved {out}/normalized.json; actual usage: {json.dumps(data.get('usage'))}")
Run from the folder containing the script. Choose a public video with an existing English track. These commands use YouTube-generated captions; choose --origin manual in Python or append en manual in Bash for uploader-provided captions.
python creator-research.py transcript FUfGcZ092b0 captions-001For a research card, fetch metadata separately. On a temporary trial, wait at least one second between requests.
python creator-research.py metadata FUfGcZ092b0 metadata-001Each new output folder submits one request. Rerunning with the same arguments reads saved output. For an intentional refresh, use a new folder after checking the previous attempt.
3 Read the mapped output and actual usage
captions-001/normalized.json contains a small adapter for familiar transcript fields. response.json retains the full FlashData response and actual usage.
The adapter converts seconds to string milliseconds and retains language and origin. It does not create ScrapeCreators credit balances, cache flags or a complete drop-in response. Metadata output preserves missing metrics as null and stores the unparsed date in uploadDateRaw.
{
"videoId": "FUfGcZ092b0",
"url": "https://www.youtube.com/watch?v=FUfGcZ092b0",
"transcript": [
{
"text": "Example caption text.",
"startMs": "1250",
"endMs": "3500",
"startTimeText": "0:01"
}
],
"transcript_only_text": "Example caption text.",
"language": "English",
"languageCode": "en-orig",
"isAutoGenerated": true
}| ScrapeCreators integration | FlashData change |
|---|---|
| GET /v1/youtube/video?url=… | POST the query API with source: youtube_metadata and video_id. Read results[0], not the response root. |
| GET /v1/youtube/video/transcript?url=… | Use source: youtube_transcript. Set params.language and params.auto explicitly. |
| transcript[].startMs / endMs | FlashData start / end are seconds. Multiply each by 1,000 and serialize as strings for an existing millisecond reader. |
| original_audio=true | Selects the spoken language in ScrapeCreators, not auto-generated captions. Resolve the required language in your app; params.auto selects caption origin instead. |
| language and transcript_only_text | Map languageName and fullText. Keep languageCode separately; a language name and a language code are different fields. |
| viewCountInt, likeCountInt, commentCountInt | Map viewCount, likeCount, commentCount. Preserve null when a metric is absent. |
| durationMs and publishDate | Convert duration seconds to milliseconds. Preserve uploadDate as a raw field until your app validates the date format it needs. |
| channel / uploader / ownerByline | FlashData channel and channelId do not reproduce all three identities. Map only fields your reader needs; keep a separate path for music-credit attribution. |
| cached, cached_at, credits_charged | Keep the FlashData raw response and usage. Record your own fetch time; do not manufacture provider cache flags or translate credit balances between providers. |
If the first request fails
- 401 / 403: check the saved key and its source permission. Stop the runner if access was revoked.
- 402: check the owner’s balance before resuming.
- 429: read the saved Retry-After header and reduce request frequency. Temporary trials allow one request per second.
- Missing track: check the available language and origin. A successful ScrapeCreators response with a null transcript is not the same as a completed FlashData track.
- Timeout or incomplete folder: inspect History and saved output before retrying. The scripts keep the attempt and never automatically resubmit it.
04 · Discovery, enrichment and reuse
Find → shortlist → enrich → cite.
A research task rarely needs full metadata and captions for every search result. Filter first, then pay for the videos that make it into the answer.
| Step | Work | Request count |
|---|---|---|
| Discover | Run P YouTube Search requests | P standard search requests. Count actual requests, not every returned video as a separate search. |
| Select | Deduplicate and shortlist N video IDs | Local filtering; no metadata or caption request yet. |
| Enrich | Fetch metadata for the shortlisted IDs | N metadata requests; repeat only when metrics need refreshing. |
| Cite | Fetch one existing caption track per ID | N transcript requests when available. Store language, origin and cue timings with the source URL. |
| Reuse | Read saved results for the next task | No provider request when your app can reuse its own saved file. |
For 10 search requests and 50 shortlisted videos with metadata plus captions, budget 110 standard requests. The calculator separates discovery requests from per-video enrichment. Cached or locally reused results change the work you need to submit.
Search is not a drop-in cursor migration
ScrapeCreators can return several result types with continuationToken. FlashData’s standard search returns video results; its Extended Search has separate limits and pricing. Start a new discovery run instead of reusing an old cursor.
YouTube Search reference →Keep evidence with the answer
Store the video ID, URL, chosen language, caption origin and segment start time. A citation link can point to that timestamp. Do not label a missing caption track as an empty successful transcript.
Timestamped captions recipe →Scale the ID list separately
After one lookup works, use batch requests for a list or bulk processing for a file. Track job IDs, save completed outputs and retry only failed items. Keep your runner responsible for the schedule.
Bulk processing reference →05 · Coding and personal agents
Prove the migration before scheduling it.
Eligible agents can start with 1 credit (up to 100 standard YouTube Data requests) for 72 hours. Metadata, captions and search share the allowance. Reuse saved access first.
- Inspect the current integration.
Record required fields, caption intent and cache freshness. Keep unrelated social-data calls.
- Run one known video.
Use the CLI, SDK or MCP. Save raw output and verify the field adapter.
- 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 saved credential.
Run recurring tasks from one persistent profile. Save outputs and stop on revocation or insufficient balance.
Migrate only this app's YouTube metadata and native-caption calls to FlashData.
Read https://flashdata.dev/auth.md and https://flashdata.dev/agents.md first.
Reuse saved access; start an eligible trial only if needed. Keep credentials out of chat.
Inspect our current fields, language choice, original_audio behavior and cache freshness requirements.
Keep comments, other social platforms and unsupported fields on their existing path.
Run one known video with explicit language and caption origin. Save the raw response and usage.
Map timestamps from seconds to string milliseconds; preserve null counts and missing-track errors.
Reuse saved output before requesting it again. Do not retry an uncertain submission automatically.
Before recurring use, ask the owner to claim access and approve permissions and shared-balance use.
Persist the resulting credential and stop on revocation or insufficient balance.06 · Migration questions
Before you switch
Are these monthly subscriptions?
ScrapeCreators Freelance and Business are prepaid packs, not subscriptions. Both have a $0 monthly fee. FlashData has pay-as-you-go credits plus optional monthly plans. Compare consumed usage and the purchase needed from your current balance separately.
What if most of my ScrapeCreators requests are cached?
Supported metadata and transcript cache hits cost zero credits. Enter those observed hits in the calculator. If your app accepts their age, they can cost less than new FlashData requests. You can also save either provider’s output locally and avoid making the next request altogether.
Do unused credits expire?
ScrapeCreators says purchased credits do not expire under its current policy. Its free 100-credit starting offer is not a monthly refill. FlashData’s temporary agent trial expires; its pricing and account pages describe the applicable owner-balance terms.
Will original_audio=true work as params.auto=true?
No. The first chooses a language based on the spoken audio; the second chooses YouTube-generated captions. Set a language and origin deliberately. Neither service’s native-caption endpoint creates speech-to-text when a matching track is absent.
Can I replace all my social-data calls?
This migration covers YouTube video metadata and existing captions. Keep comments, community posts, social profiles and any other unsupported response fields on their existing path. FlashData also offers Google Search and hosted YouTube Download, with their own permissions and pricing.
Does ScrapeCreators also support AI agents?
Yes. It offers MCP, OAuth, a CLI and agent skills. FlashData’s agent flow adds an eligible temporary trial, owner claiming and saved credentials for continued use. Choose the API and workflow your task needs; MCP support alone is not the difference.
Start with one useful video
Build your next research task with FlashData.
Save the metadata, preserve the caption timings and reuse the result.