# ScrapeCreators Alternativa a YouTube Dati

Confronta YouTube costi di metadati e didascalie, pacchetti prepagati e riscontri nella cache. Migrazione a FlashData con adattatori di campo eseguibili Python e Bash per app e agenti.

Dati video freschi. Una spesa iniziale inferiore. Sposta YouTube metadati e chiamate didascalie mantenendo il resto dell'integrazione dei dati social.

I fatti ScrapeCreators hanno recensito 2026-11-10. I prezzi e le indennità di prova FlashData provengono dai suoi attuali cataloghi pubblici.

- [Caratteristiche](#features)
- [Prezzi e cache](#costs)
- [Migrare una richiesta](#migration)
- [Flusso di lavoro della ricerca](#workflow)
- [Per gli agenti IA](#agents)
- [Domande frequenti](#faq)

<a id="features"></a>
## Confronto delle funzionalità

### Riduci il costo dei dati freschi di YouTube

| Caratteristica | FlashData | ScrapeCreators |
| --- | --- | --- |
| Tariffa di ingresso pagata / 1,000 metadati o chiamate didascalie | $0.50 — Utilizzo a consumo | $1.88 — Freelance · nuove chiamate a un credito |
| Tariffa unitaria elencata più bassa / 1,000 chiamate | $0.20 — Piano mensile opzionale; la sua tariffa è ancora valida | $0.994 — Business · $497 pacchetto prepagato; Enterprise personalizzata esclusa |
| Primo acquisto di credito pagato | Da $10 | $47 — Pacchetto da 25,000 crediti Freelance |
| Paga in base al consumo senza canone mensile | Sì | Sì |

### Trova video e aggiorna i fatti di cui hai bisogno

| Caratteristica | FlashData | ScrapeCreators |
| --- | --- | --- |
| Trova video per parola chiave e filtri | Sì — Data, durata, tipologia e filtri di ordinamento | Sì — Filtri di ricerca e impaginazione dei token di continuazione |
| Metadati per un video noto | Sì — Titolo, canale, durata, miniature e conteggio del coinvolgimento | Sì — Video/Short Dettagli endpoint |
| Indicatori di capitolo per la navigazione | Sì — include_chapters; titoli con orari di inizio/end quando presenti | Sì — capitoli nel video di risposta quando presente |
| Scopri le tracce di sottotitoli disponibili | Elenco delle lingue dei metadati — hasTranscripts e transcriptLanguages | Metadati captionTracks — Codici della lingua e dettagli della traccia |

### Mantieni la selezione e le prove delle didascalie esplicite

| Caratteristica | FlashData | ScrapeCreators |
| --- | --- | --- |
| Testo e timestamp dalla stessa risposta | Testo completo + segmenti temporizzati — Start/end volte in secondi | Testo completo + segmenti temporizzati — startMs/endMs come stringhe di millisecondo |
| Diverse lingue dei sottotitoli in un'unica richiesta | Fino a 10 lingue — Tracce esistenti più errori per lingua | Una lingua selezionata — lingua o selezione di original_audio per chiamata di trascrizione |
| Scegli esplicitamente l'origine della didascalia | Uploader o YouTube generato — params.auto seleziona un'origine | Selezione della lingua e dell'audio parlato — original_audio non è un cambio di origine dei sottotitoli |
| Gestione delle didascalie mancanti | Tracce esistenti ed errori espliciti — Gli array linguistici preservano le tracce riuscite e segnalano le selezioni mancanti | Campi di trascrizione nulli — Le tracce richieste mancanti costano zero crediti; nessuna trascrizione YouTube AI |
| Scegli quanti anni possono avere i dati riutilizzati | Criterio cache nell'applicazione — Risparmia i tempi di recupero e decidi quando recuperarli nuovamente | cache_max_age — opzioni da 1–30 giorni; i risultati della cache costano zero crediti ed espongono cached_at |

### Esegui un flusso di lavoro di dati ripetibile

| Caratteristica | FlashData | ScrapeCreators |
| --- | --- | --- |
| Elabora un file video salvato IDs | Lavori in blocco gestiti — Invia il file, monitora il suo lavoro e recupera gli output | Chiamate endpoint per video — Gestisci il loop dei file e l'archiviazione dei risultati nella tua integrazione |
| Sposta raccolte lunghe in processi in background | API asincrone, batch e in blocco — Mantieni il lavoro IDs, monitora lo stato e recupera i risultati | Chiamate sincrone YouTube — Queue e checkpoint per-video chiamate nel vostro lavoratore |
| Output strutturato e leggibile | JSON, testo semplice o Markdown — Selezionato tramite API intestazioni di risposta | Formati JSON API e CLI — CLI esporta anche CSV, tabelle e Markdown |
| Installazione del terminale | Eseguibile autonomo — Linux, macOS e Windows; nessun runtime del Node/Python | npm CLI — @scrapecreators/cli |
| MCP e abilità dell'agente | Sì | Sì |
| Continua dai dati alla distribuzione multimediale ospitata | Sì — YouTube Scarica nella tua memoria; autorizzazione separata e prezzi basati su GB | Flusso di lavoro del downloader separato — YouTube metadati e API di trascrizione non forniscono file multimediali |

Entrambi offrono accesso prepagato, MCP, CLI e competenze agente. ScrapeCreators copre anche altre piattaforme social e commenti YouTube. Gli accessi alla cache supportati sono gratuiti.

### Aggiorna i video che ti interessano

Tassi di utilizzo inferiori per richiesta sono importanti quando aggiorni la modifica delle metriche o raccogli i sottotitoli per i nuovi video. Conserva le trascrizioni salvate e richiedi i metadati solo quando è necessario aggiornarli.

### Inizia con un acquisto più piccolo

Le ricariche di credito di FlashData iniziano a $10. Sposta prima un carico di lavoro YouTube, mentre l'integrazione esistente continua a gestire commenti e altre piattaforme social.

### Scegli la traccia esatta dei sottotitoli

Seleziona esplicitamente i sottotitoli forniti dall'autore del caricamento o generati da YouTube. Richiedi fino a 10 lingue esistenti in una richiesta di trascrizione e gestisci il risultato di ciascuna lingua separatamente.

<a id="costs"></a>
## Confronta nuove richieste, riscontri nella cache e acquisti anticipati

| ScrapeCreators offerta | Acquisto una tantum | Crediti | Per 1,000 nuove chiamate con un credito | Canone mensile |
| --- | --- | --- | --- | --- |
| Offerta iniziale gratuita | $0 | 100 una volta | Indennità iniziale gratuita | $0 |
| Freelance | $47.00 | 25,000 | $1.88 | $0 |
| Business | $497.00 | 500,000 | $0.994 | $0 |
| Impresa | Personalizzato | 1,000,000+ | Personalizzato | $0 per crediti prepagati |

Si tratta di pacchetti prepagati senza rinnovo mensile. Business è esattamente $0.994 per 1,000 chiamate a un credito; $0.99 è arrotondato. I crediti acquistati non hanno scadenza secondo la politica attuale. I crediti bonus iniziali e guadagnati sono esclusi dal modello.

| Piano FlashData | Per 1,000 richieste | Canone mensile | Richieste incluse al mese |
| --- | --- | --- | --- |
| Pagamento a consumo | $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 |

I conteggi delle richieste incluse FlashData assegnano l'intero saldo condiviso ai dati standard YouTube. La ricerca estesa e il download hanno tariffe separate. [Prezzo intero](https://flashdata.dev/it/pricing/youtube-data).

### Esempio: metadati e didascalie per 1,000 video

2,000 richieste, nessuna ricerca di scoperta. FlashData paga in base al consumo rispetto a ScrapeCreators Freelance. Contare solo gli accessi alla cache osservati; le richieste evitate tramite la propria archiviazione locale non vengono inviate a nessuno dei fornitori.

| Riscontri cache gratuiti | FlashData chiamate | FlashData utilizzo | FlashData acquisto | ScrapeCreators crediti | ScrapeCreators valore d'uso | ScrapeCreators acquisto |
| --- | --- | --- | --- | --- | --- | --- |
| 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, un mese di richieste. Una nuova ricerca di metadati, un risultato di sottotitoli nativi o una richiesta di ricerca standard utilizza un credito ScrapeCreators. I metadati più le didascalie utilizzano due richieste su entrambi i lati. Vengono detratti solo gli accessi alla cache dei metadati/transcript immessi sopra; non si presuppone la memorizzazione nella cache della ricerca. Questo modello conta i sottotitoli restituiti, non i tentativi di traccia mancante ed esclude la generazione di intelligenza artificiale. FlashData utilizza il suo standard attuale YouTube Prezzi dei dati, assegnando l'intera franchigia del piano selezionato prima dell'utilizzo aggiuntivo. La ricerca estesa e il download hanno un prezzo separato. Sono esclusi saldi iniziali, prove, crediti bonus, tasse e altri utilizzi. Gli acquisti partono da saldo zero: le ricariche FlashData hanno un minimo di $10; ScrapeCreators arrotondamento degli acquisti all'intero dei pacchetti selezionati. I crediti acquistati inutilizzati possono servire ad attività successive. ScrapeCreators non ha rinnovo mensile del pacchetto; un piano mensile selezionato FlashData ha comunque il suo canone a zero richieste.

### Comportamento della cache

Sugli endpoint metadati/transcript supportati, cache_max_age accetta 1d, 3d, 7d, 14d o 30d. I risultati utilizzano zero crediti e riportano cached_at; i mancati utilizzano la tariffa normale. Non si presuppongono riscontri nella cache di ricerca. Decidi se i dati salvati sono sufficientemente recenti per l'attività. [Salvare e riutilizzare i risultati](https://flashdata.dev/it/docs/guides/save-results/reference.md).

### Offerte di partenza

ScrapeCreators inizia con i crediti gratuiti 100. I registri verificati eleggibili FlashData possono ricevere un'indennità iniziale fino alle richieste di dati 4,000 standard YouTube. Queste offerte non resettano mensile. Il processo di agente temporaneo separato appare qui sotto.

<a id="migration"></a>
## Migrare un video e i relativi timestamp dei sottotitoli

### 1. Configura l'accesso e scegli la traccia

Crea o riutilizza una chiave con l'autorizzazione youtube_transcript, più youtube_metadata per la chiamata di metadati opzionale. [API Chiavi](https://flashdata.dev/app/api-keys) · [Crediti](https://flashdata.dev/app/billing). Memorizza FLASHDATA_API_KEY nell'ambiente o utilizza il prompt nascosto dello script; non incollarlo mai nella chat.

Richiesta esistente, solo per la mappatura:

```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 con X-API-Key e questo corpo JSON:

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

original_audio=true sceglie la lingua parlata. FlashData params.auto=true seleziona i sottotitoli generati da YouTube. Specificare lingua e provenienza separatamente.

### 2. Salva lo script prima di running

Richiede Python 3.10+. Installa la dipendenza con python -m pip install requests. In una nuova cartella di lavoro, salva lo script completo seguente come creator-research.py prima di eseguirlo.

```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'))}")

```

Esegui da quella cartella utilizzando un video con una traccia inglese esistente. I metadati sono una richiesta facoltativa separata; durante una prova temporanea, lasciare almeno un secondo tra una chiamata e l'altra.

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

Per i sottotitoli forniti dall'autore del caricamento, aggiungi --origin manuale. L'impostazione predefinita sono i sottotitoli in inglese generati da YouTube.

In alternativa, usa Bash, cURL 7.76+ e jq 1.6+. Salva lo script completo di seguito come creator-research.sh in una nuova cartella di lavoro.

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

Per i sottotitoli forniti dall'autore del caricamento, aggiungi un manuale. Ogni nuova cartella di output invia una richiesta. Gli stessi argomenti e la cartella riutilizzano l'output salvato; utilizzare una nuova cartella per un aggiornamento intenzionale dopo aver esaminato il tentativo precedente.

### 3. Leggi l'output mappato e l'utilizzo effettivo

captions-001/normalized.json è un adattatore di campo; response.json mantiene la risposta raw e l'utilizzo effettivo. I secondi diventano millisecondi di stringa. languageCode e isAutoGenerated conservano la traccia selezionata. Questa non è una risposta completa al drop-in: nessun saldo di credito fabbricato, bandiere della cache, attribuzione del uploader o campi delle date. Metadata conserva le metriche mancanti come null e la sua data originale come 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 integrazione | FlashData cambiamento |
| --- | --- |
| GET /v1/youtube/video?url=… | POST la query API con sorgente: youtube_metadata e video_id. Leggi i risultati[0], non la radice della risposta. |
| GET /v1/youtube/video/transcript?url=… | Usa fonte: youtube_transcript. Imposta params.language e params.auto in modo esplicito. |
| trascrizione[].startMs / endMs | FlashData inizio/fine sono secondi. Moltiplica ciascuno per 1,000 e serializza come stringhe per un lettore di millisecondi esistente. |
| original_audio=true | Seleziona la lingua parlata in ScrapeCreators, non i sottotitoli generati automaticamente. Risolvi la lingua richiesta nella tua app; params.auto seleziona invece l'origine della didascalia. |
| lingua e transcript_only_text | Mappa languageName e fullText. Conservare languageCode separatamente; il nome della lingua e il codice della lingua sono campi diversi. |
| viewCountInt, likeCountInt, commentCountInt | Mappa viewCount, likeCount, commentCount. Conserva null quando una metrica è assente. |
| durationMs e publishDate | Converti durata secondi in millisecondi. Conserva uploadDate come campo non elaborato finché la tua app non convalida il formato data di cui ha bisogno. |
| canale/autore del caricamento/ownerByline | Il canale FlashData e channelId non riproducono tutte e tre le identità. Mappa solo i campi di cui il tuo lettore ha bisogno; mantenere un percorso separato per l'attribuzione dei crediti musicali. |
| cached, cached_at, credits_charged | Conserva la risposta e l'utilizzo non elaborati di FlashData. Registra il tuo tempo di recupero; non producono flag di cache del fornitore né traducono i saldi di credito tra i fornitori. |

[Schema di trascrizione](https://flashdata.dev/it/docs/sources/youtube_transcript/reference.md) · [Schema dei metadati](https://flashdata.dev/it/docs/sources/youtube_metadata/reference.md)

### Se la prima richiesta fallisce

- 401/403: controlla la chiave salvata e il permesso di origine; ferma se revocato.
- 402: ripristina il saldo del proprietario prima di riprendere.
- 429: legge l'intestazione Retry-After salvata; ridurre la frequenza delle richieste. Le prove temporanee consentono una richiesta al secondo.
- Traccia mancante: verificare lingua e provenienza disponibili. ScrapeCreators può restituire una risposta positiva con una trascrizione null; non confonderlo con una traccia completed FlashData.
- Timeout o cartella incompleta: controlla la cronologia e l'output prima di riprovare. Gli script preservano il tentativo senza reinvio automatico.

[Errori e codici di stato](https://flashdata.dev/it/docs/errors/reference.md)

<a id="workflow"></a>
## Trova → lista → arricchisci → cita

| Passo | Lavoro | Conteggio richieste |
| --- | --- | --- |
| Scopri | Esegui P YouTube Richieste di ricerca | P richieste di ricerca standard. Conta le richieste effettive, non tutti i video restituiti come ricerca separata. |
| Seleziona | Deduplica e seleziona N video IDs | Filtraggio locale; nessuna richiesta di metadati o didascalie ancora. |
| Arricchire | Recupera i metadati per i selezionati IDs | N richieste di metadati; ripetere solo quando è necessario aggiornare le metriche. |
| Citare | Recupera una traccia di sottotitoli esistente ogni ID | N richieste di trascrizione quando disponibili. Memorizza la lingua, l'origine e i tempi dei segnali con la sorgente URL. |
| Riutilizzare | Leggi i risultati salvati per l'attività successiva | Nessuna richiesta del provider quando la tua app può riutilizzare il proprio file salvato. |

10 richieste di ricerca più 50 video selezionati con metadati e didascalie richiedono 110 richieste standard prima del riutilizzo locale. Separare i costi di scoperta dall'arricchimento. Un risultato di ricerca non è di per sé una richiesta di ricerca separata.

### La ricerca non è una migrazione del cursore drop-in

ScrapeCreators può restituire diversi tipi di risultati con continuationToken. La ricerca standard di FlashData restituisce risultati video; la sua ricerca estesa ha limiti e prezzi separati. Avvia una nuova esecuzione di rilevamento invece di riutilizzare un vecchio cursore.

[YouTube Cerca riferimento](https://flashdata.dev/it/docs/sources/youtube_search/reference.md)

### Conserva le prove con la risposta

Memorizza il video ID, URL, la lingua scelta, l'origine dei sottotitoli e l'ora di inizio del segmento. Un collegamento di citazione può puntare a quel timestamp. Non etichettare una traccia di sottotitoli mancante come una trascrizione riuscita vuota.

[Ricetta per i sottotitoli con timestamp](https://flashdata.dev/it/docs/guides/timestamped-captions-recipe/reference.md)

### Scale l'elenco ID separatamente

Una volta completata la ricerca, utilizza batch richieste per un elenco o l'elaborazione in blocco per un file. Tieni traccia del lavoro IDs, salva gli output completed e riprova solo gli elementi failed. Mantieni il tuo corridore responsabile del programma.

[Riferimento all'elaborazione in blocco](https://flashdata.dev/it/docs/reference/bulk-processing/reference.md)

<a id="agents"></a>
## Dimostrare la migrazione prima di pianificarla

Gli agenti idonei possono iniziare con le richieste di dati 1 credit (fino alle richieste 100 standard YouTube) per le ore 72. I metadati, le didascalie e la ricerca condividono l'indennità.

1. Esamina i campi obbligatori, l'intento della didascalia e la freschezza. Riutilizzare l'accesso salvato; mantenere chiamate di dati social non correlate.
2. Esegui un video conosciuto utilizzando CLI, SDK o MCP. Salva l'output e controlla i tempi, i valori nulli e l'utilizzo effettivo.
3. Il proprietario accede o si registra, verifica l'e-mail e approva le rivendicazioni, gli ambiti e l'utilizzo del saldo condiviso. I crediti di prova inutilizzati non vengono trasferiti.
4. Mantieni le credenziali del proprietario per un uso ricorrente. Riutilizzare gli output e fermarsi in caso di revoca o saldo insufficiente.

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

[Processo e rivendicazione](https://flashdata.dev/it/docs/guides/agent-onboarding/reference.md) · [Autonomo CLI](https://flashdata.dev/it/docs/guides/flashdata-cli/reference.md) · [MCP installazione](https://flashdata.dev/it/docs/integrations/mcp-clients/reference.md)

<a id="faq"></a>
## Prima di cambiare

### Si tratta di abbonamenti mensili?

ScrapeCreators Freelance e Business sono pacchetti prepagati, non abbonamenti. Entrambi hanno un canone mensile di $0. FlashData dispone di crediti a consumo e di piani mensili opzionali. Confronta separatamente l'utilizzo consumato e l'acquisto necessario dal tuo saldo attuale.

### Cosa succede se la maggior parte delle mie ScrapeCreators richieste vengono memorizzate nella cache?

I metadati supportati e i riscontri nella cache delle trascrizioni costano zero crediti. Inserisci i risultati osservati nella calcolatrice. Se la tua app accetta la loro età, possono costare meno delle nuove FlashData richieste. Puoi anche salvare localmente l’output di entrambi i provider ed evitare del tutto di effettuare la richiesta successiva.

### I crediti non utilizzati scadono?

ScrapeCreators afferma che i crediti acquistati non scadono secondo la sua politica attuale. La sua offerta iniziale gratuita di credito 100 non è una ricarica mensile. Il periodo di prova dell'agente temporaneo di FlashData scade; le sue pagine dei prezzi e dell'account descrivono i termini applicabili del saldo del proprietario.

### original_audio=true funzionerà come params.auto=true?

No. Il primo sceglie una lingua in base all'audio parlato; il secondo sceglie didascalie generate da YouTube. Imposta deliberatamente una lingua e un'origine. Nessuno dei due endpoint dei sottotitoli nativi del servizio crea la sintesi vocale quando è assente una traccia corrispondente.

### Posso sostituire tutte le mie chiamate sui dati social?

Questa migrazione riguarda YouTube metadati video e sottotitoli esistenti. Mantieni commenti, post della community, profili social e qualsiasi altro campo di risposta non supportato nel percorso esistente. FlashData offre anche Google Ricerca e hosting YouTube Download, con le proprie autorizzazioni e prezzi.

### ScrapeCreators supporta anche gli agenti AI?

Sì. Offre MCP, OAuth, a CLI e abilità di agente. Il flusso dell'agente di FlashData aggiunge una prova temporanea idonea, la richiesta del proprietario e le credenziali salvate per un uso continuato. Scegli il API e il flusso di lavoro di cui ha bisogno la tua attività; MCP Il solo supporto non fa la differenza.
