# ScrapeCreators Alternative for YouTube Data

Compare YouTube metadata and caption costs, prepaid packs and cache hits. Migrate to FlashData with runnable Python and Bash field adapters for apps and agents.

Fresh video data. A smaller starting spend. Move YouTube metadata and caption calls while keeping the rest of your social-data integration.

ScrapeCreators facts reviewed 2026-11-10. FlashData prices and trial allowances come from its current public catalogs.

- [Features](#features)
- [Pricing & cache](#costs)
- [Migrate a request](#migration)
- [Research workflow](#workflow)
- [For AI agents](#agents)
- [FAQ](#faq)

<a id="features"></a>
## Feature-by-feature comparison

### Lower the cost of fresh YouTube data

| Feature | FlashData | ScrapeCreators |
| --- | --- | --- |
| Entry paid rate / 1,000 metadata or caption calls | $0.50 — Pay-as-you-go usage | $1.88 — Freelance · fresh one-credit calls |
| Lowest listed unit rate / 1,000 calls | $0.20 — Optional monthly plan; its fee still applies | $0.994 — Business · $497 prepaid pack; custom Enterprise excluded |
| First paid credit purchase | From $10 | $47 — 25,000-credit Freelance pack |
| Pay as you go without a monthly fee | Yes | Yes |

### Find videos and refresh the facts you need

| Feature | FlashData | ScrapeCreators |
| --- | --- | --- |
| Find videos by keyword and filters | Yes — Date, duration, type and sorting filters | Yes — Search filters and continuation-token pagination |
| Metadata for a known video | Yes — Title, channel, duration, thumbnails and engagement counts | Yes — Video/Short Details endpoint |
| Chapter markers for navigation | Yes — include_chapters; titles with start/end times when present | Yes — chapters in the video response when present |
| Discover available caption tracks | Metadata language list — hasTranscripts and transcriptLanguages | Metadata captionTracks — Language codes and track details |

### Keep caption selection and evidence explicit

| Feature | FlashData | ScrapeCreators |
| --- | --- | --- |
| Text and timestamps from the same response | Full text + timed segments — Start/end times in seconds | Full text + timed segments — startMs/endMs as millisecond strings |
| Several caption languages in one request | Up to 10 languages — Existing tracks plus per-language errors | One selected language — language or original_audio selection per transcript call |
| Choose caption origin explicitly | Uploader or YouTube-generated — params.auto selects one origin | Language and spoken-audio selection — original_audio is not a caption-origin switch |
| Missing-caption handling | Existing tracks and explicit errors — Language arrays preserve successful tracks and report missing selections | Null transcript fields — Missing requested tracks cost zero credits; no YouTube AI transcription |
| Choose how old reused data may be | Cache policy in your application — Save retrieval times and decide when to fetch again | cache_max_age — 1–30-day options; cache hits cost zero credits and expose cached_at |

### Run a repeatable data workflow

| Feature | FlashData | ScrapeCreators |
| --- | --- | --- |
| Process a saved file of video IDs | Managed bulk jobs — Submit the file, track its job and retrieve outputs | Per-video endpoint calls — Manage the file loop and result storage in your integration |
| Move long collections into background jobs | Async, Batch and Bulk APIs — Persist job IDs, track status and retrieve results | Synchronous YouTube calls — Queue and checkpoint per-video calls in your worker |
| Structured and readable output | JSON, plain text or Markdown — Selected through API response headers | JSON API and CLI formats — CLI also exports CSV, tables and Markdown |
| Terminal installation | Standalone executable — Linux, macOS and Windows; no Node/Python runtime | npm CLI — @scrapecreators/cli |
| MCP and agent skills | Yes | Yes |
| Continue from data to hosted media delivery | Yes — YouTube Download to your storage; separate permission and GB-based pricing | Separate downloader workflow — YouTube 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 comments. Supported cache hits are free.

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

<a id="costs"></a>
## Compare fresh requests, cache hits and upfront purchases

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

These are prepaid packs with no monthly renewal. Business is exactly $0.994 per 1,000 one-credit calls; $0.99 is rounded. Purchased credits have no expiry under the current policy. Initial and earned bonus credits are excluded from the model.

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

FlashData included-request counts allocate the full shared balance to standard YouTube Data. Extended Search and Download have separate rates. [Full pricing](https://flashdata.dev/pricing/youtube-data).

### Example: metadata and captions for 1,000 videos

2,000 requests, no discovery searches. FlashData pay as you go vs ScrapeCreators Freelance. Count observed cache hits only; requests avoided through your own local storage are not submitted to either provider.

| Free cache hits | FlashData calls | FlashData usage | FlashData purchase | ScrapeCreators credits | ScrapeCreators usage value | ScrapeCreators purchase |
| --- | --- | --- | --- | --- | --- | --- |
| 0 | 2,000 | $1.00 | $10.00 | 2,000 | $3.76 | $47.00 |
| 1,000 | 2,000 | $1.00 | $10.00 | 1,000 | $1.88 | $47.00 |
| 2,000 | 2,000 | $1.00 | $10.00 | 0 | $0.00 | $0.00 |

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.

### Cache behavior

On supported metadata/transcript endpoints, cache_max_age accepts 1d, 3d, 7d, 14d or 30d. Hits use zero credits and report cached_at; misses use the normal rate. Search cache hits are not assumed. Decide whether the saved data is recent enough for the task. [Save and reuse results](https://flashdata.dev/docs/guides/save-results/reference.md).

### Starting offers

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 offers do not reset monthly. The separate temporary agent trial appears below.

<a id="migration"></a>
## Migrate one video and its caption timestamps

### 1. Set up access and choose the track

Create or reuse a key with youtube_transcript permission, plus youtube_metadata for the optional metadata call. [API Keys](https://flashdata.dev/app/api-keys) · [Credits](https://flashdata.dev/app/billing). Store FLASHDATA_API_KEY in the environment or use the script’s hidden prompt; never paste it into chat.

Existing request, for mapping only:

```bash
# 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 https://data.flashdata.dev/v1/queries/realtime with X-API-Key and this JSON body:

```json
{
  "source": "youtube_transcript",
  "video_id": "FUfGcZ092b0",
  "params": {
    "language": "en",
    "auto": true
  }
}
```

original_audio=true chooses spoken language. FlashData params.auto=true selects YouTube-generated captions. Specify language and origin separately.

### 2. Save the script before running it

Python 3.10+: install with python -m pip install requests. Save the complete script below as creator-research.py in a new working folder.

```python
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 that folder using a video with an existing English track. Metadata is a separate optional request; on a temporary trial, leave at least one second between calls.

```bash
python creator-research.py transcript FUfGcZ092b0 captions-001
# Optional metadata, run separately:
python creator-research.py metadata FUfGcZ092b0 metadata-001
```

For uploader-provided captions append --origin manual. The default is YouTube-generated English captions.

Alternatively, use Bash, cURL 7.76+ and jq 1.6+. Save the complete script below as creator-research.sh in a new working folder.

```bash
#!/usr/bin/env bash
set -euo pipefail
operation="${1:?Use: transcript|metadata VIDEO_ID OUTPUT_FOLDER [LANGUAGE] [auto|manual]}"
video_id="${2:?Set VIDEO_ID}"
out="${3:?Set OUTPUT_FOLDER}"
language="${4:-en}"
origin="${5:-auto}"
[[ "$operation" == transcript || "$operation" == metadata ]] || exit 1
[[ "$video_id" =~ ^[A-Za-z0-9_-]{11}$ ]] || exit 1
[[ "$origin" == auto || "$origin" == manual ]] || exit 1
body=$(jq -n --arg source "youtube_$operation" --arg id "$video_id" \
  --arg language "$language" --arg origin "$origin" '
  {source: $source, video_id: $id, params:
    (if $source == "youtube_transcript" then {language: $language, auto: ($origin == "auto")}
     else {include_formats: false, include_chapters: true} end)}')
if [[ ! -e "$out" ]]; then
  if [[ -z "${FLASHDATA_API_KEY:-}" ]]; then
    read -r -s -p 'FlashData API key: ' FLASHDATA_API_KEY; printf '\n'
  fi
  : "${FLASHDATA_API_KEY:?An API key is required}"
  mkdir -p -- "$out"
  printf '%s\n' "$body" > "$out/request.json"
  curl --fail-with-body --silent --show-error --max-time 120 \
    --request POST 'https://data.flashdata.dev/v1/queries/realtime' \
    --header "X-API-Key: $FLASHDATA_API_KEY" \
    --header 'Content-Type: application/json' --header 'Accept: application/json' \
    --data-binary "@$out/request.json" --output "$out/response.json" \
    --dump-header "$out/response-headers.txt" --write-out '%{http_code}' \
    > "$out/http-status.txt" || {
      printf 'Request failed. Keep the output folder and inspect History before retrying.\n' >&2
      exit 1
    }
else
  printf 'Reading saved output; no API call.\n'
fi
jq -e --argjson expected "$body" '. == $expected' "$out/request.json" >/dev/null
[[ "$(cat "$out/http-status.txt")" == 200 ]] || {
  printf 'Inspect the saved HTTP status, response and Retry-After header.\n' >&2; exit 1;
}
normalized=$(jq -e --argjson request "$body" '
  if .source != $request.source or .status != "done" then error("Request not done") else . end
  | .results | if type != "array" then error("Expected results")
    elif length != 1 then error("Expected one result") else .[0] end
  | if .videoId != $request.video_id then error("Wrong video") else . end
  | if $request.source == "youtube_metadata" then
      if .duration == null then .
      elif (.duration | type) != "number" then error("Invalid video duration")
      elif (.duration | isfinite | not) or .duration < 0 then error("Invalid video duration") else . end
      | {id: .videoId, title, url: ("https://www.youtube.com/watch?v=" + .videoId), description,
         viewCountInt: .viewCount, likeCountInt: .likeCount, commentCountInt: .commentCount,
         durationMs: (if .duration == null then null else (.duration * 1000 | round) end),
         channel: {id: .channelId, title: .channel}, uploadDateRaw: .uploadDate}
    else
      if (.languageCode != $request.params.language and
          ($request.params.auto != true or ($request.params.language | endswith("-orig")) or
           .languageCode != ($request.params.language + "-orig"))) or
          .isAutoGenerated != $request.params.auto then error("Wrong language or origin") else . end
      | if (.segments | type) != "array" then error("Expected caption segments") else . end
      | {videoId, url: ("https://www.youtube.com/watch?v=" + .videoId),
         transcript_only_text: .fullText, language: .languageName, languageCode, isAutoGenerated,
         transcript: [.segments[] |
          if (.start | type) != "number" or (.end | type) != "number" or (.text | type) != "string"
          then error("Invalid caption segment")
          elif (.start | isfinite | not) or (.end | isfinite | not) or .start < 0 or .end < .start
          then error("Invalid caption timing")
          else {text, startMs: (.start * 1000 | round | tostring), endMs: (.end * 1000 | round | tostring),
            startTimeText: (((.start / 60 | floor) | tostring) + ":" +
              ((.start | floor) % 60 | if . < 10 then "0" + tostring else tostring end))} end]}
    end' "$out/response.json")
printf '%s\n' "$normalized" > "$out/normalized.json"
printf 'Saved %s/normalized.json; actual usage: ' "$out"
jq -c '.usage' "$out/response.json"

```

```bash
bash creator-research.sh transcript FUfGcZ092b0 captions-001
# Optional metadata, run separately:
bash creator-research.sh metadata FUfGcZ092b0 metadata-001
```

For uploader-provided captions append en manual. Each new output folder submits one request. The same arguments and folder reuse saved output; use a new folder for an intentional refresh after inspecting the previous attempt.

### 3. Read mapped output and actual usage

captions-001/normalized.json is a field adapter; response.json retains the raw response and actual usage. Seconds become string milliseconds. languageCode and isAutoGenerated preserve the selected track. This is not a complete drop-in response: no manufactured credit balances, cache flags, uploader attribution or date fields. Metadata preserves missing metrics as null and its original date as uploadDateRaw.

```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
}
```

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

[Transcript schema](https://flashdata.dev/docs/sources/youtube_transcript/reference.md) · [Metadata schema](https://flashdata.dev/docs/sources/youtube_metadata/reference.md)

### If the first request fails

- 401/403: check the saved key and source permission; stop if revoked.
- 402: replenish the owner balance before resuming.
- 429: read the saved Retry-After header; reduce request frequency. Temporary trials allow one request per second.
- Missing track: verify available language and origin. ScrapeCreators can return a successful response with a null transcript; do not confuse this with a completed FlashData track.
- Timeout or incomplete folder: inspect History and output before retrying. Scripts preserve the attempt without automatic resubmission.

[Errors and status codes](https://flashdata.dev/docs/errors/reference.md)

<a id="workflow"></a>
## Find → shortlist → enrich → cite

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

10 search requests plus 50 shortlisted videos with metadata and captions require 110 standard requests before local reuse. Separate discovery costs from enrichment. A search result is not itself a separate search request.

### 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](https://flashdata.dev/docs/sources/youtube_search/reference.md)

### 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](https://flashdata.dev/docs/guides/timestamped-captions-recipe/reference.md)

### 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](https://flashdata.dev/docs/reference/bulk-processing/reference.md)

<a id="agents"></a>
## 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.

1. Inspect required fields, caption intent and freshness. Reuse saved access; keep unrelated social-data calls.
2. Run one known video using CLI, SDK or MCP. Save output and check timing, nulls and actual usage.
3. The owner signs in or signs up, verifies email and approves claiming, scopes and shared-balance use. Unused trial credits do not transfer.
4. Persist the owner credential for recurring use. Reuse outputs and stop on revocation or insufficient balance.

```text
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.
```

[Trial and claiming](https://flashdata.dev/docs/guides/agent-onboarding/reference.md) · [Standalone CLI](https://flashdata.dev/docs/guides/flashdata-cli/reference.md) · [MCP setup](https://flashdata.dev/docs/integrations/mcp-clients/reference.md)

<a id="faq"></a>
## 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.
