# Supadata Alternativa para YouTube Datos

Compare YouTube costos de transcripción y metadatos, funciones de subtítulos nativos y acceso de agentes. Migre desde Supadata con ejemplos ejecutables Python y Bash.

Supadata hechos revisados 2026-11-10. FlashData los precios y asignaciones de prueba utilizan sus catálogos públicos actuales.

- [Características](#features)
- [Comparar costes](#costs)
- [Migrar una transcripción](#migration)
- [Metadatos y masa](#workflows)
- [Para agentes de IA](#agents)
- [Preguntas frecuentes](#faq)

<a id="features"></a>
## Comparación de funciones

Para aplicaciones y agentes que recopilan YouTube subtítulos y metadatos existentes.

### Mantener pagado YouTube recuperación económica

| Característica | FlashData | Supadata |
| --- | --- | --- |
| Uso pago sin suscripción | si — Créditos de pago por uso; compras desde $10 | Planes pagos — Basic: $60/año · Pro: $17/mes |
| Transcripción nativa o metadatos · precio por 1,000 | $0.50 — Paga sobre la marcha · sin cuota mensual | $5.67 en Pro — $17 / 3,000 included credits; full allowance usado |
| Lote sin plan mensual | Hasta 100 consultas/Lote — Clave de propietario de pago por uso; el límite de prueba es separado | Pro y superior — Vídeo y transcripción batch puntos finales |

### Encuentre videos y cree una biblioteca de investigación

| Característica | FlashData | Supadata |
| --- | --- | --- |
| Buscar vídeos por tema | si — Búsqueda de palabras clave con filtros de fecha, duración, tipo y clasificación | si — Búsqueda de vídeos, canales y listas de reproducción con filtros. |
| Actualizar metadatos de video sin buscar subtítulos | si — Título, canal, duración, miniaturas y recuentos de participación. | si — Punto final de metadatos separado con campos de autor, medios y estadísticas |
| Idiomas de subtítulos en metadatos de video | si — hasTranscripts y transcriptLanguages | En la respuesta de transcripción — availableLangs; esquema de metadatos separado |

### Mantenga las transcripciones útiles para citas y análisis.

| Característica | FlashData | Supadata |
| --- | --- | --- |
| Texto con marca de tiempo para citas de fuentes. | JSON segmentos en segundos — Texto con horas de inicio y finalización. | JSON fragmentos en milisegundos — Texto con desplazamiento y duración. |
| Texto completo y marcas de tiempo de la misma respuesta. | si — fullText y los segmentos se devuelven juntos | Elija texto o fragmentos — text=true devuelve una cadena; de lo contrario, únete a los fragmentos en tu aplicación |
| Múltiples idiomas de subtítulos existentes en una sola solicitud | Hasta 10 idiomas — Pistas y errores por idioma | Un idioma preferido — parámetro lang en el punto final de la transcripción |
| Seleccione subtítulos proporcionados por el usuario o generados por YouTube | si — Explícito params.auto=false o true | No hay selector de origen documentado — El modo selecciona recuperación nativa versus generación de IA. |
| Manejar explícitamente los subtítulos no disponibles | Solo pistas existentes — Las matrices de idiomas devuelven pistas más errores; no hay nueva transcripción | Elija respaldo nativo o de IA — mode=auto puede generar voz a texto; nativo limita la recuperación de subtítulos existentes |

### Pase de una solicitud a un flujo de trabajo repetible

| Característica | FlashData | Supadata |
| --- | --- | --- |
| Solicitudes interactivas y en segundo plano | En tiempo real o async — Elija el modo de ejecución y guarde el trabajo ID | Trabajo de resultado o transcripción — HTTP 200 devuelve datos; HTTP 202 devuelve un trabajo ID |
| Procesar una lista preparada de videos. | Lote API o Bulk Jobs consola — Sube un archivo ID; conservar las partes del manifiesto y del resultado | Asíncrono batch API · Pro+ — Acepta listas de vídeos, listas de reproducción o canales. |
| Recoge una lista de reproducción o un canal completo | Proporcionar vídeo explícito IDs — Prepare la lista antes del procesamiento por lotes o en masa | Lista de reproducción o canal batch entrada — Regular videos; excludes Shorts and live videos |
| Salida para aplicaciones y LLM | JSON, texto sin formato o Markdown — Elige la respuesta y el formato del contenido. | JSON con texto o fragmentos — Utilice el contenido de la transcripción en su solicitud o mensaje |
| SDK de idiomas | Python, TypeScript y listo | Python y JavaScript / TypeScript |
| MCP acceso para un host de agente | si — Control remoto MCP con OAuth o una tecla API | si — MCP servidor con Supadata credenciales |
| Prueba programática antes del registro del propietario | si — Hasta 100 solicitudes de expedientes académicos nativos · 72 horas | Cuenta API clave primero — 100 créditos gratis cada mes después de registrarse |

Supadata admite la transcripción generada por IA y múltiples plataformas sociales. Los puntos finales de subtítulos de FlashData recuperan pistas de YouTube existentes. Ambos servicios ofrecen MCP y SDK.

### Mantenga una pequeña carga de trabajo de investigación asequible

Pague por las YouTube solicitudes de datos que utilice. Agregue una suscripción más tarde si su tarifa más baja y el saldo incluido se ajustan a su volumen.

[Ponle precio a tu carga de trabajo](#costs)

### Mantenga la fuente del título explícita

Seleccione subtítulos generados por YouTube o proporcionados por quien los subió, mantenga el idioma devuelto y conserve las marcas de tiempo para las citas. Solicite pistas existentes en varios idiomas sin generar nueva conversión de voz a texto.

[Mapee su lector de transcripciones](#migration)

### Crezca de un video a un canal

Utilice la misma forma de solicitud para los trabajos realtime, async y batch. Agregue Google Buscar al flujo de trabajo de investigación utilizando la misma cuenta y saldo compartido.

[Construye el siguiente paso](#workflows)

<a id="costs"></a>
## Ponle precio al flujo de trabajo de vídeo completo

USD. Una transcripción nativa en un idioma o una búsqueda de metadatos equivale a una solicitud y un crédito Supadata. Los metadatos más una transcripción nativa son dos solicitudes por video. FlashData utiliza su catálogo de datos YouTube activo, aplicando el valor del crédito incluido antes del uso adicional. La tarifa unitaria mostrada es una tarifa de uso; Supadata es la tarifa del plan dividida por la asignación mensual completa. Basic es solo anual: $60 se paga por adelantado, se muestra como $5/mes equivalente con 300 créditos cada mes, no 3,600 disponible de inmediato. Otros planes Supadata utilizan precios de lista mensuales. La recarga automática está desactivada en esta estimación hasta que se seleccione; cuando se seleccionan, los paquetes enteros más pequeños publicados cubren el déficit. El tiempo real de recarga automática puede comprarse antes. Los montos de compra no asumen ningún saldo inicial. FlashData las recargas comienzan en $10; una compra puede dejar fondos para más adelante. Supadata los créditos mensuales no se acumulan. Se excluyen los créditos de prueba, impuestos, otros usos de API, descuentos anuales en otros planes, generación de IA y traducción. En caso de cero solicitudes, la tarifa del plan seleccionado permanece y la tarifa efectiva no está definida.

### FlashData YouTube Planes de datos

| FlashData plano | Por 1,000 solicitudes | Cuota mensual | Solicitudes incluidas al mes |
| --- | --- | --- | --- |
| Pago por uso | $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 |

[Precio completo de datos YouTube](https://flashdata.dev/es/pricing/youtube-data)

### Supadata planos publicados

| Supadata plano | Pago del plan | Créditos / mes | Por 1,000 con asignación completa | Paquete de recarga automática |
| --- | --- | --- | --- | --- |
| Gratis | $0.00 / mes | 100 | $0.00 | No disponible |
| Basic · annual only | $60.00 / año ($5.00 / mes equivalente) | 300 | $16.67 | $10.00 / 1,000 créditos |
| Pro · monthly | $17.00 / mes | 3,000 | $5.67 | $10.00 / 1,000 créditos |
| Mega · monthly | $47.00 / mes | 30,000 | $1.57 | $10.00 / 5,000 créditos |
| Giga · monthly | $297.00 / mes | 300,000 | $0.99 | $20.00 / 20,000 créditos |
| Supa · monthly | $897.00 / mes | 1,000,000 | $0.90 | $20.00 / 20,000 créditos |

### Ejemplo: metadatos más una transcripción nativa para cada vídeo

FlashData pago sobre la marcha versus Supadata Mega mensual, con recarga automática incluida. Esta es una comparación de planes explícita; seleccione otros planes de forma independiente en la calculadora HTML.

| Vídeos / mes | Solicitudes de datos | FlashData uso modelado | Supadata Mega + packs de recarga completos | Paquetes de recarga |
| --- | --- | --- | --- | --- |
| 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 |

### Acceso gratuito y generación de IA

Supadata Recargas gratuitas 100 créditos mensuales. Su transcripción nativa utiliza un crédito; La generación de IA utiliza dos créditos por minuto. Por lo tanto, una transcripción generada de 30 minutos utiliza 60 créditos. El modo automático predeterminado puede activar la generación; mode=native evita ese retroceso. La generación, la traducción y la búsqueda extendida están excluidas de esta comparación.

Los registros FlashData verificados elegibles pueden recibir una asignación inicial de hasta 4,000 solicitudes de datos estándar YouTube. No es un nivel gratuito mensual.

<a id="migration"></a>
## Migrar un lector de transcripciones nativo

| Cambiar | Supadata | FlashData | que hacer |
| --- | --- | --- | --- |
| Solicitar | GET /v1/transcript con url, idioma, texto y modo | POST /v1/queries/realtime con fuente, video_id y parámetros | Extraiga el carácter 11 YouTube ID. Una clave Supadata no se autentica en FlashData. |
| Autenticación | x-api-key: tu clave Supadata | X-API-Key: tu clave FlashData | Cree o reutilice una credencial con el permiso youtube_transcript. Los nombres de los encabezados no distinguen entre mayúsculas y minúsculas; la credencial cambia. |
| Nativo versus generado | mode=native recupera los subtítulos existentes; el automóvil puede recurrir a la IA; generar siempre usa IA | youtube_transcript lee subtítulos YouTube existentes | Mueva primero la recuperación nativa. Mantenga un paso separado de conversión de voz a texto para los videos que necesitan una nueva transcripción. |
| Origen del título | El modo selecciona recuperación versus generación. | params.auto=true selecciona subtítulos generados por YouTube; false selecciona subtítulos proporcionados por quien subió el video | Estas configuraciones automáticas no son equivalentes. FlashData el auto nunca inicia la conversión de voz a texto. |
| Idioma | se prefiere el idioma; Los idiomas no disponibles pueden recurrir al primero disponible. | params.language es explícito; auto=true prueba la variante -orig y luego el código solicitado | Marque languageCode y requestedLanguageCode. FlashData no elige silenciosamente otro idioma u origen de subtítulos. |
| Segmentos | contenido[]: texto, desplazamiento y duración en milisegundos | resultados[0].segmentos[]: texto, inicio y fin en segundos | desplazamiento = ronda(inicio × 1000); duración = ronda((fin - inicio) × 1000). Preserve las superposiciones en lugar de cambiar las señales. |
| Texto sin formato | text=true devuelve el contenido como una cadena | resultados[0].fullText | Lea fullText para obtener resúmenes y conserve los segmentos para las citas con marca de tiempo. |
| Descubrimiento del idioma | availableLangs en la respuesta de la transcripción | transcriptLanguages en youtube_metadata | Obtenga metadatos cuando su aplicación necesite la lista completa de idiomas. No inventes availableLangs a partir de una pista devuelta. |
| Finalización | HTTP 200 resultado, o HTTP 202 + jobId | Estado en tiempo real=done; async devolución de envíos FlashData trabajo IDs | Maneje los estados de cada proveedor por separado. Termine Supadata trabajos existentes allí antes de migrar nuevos trabajos. |

### 1. Configurar el acceso

Cree o reutilice una clave FlashData con permiso youtube_transcript en [API Claves](https://flashdata.dev/app/api-keys). Agregue youtube_metadata para la tarea de metadatos opcional. Marque [créditos disponibles](https://flashdata.dev/app/billing) o utilice [acceso de prueba para agentes elegibles](#agents). Guarde las claves en un entorno o almacén secreto.

Supadata solicitud nativa reemplazada:

```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 reemplazo JSON cuerpo para POST /v1/queries/realtime:

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

### 2. Guarde el script y luego ejecútelo

Elija Python o Bash. Cada nueva carpeta de salida envía una solicitud; reutilizar una carpeta lee el resultado guardado sin otra llamada a API. Las versiones comparten el formato del archivo guardado. Elija un vídeo con la pista de subtítulos solicitada.

#### Python

Requiere Python 3.10+. Instala la dependencia con python -m pip install requests. En una nueva carpeta de trabajo, guarda el script completo que aparece a continuación como youtube-migrate.py antes de ejecutarlo.

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

```

Ejecute desde esa carpeta de trabajo:

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

Esto selecciona YouTube subtítulos en inglés generados. Agregue --origin manual para una pista proporcionada por quien subió el video, o --language CÓDIGO para elegir un idioma.

Solicitud de metadatos separados opcional:

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

#### Bash

Requiere Bash, cURL 7.76+ y jq 1.6+. Guarde este script completo como youtube-migrate.sh en su carpeta de trabajo antes de 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"

```

Ejecute desde esa carpeta de trabajo:

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

Los argumentos opcionales después de la carpeta son el idioma y el origen; por ejemplo, en manual selecciona los subtítulos en inglés proporcionados por quien los subió.

Solicitud de metadatos separados opcional:

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

Para acceso de prueba temporal, ejecute las solicitudes secuencialmente con al menos un segundo de diferencia.

### 3. Leer el resultado

response.json conserva el resultado y el uso sin procesar. normalized.json convierte segundos de segmento de transcripción en desplazamiento/duration milisegundos. Este es un adaptador de segmento, no una respuesta completa compatible con Supadata: availableLangs no está fabricado. La salida de metadatos conserva los valores que aceptan valores NULL. Las solicitudes fallidas o interrumpidas conservan su evidencia y se detienen.

Ilustrativo normalized.json:

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

[Esquema de transcripción](https://flashdata.dev/es/docs/sources/youtube_transcript/reference.md)

<a id="workflows"></a>
## Metadatos y flujos de trabajo masivos

| Datos | Supadata /v1/metadata | FlashData youtube_metadata |
| --- | --- | --- |
| Identidad de vídeo | id | resultados[0].videoId |
| Título y descripción | título, descripción | resultados[0].título, resultados[0].descripción |
| canal | author.displayName; additionalData.channelId | resultados[0].canal; resultados[0].channelId |
| Compromiso | stats.views, stats.likes, stats.comments | resultados[0].viewCount, likeCount, commentCount |
| Duración | media.duration (segundos) | resultados[0].duración (segundos) |
| Miniatura | media.thumbnailUrl | resultados[0].miniaturas[]; elige el tamaño que necesita tu aplicación |
| Fecha de publicación | createdAt | resultados[0].uploadDate; normaliza su formato en tu aplicación |
| Descubrimiento de subtítulos | Leer availableLangs de una transcripción de respuesta | resultados[0].hasTranscripts y transcriptLanguages |

### Varios idiomas existentes en una sola solicitud.

Envíe una matriz de idiomas para recibir pistas y errores, incluso para una matriz que contenga un idioma. Inspeccione los errores incluso cuando el estado sea done. Estas son pistas existentes, no traducidas ni subtítulos generados.

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

### Enriquecer una biblioteca de investigación

Obtenga metadatos una vez, guarde su video ID y los idiomas de subtítulos disponibles, luego recupere la pista que necesita. Mantenga los recuentos de participación anulables como null en lugar de convertirlos a cero.

[YouTube Mejores prácticas de datos](https://flashdata.dev/es/docs/guides/youtube-data-guide/reference.md)

### Procesar una lista de videos IDs

Amplíe su entrada a un video explícito IDs, luego use Batch o un archivo masivo. FlashData no acepta un Supadata playlistId como entrada directa batch. Guarde el estado y la salida de cada elemento antes de volver a intentar failed elementos.

[Referencia de procesamiento masivo](https://flashdata.dev/es/docs/reference/bulk-processing/reference.md)

### Realizar investigaciones según un cronograma

Conserve la credencial de propietario, controle completed videos y lea el resultado guardado al reiniciar. Detener por acceso revocado o saldo insuficiente; no cree otra prueba para continuar un trabajo programado.

[Tareas recurrentes del agente](https://flashdata.dev/es/docs/guides/recurring-tasks/reference.md)

### Production decisiones migratorias

- Resolver las entradas de la lista de reproducción/channel a videos explícitos IDs antes del FlashData procesamiento por lotes o archivos masivos; Supadata playlistId no es una entrada directa.
- La búsqueda Supadata cuesta un crédito por 20 página de resultados, o techo(límite/20) con límite. FlashData estándar YouTube La búsqueda admite hasta 20 resultados; La búsqueda extendida tiene una tarifa separada. Asigne filtros y no transfiera tokens de página.
- Supadata documenta una ventana de resultados del trabajo de transcripción de una hora completed. Drene los trabajos existentes allí y almacene los resultados antes de migrar nuevos trabajos. Mantenga el trabajo específico del proveedor IDs separado.
- Mantenga los medios multiplataforma, la extracción de IA, la traducción y la transcripción de audio en sus rutas existentes, a menos que se haya implementado un flujo de trabajo equivalente.

<a id="agents"></a>
## Prueba de agente, reclamación y uso recurrente

Los agentes elegibles pueden comenzar con 1 crédito(s), hasta 100 solicitudes de transcripción nativa por 72 horas. Los metadatos y las transcripciones comparten esta asignación.

1. Reutilice primero el acceso existente; de lo contrario, inicie una prueba elegible con solo los permisos necesarios.
2. Devuelva un resultado útil, guarde la salida y el uso sin procesar y mantenga el mismo perfil y directorio de estado.
3. El propietario inicia sesión o se registra, verifica el correo electrónico y aprueba los reclamos, los alcances y el acceso al saldo compartido.
4. Reutilice la credencial de propietario para tareas recurrentes. Los créditos de prueba no utilizados no se transfieren. Detener después de la revocación o saldo insuficiente; nunca cree otra prueba para continuar.

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

[Juicio y reclamación](https://flashdata.dev/es/docs/guides/agent-onboarding/reference.md) · [Independiente CLI](https://flashdata.dev/es/docs/guides/flashdata-cli/reference.md) · [MCP conexión](https://flashdata.dev/es/docs/integrations/mcp-clients/reference.md)

<a id="faq"></a>
## Preguntas sobre migración

### ¿Puede FlashData reemplazar la transcripción de IA de Supadata?

Las fuentes de transcripción y subtítulos de FlashData recuperan subtítulos que ya están presentes en YouTube. No transcriben audio, traducen texto ni realizan análisis visuales. Mover la recuperación nativa YouTube a FlashData; mantenga un servicio separado para conversión de voz a texto, video multiplataforma o extracción de IA cuando su aplicación lo necesite.

### ¿Qué se pide comprar?

La calculadora cubre una transcripción existente en un idioma o una búsqueda de metadatos de vídeo. Obtener ambos utiliza dos solicitudes por video. Supadata factura cada una de estas operaciones a un crédito. FlashData utiliza la tarifa de datos YouTube del plan seleccionado. La búsqueda extendida, la transcripción mediante IA, la traducción y la entrega de medios están fuera de esta estimación.

### ¿Siempre es FlashData más barato?

Compare su carga de trabajo real y los planes seleccionados. Supadata incluye 100 créditos todos los meses de forma gratuita. La prueba de agente temporal de FlashData es limitada y vence; no es un nivel gratuito mensual. A bajo volumen, una asignación gratuita puede cubrir toda la tarea. Las tarifas pagadas del plan, los paquetes de recarga y los saldos no utilizados afectan el monto que paga.

### ¿Supadata ya es compatible con MCP y SDK?

Sí. Ambos servicios admiten integraciones MCP y Python/JavaScript. FlashData también proporciona un Go SDK, un CLI independiente y una prueba de agente temporal que se puede solicitar para acceso recurrente. Elija la interfaz que admita su host; MCP por sí solo no es motivo para cambiar.

### ¿Qué sucede si falta una pista de subtítulos?

Trátelo como una brecha de datos. FlashData no cambia entre subtítulos proporcionados por el usuario y los generados por YouTube ni sintetiza una transcripción. Para una matriz de idiomas, inspeccione los errores incluso cuando la solicitud sea done. Supadata puede generar una transcripción en modo automático, mientras que el modo nativo puede devolver HTTP 206 para una transcripción no disponible; su documentación factura esa respuesta con un crédito.

### ¿Puedo mantener la forma de respuesta de la aplicación existente?

Guarde su propio adaptador. El ejemplo convierte segmentos FlashData en entradas de contenido con desplazamiento y duración en milisegundos, pero no afirma una respuesta completa compatible con Supadata. Lea los metadatos FlashData si necesita idiomas disponibles y migre explícitamente el estado del trabajo, el manejo de errores y uso.

[Obtener una clave API](https://flashdata.dev/signup)
