Skip to content
EN
Get API key

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.

Read as Markdown

01 · For video apps and agents

Feature-by-feature comparison

Focus on the cost and controls behind a YouTube research workflow.

Feature-by-feature comparison: FlashData and ScrapeCreators
FeatureFlashDataScrapeCreators
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 purchaseFrom $10$4725,000-credit Freelance pack
Pay as you go without a monthly feeYesYes
Find videos and refresh the facts you need
Find videos by keyword and filtersYesDate, duration, type and sorting filtersYesSearch filters and continuation-token pagination
Metadata for a known videoYesTitle, channel, duration, thumbnails and engagement countsYesVideo/Short Details endpoint
Chapter markers for navigationYesinclude_chapters; titles with start/end times when presentYeschapters in the video response when present
Discover available caption tracksMetadata language listhasTranscripts and transcriptLanguagesMetadata captionTracksLanguage codes and track details
Keep caption selection and evidence explicit
Text and timestamps from the same responseFull text + timed segmentsStart/end times in secondsFull text + timed segmentsstartMs/endMs as millisecond strings
Several caption languages in one requestUp to 10 languagesExisting tracks plus per-language errorsOne selected languagelanguage or original_audio selection per transcript call
Choose caption origin explicitlyUploader or YouTube-generatedparams.auto selects one originLanguage and spoken-audio selectionoriginal_audio is not a caption-origin switch
Missing-caption handlingExisting tracks and explicit errorsLanguage arrays preserve successful tracks and report missing selectionsNull transcript fieldsMissing requested tracks cost zero credits; no YouTube AI transcription
Choose how old reused data may beCache policy in your applicationSave retrieval times and decide when to fetch againcache_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 IDsManaged bulk jobsSubmit the file, track its job and retrieve outputsPer-video endpoint callsManage the file loop and result storage in your integration
Move long collections into background jobsAsync, Batch and Bulk APIsPersist job IDs, track status and retrieve resultsSynchronous YouTube callsQueue and checkpoint per-video calls in your worker
Structured and readable outputJSON, plain text or MarkdownSelected through API response headersJSON API and CLI formatsCLI also exports CSV, tables and Markdown
Terminal installationStandalone executableLinux, macOS and Windows; no Node/Python runtimenpm CLI@scrapecreators/cli
MCP and agent skillsYesYes
Continue from data to hosted media deliveryYesYouTube Download to your storage; separate permission and GB-based pricingSeparate 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 prepaid pricing
ScrapeCreators offerOne-time purchaseCreditsPer 1,000 fresh one-credit callsMonthly fee
Initial free offer$0100 onceFree starting allowance$0
Freelance$47.0025,000$1.88$0
Business$497.00500,000$0.994$0
EnterpriseCustom1,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 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

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.

ScrapeCreators call · reference only
# 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'
FlashData · POST /v1/queries/realtime
{
  "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.

creator-research.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("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.

Fetch one caption track
python creator-research.py transcript FUfGcZ092b0 captions-001

For a research card, fetch metadata separately. On a temporary trial, wait at least one second between requests.

Optional metadata lookup
python creator-research.py metadata FUfGcZ092b0 metadata-001

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

Transcript schema →
Illustrative captions-001/normalized.json
{
  "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
}
Request and response migration map
ScrapeCreators integrationFlashData 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 / endMsFlashData start / end are seconds. Multiply each by 1,000 and serialize as strings for an existing millisecond reader.
original_audio=trueSelects 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_textMap languageName and fullText. Keep languageCode separately; a language name and a language code are different fields.
viewCountInt, likeCountInt, commentCountIntMap viewCount, likeCount, commentCount. Preserve null when a metric is absent.
durationMs and publishDateConvert duration seconds to milliseconds. Preserve uploadDate as a raw field until your app validates the date format it needs.
channel / uploader / ownerBylineFlashData 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_chargedKeep 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.
Errors and status codes →

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.

Budget a complete YouTube research task
StepWorkRequest count
DiscoverRun P YouTube Search requestsP standard search requests. Count actual requests, not every returned video as a separate search.
SelectDeduplicate and shortlist N video IDsLocal filtering; no metadata or caption request yet.
EnrichFetch metadata for the shortlisted IDsN metadata requests; repeat only when metrics need refreshing.
CiteFetch one existing caption track per IDN transcript requests when available. Store language, origin and cue timings with the source URL.
ReuseRead saved results for the next taskNo 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.

  1. Inspect the current integration.

    Record required fields, caption intent and cache freshness. Keep unrelated social-data calls.

  2. Run one known video.

    Use the CLI, SDK or MCP. Save raw output and verify the field adapter.

  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 saved credential.

    Run recurring tasks from one persistent profile. Save outputs and stop on revocation or insufficient balance.

Give this task to your agent
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.