# Supadata Alternativa a YouTube Dati

Confronta YouTube costi di trascrizione e metadati, funzionalità di sottotitoli nativi e accesso agli agenti. Migrazione da Supadata con esempi eseguibili Python e Bash.

Supadata fatti esaminati 2026-11-10. I prezzi FlashData e le indennità di prova utilizzano i suoi attuali cataloghi pubblici.

- [Caratteristiche](#features)
- [Confronta i costi](#costs)
- [Migrare una trascrizione](#migration)
- [Metadati e massa](#workflows)
- [Per gli agenti IA](#agents)
- [Domande frequenti](#faq)

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

Per app e agenti che raccolgono YouTube didascalie e metadati esistenti.

### Mantieni pagato YouTube recupero economico

| Caratteristica | FlashData | Supadata |
| --- | --- | --- |
| Utilizzo a pagamento senza abbonamento | Sì — Crediti a consumo; acquisti da $10 | Piani a pagamento — Basic: $60/anno · Pro: $17/mese |
| Trascrizione o metadati nativi · prezzo per 1,000 | $0.50 — Paga in base al consumo · nessun canone mensile | $5.67 il Pro — $17 / 3,000 included credits; full allowance usato |
| Lotto senza un piano mensile | Fino a 100 query/batch — Chiave proprietario a consumo; il limite di prova è separato | Pro e oltre — Endpoint di video e trascrizione batch |

### Trova video e crea una libreria di ricerca

| Caratteristica | FlashData | Supadata |
| --- | --- | --- |
| Trova video per argomento | Sì — Ricerca per parole chiave con data, durata, tipo e filtri di ordinamento | Sì — Ricerca di video, canali e playlist con filtri |
| Aggiorna i metadati del video senza recuperare i sottotitoli | Sì — Titolo, canale, durata, miniature e conteggio del coinvolgimento | Sì — Endpoint dei metadati separati con campi autore, media e statistiche |
| Lingue dei sottotitoli nei metadati del video | Sì — hasTranscripts e transcriptLanguages | Nella risposta alla trascrizione — availableLangs; schema di metadati separato |

### Mantieni le trascrizioni utili per citazioni e analisi

| Caratteristica | FlashData | Supadata |
| --- | --- | --- |
| Testo con timestamp per le citazioni delle fonti | JSON segmenti in secondi — Testo con orari di inizio e fine | JSON blocchi in millisecondi — Testo con offset e durata |
| Testo completo e timestamp dalla stessa risposta | Sì — fullText e i segmenti vengono restituiti insieme | Scegli testo o blocchi — text=true restituisce una stringa; altrimenti unisci i blocchi nella tua app |
| Più lingue dei sottotitoli esistenti in un'unica richiesta | Fino a 10 lingue — Tracce ed errori per lingua | Una lingua preferita — parametro lang sull'endpoint della trascrizione |
| Seleziona i sottotitoli forniti dall'autore del caricamento o generati da YouTube | Sì — params.auto=false o true esplicito | Nessun selettore di origine documentato — la modalità seleziona il recupero nativo rispetto alla generazione AI |
| Gestisci esplicitamente i sottotitoli non disponibili | Solo tracce esistenti — Gli array linguistici restituiscono tracce più errori; nessuna nuova trascrizione | Scegli il fallback nativo o AI — mode=auto può generare la sintesi vocale; nativo limita il recupero alle didascalie esistenti |

### Passa da una richiesta a un flusso di lavoro ripetibile

| Caratteristica | FlashData | Supadata |
| --- | --- | --- |
| Richieste interattive e in background | In tempo reale o async — Scegli la modalità di esecuzione e salva il lavoro ID | Lavoro di risultato o trascrizione — HTTP 200 restituisce i dati; HTTP 202 restituisce un lavoro ID |
| Elabora un elenco preparato di video | Console batch API o Bulk Jobs — Carica un file ID; mantenere le parti manifest e risultato | Asincrono batch API · Pro+ — Accetta elenchi di video, playlist o canali |
| Raccogli un'intera playlist o un canale | Fornisci video esplicito IDs — Preparare l'elenco prima dell'elaborazione batch o di massa | Video Ingresso playlist o canale batch — Regular videos; excludes Shorts and live |
| Output per applicazioni e LLM | JSON, testo semplice o Markdown — Scegli la risposta e il formato del contenuto | JSON con testo o pezzi — Utilizza il contenuto della trascrizione nella tua domanda o nel prompt |
| SDK per la lingua | Python, TypeScript e Vai | Python e JavaScript / TypeScript |
| MCP accesso per un host agente | Sì — Telecomando MCP con OAuth o un tasto API | Sì — MCP server con credenziali Supadata |
| Prova programmatica prima della registrazione del proprietario | Sì — Fino a 100 richieste di trascrizione nativa · 72 ore | Prima la chiave dell'account API — 100 crediti gratuiti ogni mese dopo la registrazione |

Supadata supporta la trascrizione generata dall'intelligenza artificiale e più piattaforme social. Gli endpoint dei sottotitoli di FlashData recuperano le tracce YouTube esistenti. Entrambi i servizi offrono MCP e SDK.

### Mantieni un piccolo carico di lavoro di ricerca accessibile

Paga per le YouTube richieste di dati che utilizzi. Aggiungi un abbonamento in un secondo momento se la tariffa più bassa e il saldo incluso sono adatti al tuo volume.

[Dai un prezzo al tuo carico di lavoro](#costs)

### Mantieni esplicita la fonte della didascalia

Seleziona i sottotitoli generati da YouTube o forniti dall'autore del caricamento, mantieni la lingua restituita e conserva i timestamp per le citazioni. Richiedi tracce esistenti in diverse lingue senza generare nuova sintesi vocale.

[Mappa il tuo lettore di trascrizioni](#migration)

### Passa da un video a una pipeline

Utilizza la stessa forma di richiesta per il lavoro realtime, async e batch. Aggiungi Google Cerca al flusso di lavoro di ricerca utilizzando lo stesso account e saldo condiviso.

[Costruisci il passaggio successivo](#workflows)

<a id="costs"></a>
## Prezzo del flusso di lavoro video completo

USD. Una trascrizione nativa in una lingua o una ricerca di metadati corrisponde a una richiesta e un credito Supadata. I metadati più una trascrizione nativa corrispondono a due richieste per video. FlashData utilizza il suo catalogo dati live YouTube, applicando il valore del credito incluso prima dell'ulteriore utilizzo. La tariffa unitaria visualizzata è una tariffa di utilizzo; Supadata è la tariffa del piano divisa per l'intera indennità mensile. Basic è solo annuale: $60 pagato in anticipo, indicato come $5/mese equivalente con 300 crediti ogni mese, non 3,600 disponibile immediatamente. Altri piani Supadata utilizzano prezzi di listino mensili. La ricarica automatica è disattivata in questa stima finché non viene selezionata; quando selezionati, i pacchetti interi più piccoli pubblicati coprono il deficit. I tempi effettivi di ricarica automatica potrebbero essere anticipati. Gli importi di acquisto non presuppongono alcun saldo iniziale. FlashData le ricariche iniziano alle $10; un acquisto può lasciare fondi per dopo. Supadata i crediti mensili non si rinnovano. Sono esclusi crediti di prova, tasse, altro utilizzo di API, sconti annuali su altri piani, generazione di AI e traduzione. A zero richieste rimane la tariffa del piano selezionato e la tariffa effettiva non è definita.

### FlashData YouTube Piani dati

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

[Prezzo completo dei dati YouTube](https://flashdata.dev/it/pricing/youtube-data)

### Supadata piani pubblicati

| Piano Supadata | Pianificare il pagamento | Crediti/mese | Per 1,000 a indennità piena | Pacchetto di ricarica automatica |
| --- | --- | --- | --- | --- |
| Gratis | $0.00 / mese | 100 | $0.00 | Non disponibile |
| Basic · annual only | $60.00 / anno ($5.00 / mese equivalente) | 300 | $16.67 | $10.00 / 1,000 crediti |
| Pro · monthly | $17.00 / mese | 3,000 | $5.67 | $10.00 / 1,000 crediti |
| Mega · monthly | $47.00 / mese | 30,000 | $1.57 | $10.00 / 5,000 crediti |
| Giga · monthly | $297.00 / mese | 300,000 | $0.99 | $20.00 / 20,000 crediti |
| Supa · monthly | $897.00 / mese | 1,000,000 | $0.90 | $20.00 / 20,000 crediti |

### Esempio: metadati più una trascrizione nativa per ogni video

FlashData paga in base al consumo rispetto a Supadata Mega al mese, con ricarica automatica inclusa. Questo è un confronto esplicito dei piani; seleziona altri piani in modo indipendente nella calcolatrice HTML.

| Video/mese | Richieste di dati | FlashData utilizzo modellato | Supadata Mega + interi pacchetti di ricarica | Ricaricare i pacchi |
| --- | --- | --- | --- | --- |
| 100 | 200 | $0.10 | $47.00 | 0 |
| 1,000 | 2,000 | $1.00 | $47.00 | 0 |
| 10,000 | 20,000 | $10.00 | $47.00 | 0 |
| 100,000 | 200,000 | $100.00 | $387.00 | 34 |

### Accesso gratuito e generazione di intelligenza artificiale

Supadata Ricariche gratuite 100 crediti mensili. La sua trascrizione nativa utilizza un credito; La generazione dell'IA utilizza due crediti al minuto. Una trascrizione generata da 30 minuti utilizza quindi 60 crediti. La modalità automatica predefinita può attivare la generazione; mode=native evita questo fallback. Da questo confronto sono escluse la generazione, la traduzione e la ricerca estesa.

Le iscrizioni idonee verificate di FlashData possono ricevere un'indennità iniziale fino a 4,000 richieste di dati standard YouTube. Non è un livello gratuito mensile.

<a id="migration"></a>
## Migrare un lettore di trascrizioni nativo

| Cambiare | Supadata | FlashData | Cosa fare |
| --- | --- | --- | --- |
| Richiesta | GET /v1/transcript con url, lang, testo e modalità | POST /v1/queries/realtime con sorgente, video_id e parametri | Estrai il carattere 11 YouTube ID. Una chiave Supadata non esegue l'autenticazione su FlashData. |
| Autenticazione | x-api-key: la tua chiave Supadata | X-API-Key: la tua chiave FlashData | Crea o riutilizza una credenziale con l'autorizzazione youtube_transcript. I nomi delle intestazioni non fanno distinzione tra maiuscole e minuscole; la credenziale cambia. |
| Nativo contro generato | mode=native recupera le didascalie esistenti; l'auto può ricorrere all'intelligenza artificiale; generate utilizza sempre l'intelligenza artificiale | youtube_transcript legge le didascalie YouTube esistenti | Sposta prima il recupero nativo. Mantieni un passaggio di sintesi vocale separato per i video che necessitano di una nuova trascrizione. |
| Origine della didascalia | la modalità seleziona il recupero rispetto alla generazione | params.auto=true seleziona i sottotitoli generati da YouTube; false seleziona i sottotitoli forniti dall'autore del caricamento | Queste impostazioni automatiche non sono equivalenti. FlashData la funzione automatica non avvia mai la sintesi vocale. |
| Lingua | è preferibile la lingua; le lingue non disponibili possono ricorrere alla prima disponibile | params.language è esplicito; auto=true prova la variante -orig quindi il codice richiesto | Controlla languageCode e requestedLanguageCode. FlashData non sceglie silenziosamente un'altra lingua o origine dei sottotitoli. |
| Segmenti | contenuto[]: testo, offset e durata in millisecondi | risultati[0].segments[]: testo, inizio e fine in secondi | offset = round(inizio × 1000); durata = round((fine − inizio) × 1000). Preserva le sovrapposizioni invece di spostare i segnali. |
| Testo semplice | text=true restituisce il contenuto come una stringa | risultati[0].fullText | Leggere fullText per la sintesi e mantenere i segmenti per le citazioni timestamp. |
| Scoperta della lingua | availableLangs nella risposta alla trascrizione | transcriptLanguages in youtube_metadata | Recupera i metadati quando la tua app necessita dell'elenco completo delle lingue. Non inventare availableLangs da una traccia restituita. |
| Completamento | HTTP 200 risultato, oppure HTTP 202 + jobId | Stato in tempo reale=done; async invii restituiti FlashData lavoro IDs | Gestisci gli stati di ciascun provider separatamente. Completa lì Supadata lavori esistenti prima di migrare nuovi lavori. |

### 1. Configura l'accesso

Crea o riutilizza una chiave FlashData con autorizzazione youtube_transcript in [API Chiavi](https://flashdata.dev/app/api-keys). Aggiungi youtube_metadata per l'attività facoltativa sui metadati. Seleziona [crediti disponibili](https://flashdata.dev/app/billing) o usa [accesso di prova dell'agente idoneo](#agents). Conservare le chiavi in ​​un ambiente o in un negozio segreto.

Supadata richiesta nativa in fase di sostituzione:

```bash
# Existing Supadata call: use your saved SUPADATA_API_KEY.
curl --get --fail-with-body --silent --show-error \
  'https://api.supadata.ai/v1/transcript' \
  --header "x-api-key: $SUPADATA_API_KEY" \
  --data-urlencode 'url=https://www.youtube.com/watch?v=FUfGcZ092b0' \
  --data-urlencode 'lang=en' --data-urlencode 'text=false' \
  --data-urlencode 'mode=native'
```

FlashData sostituzione JSON corpo per POST /v1/queries/realtime:

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

### 2. Salva lo script, quindi eseguilo

Scegli Python o Bash. Ogni nuova cartella di output invia una richiesta; riutilizzando una cartella si legge l'output salvato senza un'altra chiamata API. Le versioni condividono il formato del file salvato. Scegli un video con la traccia dei sottotitoli richiesta.

#### Python

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 youtube-migrate.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")
    content = []
    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")
        content.append({"text": text, "offset": round(start * 1000),
                        "duration": round((end - start) * 1000)})
    normalized = {"content": content, "lang": item["languageCode"].removesuffix("-orig")}
else:
    normalized = {name: item.get(name) for name in (
        "videoId", "title", "channel", "duration", "viewCount", "likeCount",
        "commentCount", "hasTranscripts", "transcriptLanguages", "chapters")}
(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 di lavoro:

```bash
python youtube-migrate.py transcript FUfGcZ092b0 transcript-001
```

Questo seleziona sottotitoli inglesi generati da YouTube. Aggiungi il manuale --origin per una traccia fornita dall'autore del caricamento o il CODICE --language per scegliere una lingua.

Richiesta di metadati separata facoltativa:

```bash
python youtube-migrate.py metadata FUfGcZ092b0 metadata-001
```

#### Bash

Richiede Bash, cURL 7.76+ e jq 1.6+. Salva questo script completo come youtube-migrate.sh nella cartella di lavoro prima di running:

```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
      {videoId, title, channel, duration, viewCount, likeCount, commentCount,
       hasTranscripts, transcriptLanguages, chapters}
    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
      | {lang: (.languageCode | sub("-orig$"; "")), content: [.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, offset: (.start * 1000 | round), duration: ((.end - .start) * 1000 | round)} 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"

```

Esegui da quella cartella di lavoro:

```bash
bash youtube-migrate.sh transcript FUfGcZ092b0 transcript-001
```

Gli argomenti facoltativi dopo la cartella sono lingua e origine; ad esempio, en manual seleziona i sottotitoli in inglese forniti dall'autore del caricamento.

Richiesta di metadati separata facoltativa:

```bash
bash youtube-migrate.sh metadata FUfGcZ092b0 metadata-001
```

Per l'accesso di prova temporaneo, eseguire le richieste in sequenza ad almeno un secondo di distanza.

### 3. Leggi l'output

response.json preserva il risultato grezzo e l'utilizzo. normalized.json converte i secondi del segmento di trascrizione in offset/duration millisecondi. Questo è un adattatore di segmento, non una risposta completa compatibile con Supadata: availableLangs non è fabbricato. L'output dei metadati conserva i valori nullable. Le richieste fallite o interrotte mantengono la loro evidenza e si interrompono.

Illustrativo normalized.json:

```json
{
  "content": [
    {
      "text": "Example caption text.",
      "offset": 1250,
      "duration": 2250
    }
  ],
  "lang": "en"
}
```

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

<a id="workflows"></a>
## Metadati e flussi di lavoro in blocco

| Dati | Supadata /v1/metadata | FlashData youtube_metadata |
| --- | --- | --- |
| Identità video | id | risultati[0].videoId |
| Titolo e descrizione | titolo, descrizione | risultati[0].titolo, risultati[0].descrizione |
| Canale | author.displayName; additionalData.channelId | risultati[0].canale; risultati[0].channelId |
| Coinvolgimento | stats.views, stats.likes, stats.comments | risultati[0].viewCount, likeCount, commentCount |
| Durata | media.duration (secondi) | risultati[0].durata (secondi) |
| Miniatura | media.thumbnailUrl | risultati[0].miniature[]; scegli la dimensione di cui ha bisogno la tua app |
| Data di pubblicazione | createdAt | risultati[0].uploadDate; normalizza il suo formato nella tua app |
| Scoperta delle didascalie | Leggi availableLangs da una risposta alla trascrizione | risultati[0].hasTranscripts e transcriptLanguages |

### Diverse lingue esistenti in un'unica richiesta

Invia un array di lingue per ricevere tracce ed errori, anche per un array contenente una lingua. Controlla gli errori anche quando lo stato è done. Si tratta di tracce esistenti, non di sottotitoli tradotti o generati.

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

### Arricchisci una biblioteca di ricerca

Recupera i metadati una volta, salva il video ID e le lingue dei sottotitoli disponibili, quindi recupera la traccia che ti serve. Mantieni i conteggi dell'impegno nullable come null anziché convertirli in zero.

[YouTube Migliori pratiche sui dati](https://flashdata.dev/it/docs/guides/youtube-data-guide/reference.md)

### Elabora un elenco di video IDs

Espandi il tuo input in un video esplicito IDs, quindi utilizza Batch o un file collettivo. FlashData non accetta un Supadata playlistId come input drop-in batch. Salva lo stato e l'output per articolo prima di riprovare con failed articoli.

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

### Esegui la ricerca secondo un programma

Mantieni le credenziali del proprietario, controlla i video completed e leggi l'output salvato al riavvio. Stop per accesso revocato o saldo insufficiente; non creare un'altra prova per continuare un lavoro pianificato.

[Attività ricorrenti dell'agente](https://flashdata.dev/it/docs/guides/recurring-tasks/reference.md)

### Production decisioni sulla migrazione

- Risolvi gli input della playlist/channel nel video esplicito IDs prima di FlashData Elaborazione di file batch o di massa; Supadata playlistId non è un input drop-in.
- La ricerca di Supadata costa un credito per pagina di risultati 20 o ceil(limit/20) con limite. FlashData standard YouTube La ricerca supporta fino a 20 risultati; La ricerca estesa ha una tariffa separata. Filtra la mappa e non trasferisce i token della pagina.
- Supadata documenta una finestra dei risultati del lavoro di trascrizione completed di un'ora. Svuota i posti di lavoro esistenti e archivia i risultati prima di migrare nuovo lavoro. Mantieni separato il lavoro specifico del fornitore IDs.
- Mantieni i media multipiattaforma, l'estrazione AI, la traduzione e la trascrizione audio sui percorsi esistenti a meno che non sia stato implementato un flusso di lavoro equivalente.

<a id="agents"></a>
## Prova dell'agente, richiesta e utilizzo ricorrente

Gli agenti idonei possono iniziare con 1 crediti, fino a 100 richieste di trascrizione nativa per 72 ore. Metadati e trascrizioni condividono questa indennità.

1. Riutilizzare prima l'accesso esistente; altrimenti avvia una prova idonea con solo le autorizzazioni necessarie.
2. Restituisce un risultato utile, salva l'output e l'utilizzo non elaborati e mantieni lo stesso profilo e la stessa directory di stato.
3. Il proprietario accede o si registra, verifica l'e-mail e approva le richieste, gli ambiti e l'accesso al saldo condiviso.
4. Riutilizza le credenziali del proprietario per attività ricorrenti. I crediti di prova inutilizzati non vengono trasferiti. Stop dopo revoca o saldo insufficiente; non creare mai un'altra prova per continuare.

```text
Migrate the native YouTube transcript part of this project from Supadata to FlashData.
Read https://flashdata.dev/auth.md and https://flashdata.dev/docs/sources/youtube_transcript/reference.md.
Reuse a saved FlashData credential before requesting an eligible temporary trial.
Use youtube_transcript permission and one explicit video ID, language and caption origin.
Do not map Supadata mode=auto to FlashData auto=true: the latter selects existing YouTube-generated captions.
Save the raw response and actual usage. Convert segment seconds to milliseconds if my reader expects offset/duration.
Do not fabricate captions or available languages. Report missing tracks and keep AI generation separate.
Ask the owner to claim access before recurring use. Store credentials outside chat and source control.
Reuse saved outputs on restart and stop after revocation; never create repeated trials to keep running.
```

[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) · [Connessione MCP](https://flashdata.dev/it/docs/integrations/mcp-clients/reference.md)

<a id="faq"></a>
## Domande sulla migrazione

### Può FlashData sostituire la trascrizione AI di Supadata?

Le fonti della trascrizione e dei sottotitoli di FlashData recuperano i sottotitoli già presenti su YouTube. Non trascrivono l'audio, non traducono testi né eseguono analisi visive. Sposta il recupero nativo YouTube in FlashData; mantieni un servizio separato per la sintesi vocale, i video multipiattaforma o l'estrazione AI quando la tua applicazione lo richiede.

### Cosa si compra con una richiesta?

Il calcolatore copre una trascrizione esistente in una lingua o una ricerca di metadati video. Il recupero di entrambi utilizza due richieste per video. Supadata fattura ciascuna di queste operazioni con un credito. FlashData utilizza la velocità dati YouTube del piano selezionato. La ricerca estesa, la trascrizione AI, la traduzione e la distribuzione dei contenuti multimediali non rientrano in questa stima.

### FlashData è sempre più economico?

Confronta il tuo carico di lavoro effettivo e i piani selezionati. Supadata include 100 crediti ogni mese in modalità gratuita. Il periodo di prova dell'agente temporaneo di FlashData è limitato e scade; non è un livello gratuito mensile. A basso volume, un'indennità gratuita può coprire l'intero compito. Le tariffe del piano pagato, i pacchetti di ricarica e i saldi non utilizzati influiscono sull'importo pagato.

### Supadata supporta già MCP e gli SDK?

Sì. Entrambi i servizi supportano le integrazioni MCP e Python/JavaScript. FlashData fornisce anche un Go SDK, un CLI autonomo e una versione di prova dell'agente temporaneo che può essere richiesta per l'accesso ricorrente. Scegli l'interfaccia supportata dal tuo host; MCP da solo non è un motivo per cambiare.

### Cosa succede se manca una traccia di sottotitoli?

Trattalo come una lacuna di dati. FlashData non alterna tra i sottotitoli forniti dall'uploader e quelli generati da YouTube né sintetizza una trascrizione. Per un array di lingue, controlla gli errori anche quando la richiesta è done. Supadata può generare una trascrizione in modalità automatica, mentre la modalità nativa può restituire HTTP 206 per una trascrizione non disponibile; la sua documentazione fattura quella risposta con un credito.

### Posso mantenere la forma di risposta dell'applicazione esistente?

Tieni il tuo adattatore. L'esempio converte i segmenti FlashData in voci di contenuto con offset e durata in millisecondi, ma non richiede una risposta completa compatibile con Supadata. Leggi i metadati FlashData se hai bisogno delle lingue disponibili e migra in modo esplicito lo stato del lavoro, la gestione degli errori e dell'utilizzo.

[Ottieni una chiave API](https://flashdata.dev/signup)
