# ScrapeCreators Alternativa para YouTube Datos

Compare YouTube costos de metadatos y subtítulos, paquetes prepagos y visitas de caché. Migre a FlashData con adaptadores de campo ejecutables Python y Bash para aplicaciones y agentes.

Datos de vídeo nuevos. Un gasto inicial menor. Mueve YouTube metadatos y llamadas de subtítulos mientras conservas el resto de tu integración de datos sociales.

Los hechos de ScrapeCreators revisaron 2026-11-10. Los precios y las prestaciones de prueba FlashData provienen de sus catálogos públicos actuales.

- [Características](#features)
- [Precios y caché](#costs)
- [Migrar una solicitud](#migration)
- [Flujo de trabajo de investigación](#workflow)
- [Para agentes de IA](#agents)
- [Preguntas frecuentes](#faq)

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

### Reduzca el costo de los datos nuevos YouTube

| Característica | FlashData | ScrapeCreators |
| --- | --- | --- |
| Tarifa pagada de entrada / 1,000 metadatos o llamadas de subtítulos | $0.50 — Uso de pago por uso | $1.88 — Freelance · nuevas llamadas de un crédito |
| Tarifa unitaria más baja listada/1,000 llamadas | $0.20 — Plan mensual opcional; su tarifa aún se aplica | $0.994 — Business · $497 paquete prepago; Empresa personalizada excluida |
| Primera compra a crédito pagada | Desde $10 | $47 — 25,000-crédito Freelance paquete |
| Paga sobre la marcha sin cuota mensual | si | si |

### Encuentre videos y actualice los datos que necesita

| Característica | FlashData | ScrapeCreators |
| --- | --- | --- |
| Encuentra vídeos por palabra clave y filtros. | si — Filtros de fecha, duración, tipo y clasificación. | si — Filtros de búsqueda y paginación de tokens de continuación |
| Metadatos de un vídeo conocido | si — Título, canal, duración, miniaturas y recuentos de participación. | si — Video/Short Detalles punto final |
| Marcadores de capítulos para la navegación. | si — include_chapters; títulos con inicio/end veces cuando están presentes | si — capítulos en la respuesta en video cuando estén presentes |
| Descubra las pistas de subtítulos disponibles | Lista de idiomas de metadatos — hasTranscripts y transcriptLanguages | Metadatos captionTracks — Códigos de idioma y detalles de seguimiento |

### Mantenga la selección de subtítulos y la evidencia explícita

| Característica | FlashData | ScrapeCreators |
| --- | --- | --- |
| Texto y marcas de tiempo de la misma respuesta. | Texto completo + segmentos cronometrados — Start/end veces en segundos | Texto completo + segmentos cronometrados — startMs/endMs como cuerdas de milisegundos |
| Varios idiomas de subtítulos en una sola solicitud | Hasta 10 idiomas — Pistas existentes más errores por idioma | Un idioma seleccionado — idioma o original_audio selección por llamada de expediente académico |
| Elija el origen del título explícitamente | Cargador o generado por YouTube — params.auto selecciona un origen | Selección de idioma y audio hablado — original_audio no es un cambio de origen de subtítulos |
| Manejo de subtítulos faltantes | Pistas existentes y errores explícitos — Las matrices de idiomas preservan las pistas exitosas e informan sobre las selecciones faltantes | Campos de transcripción nulos — Las pistas solicitadas que faltan cuestan cero créditos; no YouTube transcripción AI |
| Elija la antigüedad de los datos reutilizados | Política de caché en su aplicación — Ahorre tiempos de recuperación y decida cuándo recuperarlos nuevamente | cache_max_age — Opciones de 1–30 días; los accesos al caché cuestan cero créditos y exponen cached_at |

### Ejecute un flujo de trabajo de datos repetible

| Característica | FlashData | ScrapeCreators |
| --- | --- | --- |
| Procesar un archivo de video guardado IDs | Trabajos masivos gestionados — Envíe el archivo, realice un seguimiento de su trabajo y recupere los resultados. | Llamadas a terminales por vídeo — Administre el bucle de archivos y el almacenamiento de resultados en su integración |
| Mover colecciones largas a trabajos en segundo plano | API asíncronas, por lotes y masivas — Persistir en el trabajo IDs, realizar un seguimiento del estado y recuperar resultados | Llamadas YouTube sincrónicas — Llamadas por video en cola y punto de control en su trabajador |
| Salida estructurada y legible | JSON, texto sin formato o Markdown — Seleccionado a través de API encabezados de respuesta | Formatos JSON API y CLI — CLI también exporta CSV, tablas y Markdown |
| Instalación de terminales | Ejecutable independiente — Linux, macOS y Windows; sin Nodo/Python tiempo de ejecución | npm CLI — @scrapecreators/cli |
| MCP y habilidades de agente | si | si |
| Continuar desde los datos hasta la entrega de medios alojados | si — YouTube Descargue a su almacenamiento; permiso separado y precio basado en GB | Flujo de trabajo de descarga separado — YouTube Las API de transcripción y metadatos no entregan archivos multimedia |

Ambos ofrecen acceso prepago, MCP, CLI y habilidades de agente. ScrapeCreators también cubre otras plataformas sociales y YouTube comentarios. Los accesos de caché admitidos son gratuitos.

### Actualiza los vídeos que te interesan

Las tasas de uso más bajas por solicitud son importantes cuando actualiza las métricas cambiantes o recopila subtítulos para videos nuevos. Mantenga las transcripciones guardadas y solicite metadatos solo cuando sea necesario actualizarlos.

### Comience con una compra más pequeña

Las recargas de crédito de FlashData comienzan en $10. Primero mueva una carga de trabajo YouTube, mientras su integración existente continúa manejando comentarios y otras plataformas sociales.

### Elija la pista de subtítulos exacta

Seleccione explícitamente los subtítulos proporcionados por el usuario o generados por YouTube. Solicite hasta 10 idiomas existentes en una solicitud de transcripción y maneje el resultado de cada idioma por separado.

<a id="costs"></a>
## Compare solicitudes nuevas, aciertos de caché y compras iniciales

| ScrapeCreators oferta | Compra única | Créditos | Por 1,000 llamadas nuevas de un crédito | Cuota mensual |
| --- | --- | --- | --- | --- |
| Oferta inicial gratuita | $0 | 100 una vez | Asignación inicial gratuita | $0 |
| Freelance | $47.00 | 25,000 | $1.88 | $0 |
| Business | $497.00 | 500,000 | $0.994 | $0 |
| Empresa | personalizado | 1,000,000+ | personalizado | $0 para créditos prepago |

Se trata de packs prepago sin renovación mensual. Business es exactamente $0.994 por 1,000 llamadas de un crédito; $0.99 está redondeado. Los créditos adquiridos no tienen vencimiento bajo la póliza actual. Los créditos de bonificación iniciales y obtenidos están excluidos del modelo.

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

FlashData los recuentos de solicitudes incluidas asignan el saldo compartido completo a los datos YouTube estándar. La búsqueda extendida y la descarga tienen tarifas separadas. [Precio completo](https://flashdata.dev/es/pricing/youtube-data).

### Ejemplo: metadatos y subtítulos para 1,000 vídeos

2,000 solicitudes, sin búsquedas de descubrimiento. FlashData pago sobre la marcha frente a ScrapeCreators Freelance. Cuente únicamente los aciertos de caché observados; Las solicitudes evitadas a través de su propio almacenamiento local no se envían a ninguno de los proveedores.

| Visitas de caché gratuitas | FlashData llamadas | FlashData uso | FlashData compra | ScrapeCreators créditos | ScrapeCreators valor de uso | ScrapeCreators compra |
| --- | --- | --- | --- | --- | --- | --- |
| 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 mes de solicitudes. Una nueva búsqueda de metadatos, un resultado de subtítulos nativos o una solicitud de búsqueda estándar utiliza un crédito ScrapeCreators. Los metadatos más subtítulos utilizan dos solicitudes en ambos lados. Solo se deducen los aciertos de caché de metadatos/transcript ingresados ​​anteriormente; No se asume el almacenamiento en caché de búsqueda. Este modelo cuenta los subtítulos devueltos, no los intentos de pérdida de pista y excluye la generación de IA. FlashData utiliza su estándar actual YouTube Precios de datos, asignando toda la asignación del plan seleccionado antes del uso adicional. La búsqueda extendida y la descarga tienen un precio por separado. Se excluyen los saldos iniciales, las pruebas, los créditos de bonificación, los impuestos y otros usos. Las compras comienzan con saldo cero: las recargas de FlashData tienen un mínimo de $10; ScrapeCreators las compras se redondean a paquetes completos seleccionados. Los créditos comprados no utilizados pueden servir para tareas posteriores. ScrapeCreators no tiene renovación de paquete mensual; un plan mensual FlashData seleccionado todavía tiene su tarifa sin solicitudes.

### Comportamiento de caché

En los puntos finales/transcript de metadatos admitidos, cache_max_age acepta 1d, 3d, 7d, 14d o 30d. Los hits usan cero créditos y reportan cached_at; Los errores utilizan la tarifa normal. No se asumen aciertos en la caché de búsqueda. Decida si los datos guardados son lo suficientemente recientes para la tarea. [Guardar y reutilizar resultados](https://flashdata.dev/es/docs/guides/save-results/reference.md).

### Ofertas iniciales

ScrapeCreators comienza con créditos gratuitos 100. Los registros FlashData verificados eligibles pueden recibir una asignación inicial de hasta las solicitudes 4,000 estándar YouTube Data. Estas ofertas no se restablecen mensualmente. A continuación se presenta el ensayo del agente temporal separado.

<a id="migration"></a>
## Migrar un video y sus marcas de tiempo de subtítulos

### 1. Configura el acceso y elige la pista

Cree o reutilice una clave con el permiso youtube_transcript, más youtube_metadata para la llamada de metadatos opcional. [API Claves](https://flashdata.dev/app/api-keys) · [Créditos](https://flashdata.dev/app/billing). Almacene FLASHDATA_API_KEY en el entorno o utilice el mensaje oculto del script; nunca lo pegues en el chat.

Solicitud existente, solo para mapeo:

```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 y este JSON cuerpo:

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

original_audio=true elige el idioma hablado. FlashData params.auto=true selecciona subtítulos generados por YouTube. Especifique el idioma y el origen por separado.

### 2. Guarde el script antes de running.

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 creator-research.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")
    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'))}")

```

Ejecute desde esa carpeta usando un video con una pista en inglés existente. Los metadatos son una solicitud opcional independiente; en una prueba temporal, deje al menos un segundo entre llamadas.

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

Para los subtítulos proporcionados por quien subió el video, agregue --origin manual. El valor predeterminado son los subtítulos en inglés generados por YouTube.

Alternativamente, use Bash, cURL 7.76+ y jq 1.6+. Guarde el script completo a continuación como creator-research.sh en una nueva carpeta de trabajo.

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

Para ver los subtítulos proporcionados por quien subió el video, adjunte el manual. Cada nueva carpeta de salida envía una solicitud. Los mismos argumentos y carpetas reutilizan la salida guardada; use una nueva carpeta para una actualización intencional después de inspeccionar el intento anterior.

### 3. Leer la salida asignada y el uso real

capciones...001/normalized.json es un adaptador de campo; response.json conserva la respuesta cruda y el uso real. Los segundos se convierten en milisegundos de cuerda. languageCode y isAutoGenerated preservan la pista seleccionada. Esto no es una respuesta completa desplegable: no hay saldos de crédito manufacturados, banderas de caché, atribución del cargador o campos de fecha. Los metadatos conservan las métricas que faltan null y su fecha original 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 integración | FlashData cambio |
| --- | --- |
| GET /v1/youtube/video?url=… | POST la consulta API con fuente: youtube_metadata y video_id. Lea los resultados [0], no la raíz de respuesta. |
| GET /v1/youtube/video/transcript?url=… | Fuente de uso: youtube_transcript. Establezca params.language y params.auto explícitamente. |
| transcripción[].startMs / endMs | FlashData inicio/fin son segundos. Multiplique cada uno por 1,000 y serialícelos como cadenas para un lector de milisegundos existente. |
| original_audio=true | Selecciona el idioma hablado en ScrapeCreators, no subtítulos generados automáticamente. Resuelva el idioma requerido en su aplicación; params.auto selecciona el origen del título en su lugar. |
| idioma y transcript_only_text | Mapa languageName y fullText. Mantenga languageCode por separado; un nombre de idioma y un código de idioma son campos diferentes. |
| viewCountInt, likeCountInt, commentCountInt | Mapa viewCount, likeCount, commentCount. Conservar null cuando falta una métrica. |
| durationMs y publishDate | Convierta segundos de duración a milisegundos. Conserve uploadDate como campo sin formato hasta que su aplicación valide el formato de fecha que necesita. |
| canal / cargador / ownerByline | FlashData canal y channelId no reproducen las tres identidades. Asigne sólo los campos que su lector necesita; mantenga una ruta separada para la atribución de créditos musicales. |
| cached, cached_at, credits_charged | Mantenga la respuesta y el uso sin procesar FlashData. Registre su propio tiempo de recuperación; no fabrique indicadores de caché de proveedores ni traduzca saldos de crédito entre proveedores. |

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

### Si la primera solicitud falla

- 401/403: verifique la clave guardada y el permiso de origen; deténgase si es revocado.
- 402: reponer el saldo del propietario antes de continuar.
- 429: lee el encabezado Retry-After guardado; reducir la frecuencia de las solicitudes. Las pruebas temporales permiten una solicitud por segundo.
- Pista faltante: verificar idioma y origen disponibles. ScrapeCreators puede devolver una respuesta exitosa con una transcripción null; No confunda esto con una pista completed FlashData.
- Tiempo de espera agotado o carpeta incompleta: inspeccione el historial y la salida antes de volver a intentarlo. Los scripts conservan el intento sin volver a enviarlo automáticamente.

[Errores y códigos de estado.](https://flashdata.dev/es/docs/errors/reference.md)

<a id="workflow"></a>
## Buscar → preseleccionar → enriquecer → citar

| paso | trabajo | Recuento de solicitudes |
| --- | --- | --- |
| Descubrir | Ejecute P YouTube Solicitudes de búsqueda | P solicitudes de búsqueda estándar. Cuente las solicitudes reales, no todos los videos devueltos, como una búsqueda separada. |
| Seleccionar | Deduplicar y preseleccionar N video IDs | Filtrado local; Aún no hay solicitud de metadatos ni subtítulos. |
| Enriquecer | Obtenga metadatos para los preseleccionados IDs | N solicitudes de metadatos; repita solo cuando sea necesario actualizar las métricas. |
| citar | Obtenga una pista de subtítulos existente por ID | N solicitudes de expedientes académicos cuando estén disponibles. Almacene el idioma, el origen y los tiempos de referencia con la fuente URL. |
| Reutilizar | Leer los resultados guardados para la siguiente tarea | No hay solicitud del proveedor cuando su aplicación puede reutilizar su propio archivo guardado. |

10 solicitudes de búsqueda más 50 videos preseleccionados con metadatos y subtítulos requieren 110 solicitudes estándar antes de su reutilización local. Separe los costos de descubrimiento de los de enriquecimiento. Un resultado de búsqueda no es en sí mismo una solicitud de búsqueda independiente.

### La búsqueda no es una migración directa del cursor

ScrapeCreators puede devolver varios tipos de resultados con continuationToken. La búsqueda estándar de FlashData devuelve resultados de vídeo; su búsqueda extendida tiene límites y precios separados. Inicie una nueva ejecución de descubrimiento en lugar de reutilizar un cursor antiguo.

[YouTube Buscar referencia](https://flashdata.dev/es/docs/sources/youtube_search/reference.md)

### Mantenga evidencia con la respuesta.

Almacene el video ID, URL, el idioma elegido, el origen de los subtítulos y la hora de inicio del segmento. Un enlace de cita puede apuntar a esa marca de tiempo. No etiquete una pista de subtítulos faltante como una transcripción exitosa vacía.

[Receta de subtítulos con marca de tiempo](https://flashdata.dev/es/docs/guides/timestamped-captions-recipe/reference.md)

### Scale la lista ID por separado

Después de que una búsqueda funcione, utilice batch solicitudes para una lista o procesamiento masivo para un archivo. Realice un seguimiento del trabajo IDs, guarde completed salidas y vuelva a intentarlo solo failed elementos. Haga que su corredor sea responsable del horario.

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

<a id="agents"></a>
## Probar la migración antes de programarla

Los agentes eligibles pueden empezar con 1 credit (hasta 100 estándar YouTube Solicitudes de datos 72 horas. Los metadatos, las subtítulos y la búsqueda comparten el subsidio.

1. Inspeccione los campos obligatorios, la intención de los subtítulos y su actualidad. Reutilizar el acceso guardado; mantener llamadas de datos sociales no relacionadas.
2. Ejecute un video conocido usando CLI, SDK o MCP. Guarde la salida y verifique el tiempo, los nulos y el uso real.
3. El propietario inicia sesión o se registra, verifica el correo electrónico y aprueba los reclamos, los alcances y el uso del saldo compartido. Los créditos de prueba no utilizados no se transfieren.
4. Conservar la credencial de propietario para uso recurrente. Reutilizar las salidas y detenerlas en caso de revocación o saldo insuficiente.

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

[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 configuración](https://flashdata.dev/es/docs/integrations/mcp-clients/reference.md)

<a id="faq"></a>
## Antes de cambiar

### ¿Son estas suscripciones mensuales?

ScrapeCreators Freelance y Business son paquetes prepago, no suscripciones. Ambos tienen una cuota mensual de $0. FlashData tiene créditos de pago por uso más planes mensuales opcionales. Compare el uso consumido y la compra necesaria de su saldo actual por separado.

### ¿Qué pasa si la mayoría de mis ScrapeCreators solicitudes se almacenan en caché?

Los hits de caché de transcripciones y metadatos admitidos no cuestan créditos. Ingrese esos aciertos observados en la calculadora. Si su aplicación acepta su antigüedad, pueden costar menos que las nuevas FlashData solicitudes. También puede guardar la salida de cualquiera de los proveedores localmente y evitar por completo realizar la siguiente solicitud.

### ¿Caducan los créditos no utilizados?

ScrapeCreators dice que los créditos comprados no vencen según su política actual. Su oferta inicial gratuita de 100 crédito no es una recarga mensual. La prueba de agente temporal de FlashData expira; sus páginas de precios y cuenta describen los términos aplicables del saldo del propietario.

### ¿Funcionará original_audio=true como params.auto=true?

No. El primero elige un idioma en función del audio hablado; el segundo elige subtítulos generados por YouTube. Establece un idioma y un origen deliberadamente. El punto final de subtítulos nativos de ninguno de los servicios crea voz a texto cuando no hay una pista coincidente.

### ¿Puedo reemplazar todas mis llamadas de datos sociales?

Esta migración cubre YouTube metadatos de vídeo y subtítulos existentes. Mantenga los comentarios, publicaciones comunitarias, perfiles sociales y cualquier otro campo de respuesta no admitido en su ruta existente. FlashData también ofrece Google Búsqueda y YouTube Descarga alojada, con sus propios permisos y precios.

### ¿ScrapeCreators también admite agentes de IA?

Sí. Ofrece MCP, OAuth, a CLI y habilidades de agente. El flujo de agentes de FlashData agrega una prueba temporal elegible, el propietario reclama y guarda credenciales para uso continuo. Elija el API y el flujo de trabajo que necesita su tarea; MCP el apoyo por sí solo no es la diferencia.
