# Bright Data Alternativa para YouTube Datos

Compare FlashData YouTube solicitudes con Bright Data registros raspadores: tarifas pagadas, asignaciones mensuales, límites de trabajo y Python/Bash migración de instantáneas a trabajos guardados.

Cree investigaciones de vídeo en torno a las solicitudes de fuentes. Compare toda la tarea y luego mueva un flujo de trabajo instantáneo a trabajos guardados y reanudables.

Esta es la comparación YouTube. [Bright Data Alternativa para Google Buscar](https://flashdata.dev/es/compare/brightdata/reference.md) es una página separada.

Los hechos de Bright Data revisaron 2026-11-10. Las tarifas y los subsidios FlashData utilizan sus catálogos públicos actuales.

- [Características](#features)
- [Precios](#pricing)
- [Cuotas y límites](#limits)
- [Migrar un trabajo](#migration)
- [Flujos de trabajo de agentes](#agents)
- [Preguntas frecuentes](#faq)

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

### Costos pagados más bajos por búsquedas de videos enfocadas

| Característica | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Búsqueda de metadatos pagada · 1,000 vídeos | $0.50 — 1,000 solicitudes de fuente · PAYG | $1.50 — 1,000 registros de vídeo entregados · PAYG |
| Metadatos + subtítulos existentes · 1,000 vídeos | $1.00 — 2,000 solicitudes de origen · PAYG | $1.50 — 1,000 registros de video cuando se incluyen campos de subtítulos |
| Plan mensual de entrada | $49.00 — Micro/mes; saldo de uso compartido incluido | $499 — Registros Scale/mes · 384,000 incluidos |
| Paga sobre la marcha sin suscripción mensual | si | si |

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

| Característica | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Descubra vídeos por palabra clave | si — Busque con filtros de fecha, duración, tipo y clasificación | si — Modos de descubrimiento de palabras clave y filtros de búsqueda |
| Metadatos de un vídeo conocido | si — Título, canal, duración, miniaturas y recuentos de participación. | si — Registros de vídeo con campos de identidad, canal y participación. |
| Marcadores de capítulos para la navegación. | si — include_chapters; tiempos de capítulo en segundos | si — Títulos de capítulos, vistas previas y horas de inicio en milisegundos |
| Descubra los idiomas de subtítulos disponibles | Lista de idiomas en metadatos | Lista de pistas en la grabación de vídeo. — Incluye información de idioma y subtítulos automáticos. |

### Hacer que los subtítulos se puedan utilizar como evidencia

| Característica | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Solicitar subtítulos sin actualizar metadatos | Fuente de transcripción dedicada — Una solicitud estándar por vídeo | Campos de subtítulos en el registro de video — YouTube Rascador de vídeos |
| Solicitar varios idiomas de subtítulos | Hasta 10 idiomas explícitos — Pistas más errores por idioma | Un idioma seleccionado — Seleccione el idioma al recopilar la grabación de vídeo. |
| Seleccione el cargador o el origen de los subtítulos automáticos | si — params.auto selecciona un origen sin respaldo de origen cruzado | Origen mostrado en los metadatos de la pista — No se incluye ninguna entrada de selección de origen para el raspador de videos revisados |
| Texto completo y citas con marca de tiempo. | Texto completo + segmentos cronometrados — Start/end veces en segundos | Texto completo + segmentos cronometrados — Inicio, fin y duración del segmento en milisegundos |

### Ejecute la colección en su aplicación o agente

| Característica | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Colección interactiva y de fondo. | En tiempo real o async — Elija el modo; guarde el trabajo ID para trabajo en segundo plano | Raspado de sincronización o disparador async — El trabajo de sincronización que supere un minuto continúa como una instantánea |
| Procesar una gran lista preparada | Bulk Jobs con un archivo de vídeo-ID — Consola o API; partes de progreso, manifiesto y resultado | Lotes de entrada asíncronos — Activar una colección y recuperar o entregar su instantánea |
| Salida para aplicaciones y LLM | JSON, texto sin formato o Markdown | Formatos de exportación de instantáneas — JSON, NDJSON y CSV |
| Conservar completed resultados para análisis posteriores | Guarde resultados o utilice almacenamiento masivo — Mantenga los datos sin procesar y los manifiestos en su propio almacenamiento. | Instantáneas y entrega de almacenamiento — Instantáneas retenidas durante 30 días |
| Cliente terminal independiente | Nativo CLI — Linux, macOS y Windows; sin Nodo/Python tiempo de ejecución | Node.js CLI — comando bdata instalado por npm |
| MCP, habilidades y SDK acceso | si | si |

Las tarifas pagadas excluyen los subsidios gratuitos. Ambos ofrecen async trabajos, recolección masiva y herramientas para agentes. Mantenga la recopilación de comentarios, otras plataformas sociales, conjuntos de datos administrados y las integraciones de almacenamiento y entrega existentes cuando sea necesario.

### Paga por los campos que tu tarea necesita

Obtenga metadatos para su lista corta. Solicite subtítulos solo para los videos que analizará. No es necesario repetir el paso de transcripción para actualizar los metadatos.

### Elija la pista de subtítulos explícitamente

Solicite un idioma y seleccione subtítulos proporcionados por el usuario o generados por YouTube. Mantenga visibles los errores de idioma en lugar de cambiar silenciosamente los datos de la investigación.

### Mantenga el trabajo en todas las sesiones del agente

Guarde el trabajo aceptado ID antes de realizar la encuesta. Un proceso posterior reanuda el mismo trabajo y reutiliza el resultado descargado sin enviar otra consulta.

<a id="pricing"></a>
## Compara la tarea de video completa

El registro de vídeo de Bright Data puede incluir metadatos y subtítulos. FlashData utiliza una solicitud de metadatos y una solicitud de título independiente. Una entrada de descubrimiento puede devolver muchos registros facturables; Esta calculadora cubre únicamente búsquedas de videos conocidos.

| Bright Data YouTube oferta | Cuota mensual | Registros incluidos | Tarifa pagada / 1,000 registros |
| --- | --- | --- | --- |
| Grupo gratuito elegible | $0 | Hasta 5,000/mes compartido entre productos elegibles | dentro de la asignación |
| Pago por uso | $0.00 | Sin asignación de plan pago | $1.50 |
| Scale · $499/month | $499.00 | 384,000 | $1.30 additional |
| Empresa | personalizado | personalizado | personalizado |

Scale incluye 384,000 registros para $499/mes; Los registros adicionales cuestan $1.30 por 1,000. No se modelan las coincidencias de depósitos promocionales y de Custom Enterprise.

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

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

### 10,000 vídeos: pago por uso en ambos lados

| Tarea | FlashData solicitudes | FlashData factura modelada | Bright Data registros gratuitos aplicados | Bright Data factura modelada |
| --- | --- | --- | --- | --- |
| Metadatos de vídeo | 10,000 | $5.00 | 0 | $15.00 |
| Metadatos de vídeo | 10,000 | $5.00 | 5,000 | $7.50 |
| Metadatos + subtítulos existentes | 20,000 | $10.00 | 0 | $15.00 |
| Metadatos + subtítulos existentes | 20,000 | $10.00 | 5,000 | $7.50 |

USD por un mes de búsquedas de videos exitosas. Un registro de vídeo Bright Data devuelto puede contener metadatos y subtítulos existentes; la tarea FlashData combinada utiliza dos solicitudes de origen. Se excluyen el descubrimiento, los comentarios, la transcripción de IA, la búsqueda extendida y las descargas de medios. Ingrese solo Bright Data créditos gratuitos aún disponibles para estos registros; el grupo de créditos 5,000 se comparte y los créditos gratuitos recurrentes no se acumulan con Scale. FlashData los precios provienen de su catálogo público vigente; todo el saldo del plan seleccionado se asigna aquí antes del uso adicional. FlashData Se excluyen los saldos iniciales y las pruebas de registro/agent. La factura modelada mide el uso más cualquier tarifa mensual, no una nueva compra de billetera: FlashData las recargas comienzan en $10. No se incluyen impuestos, promociones de igualación de depósitos, tarifas personalizadas ni descuentos anuales.

### Ofertas iniciales

Los registros FlashData verificados eligibles pueden recibir una asignación inicial de hasta las solicitudes 4,000 estándar YouTube Data. Este es un saldo inicial, no una cuota mensual recurrente.

Las cuentas Bright Data elegibles reciben 5,000 créditos gratuitos por mes compartidos entre productos elegibles, incluido Scraper API. Un registro YouTube entregado consume un crédito. Los créditos gratuitos no utilizados no se acumulan; Las cuentas con compromiso previo no reciben créditos gratuitos recurrentes. No apile el fondo mensual gratuito con Scale.

<a id="limits"></a>
## Asignaciones, batch tamaños y running puestos de trabajo

| Preocupación | FlashData | Bright Data Rascador API |
| --- | --- | --- |
| ¿Qué consume la asignación? | Cada consulta de origen; los metadatos y los subtítulos están separados | Registros entregados exitosamente; una entrada de descubrimiento puede devolver muchas |
| Una solicitud interactiva | POST /v1/queries/realtime; elija async para el trabajo en segundo plano | POST /datasets/v3/scrape; después de 1 minuto, HTTP 202 devuelve una instantánea ID y el trabajo continúa |
| Entradas más grandes | El tamaño del lote depende del plan; utilice el procesamiento masivo para un archivo de IDs | Async /trigger acepta hasta 1 GB de entrada; El recuento mínimo de entrada depende del raspador. |
| Trabajo corriendo | La simultaneidad de la cuenta depende del plan seleccionado, como se muestra a continuación | 5,000 trabajos activos/snapshots; exceder el límite de retornos 429 |
| Retroceder | Honor Retry-After; Las pruebas de agentes temporales permiten una solicitud por segundo. | Honor Retry-After; 25 HTTP 429 respuestas por IP en 5 minutos pueden desencadenar un bloqueo de 1 horas API |
| Resultados guardados | Descargue y guarde el JSON en su propio almacenamiento de tareas | Instantáneas retenidas durante 30 días; las solicitudes de descarga admiten hasta 5 GB, con recuperación basada en partes para obtener resultados más grandes |

| FlashData plano | Consultas simultáneas | Consultas por solicitud de lote |
| --- | --- | --- |
| Pago por uso | 25 | 100 |
| Micro | 50 | 100 |
| Starter | 100 | 200 |
| Pro | 200 | 300 |
| Scale | 300 | 400 |
| Business | 400 | 500 |

La simultaneidad no son solicitudes por segundo. Los créditos aún se aplican a cada consulta. [Tiempo real y async](https://flashdata.dev/es/docs/reference/realtime-and-async/reference.md) · [Lote y a granel](https://flashdata.dev/es/docs/reference/batch-and-bulk/reference.md) · [Referencia de procesamiento masivo](https://flashdata.dev/es/docs/reference/bulk-processing/reference.md).

<a id="migration"></a>
## De una instantánea a un trabajo guardado

### 1. Preparar el acceso y mapear la solicitud.

Cree o reutilice una clave con el permiso youtube_metadata. [API Claves](https://flashdata.dev/app/api-keys) · [Créditos disponibles](https://flashdata.dev/app/billing). Guarde FLASHDATA_API_KEY en un almacén secreto o ingréselo en el mensaje oculto del script.

Envío Bright Data existente, para referencia de migración:

```bash
# Existing Bright Data job submission, for migration reference.
curl --fail-with-body --silent --show-error --max-time 120 \
  --request POST \
  'https://api.brightdata.com/datasets/v3/trigger?dataset_id=gd_lk56epmy2i5g7lzu0k&format=json' \
  --header "Authorization: Bearer $BRIGHTDATA_API_KEY" \
  --header 'Content-Type: application/json' \
  --data '{"input":[{"url":"https://www.youtube.com/watch?v=FUfGcZ092b0"}]}'
```

FlashData POST https://data.flashdata.dev/v1/queries con X-API-Key:

```json
{
  "source": "youtube_metadata",
  "video_id": "FUfGcZ092b0",
  "params": {
    "include_formats": false,
    "include_chapters": true
  }
}
```

### 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 migrate-video.py antes de ejecutarlo.

```python
# Save as migrate-video.py in your working folder.
import argparse
import getpass
import json
import os
import re
import time
from pathlib import Path
from urllib.parse import urlsplit

import requests

parser = argparse.ArgumentParser()
parser.add_argument("video_id")
parser.add_argument("folder", help="A new folder name, such as video-001")
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")
if not re.fullmatch(r"[A-Za-z0-9_-]+", args.folder):
    raise SystemExit("Use a simple output folder name")
os.umask(0o077)
out = Path(args.folder)
body = {"source": "youtube_metadata", "video_id": args.video_id,
        "params": {"include_formats": False, "include_chapters": True}}
key = None

def read(name):
    return json.loads((out / name).read_text(encoding="utf-8"))

def call(method, url, name, payload=None, authenticated=True):
    global key
    headers = {"Accept": "application/json"}
    if authenticated:
        if key is None:
            key = os.environ.get("FLASHDATA_API_KEY") or getpass.getpass("FlashData API key: ")
        if not key.strip():
            raise SystemExit("An API key is required")
        headers["X-API-Key"] = key
    try:
        response = requests.request(method, url, json=payload, headers=headers,
                                    timeout=(10, 120), allow_redirects=False)
    except requests.RequestException:
        raise SystemExit("Network outcome unknown. Keep this folder and check History; do not resubmit.")
    (out / name).write_bytes(response.content)
    (out / (name + ".http")).write_text(str(response.status_code))
    (out / "retry-after.txt").write_text(response.headers.get("Retry-After", ""))
    return response

if not out.exists():
    out.mkdir()
    (out / "request.json").write_text(json.dumps(body), encoding="utf-8")
    submitted = call("POST", "https://data.flashdata.dev/v1/queries", "submission.json", body)
    if submitted.status_code not in (200, 201, 202):
        raise SystemExit(f"HTTP {submitted.status_code}. Inspect submission.json and retry-after.txt.")
else:
    try:
        if read("request.json") != body:
            raise SystemExit("This folder belongs to another request. Use a new folder.")
    except (OSError, ValueError):
        raise SystemExit("Incomplete attempt. Check the folder and History before resubmitting.")
try:
    receipt = read("submission.json")
    job_id = receipt["id"]
    status = (out / "submission.json.http").read_text().strip()
    if status not in ("200", "201", "202") or receipt["source"] != body["source"] or not re.fullmatch(r"[A-Za-z0-9_-]+", job_id):
        raise ValueError()
except (OSError, ValueError, KeyError, TypeError):
    raise SystemExit("No valid saved receipt. Check History; this script will not submit again.")

if not (out / "result.json").exists():
    url = "https://api.flashdata.dev/v2/jobs/" + job_id
    for attempt in range(12):
        response = call("GET", url, "job.json")
        if response.status_code != 200:
            raise SystemExit(f"HTTP {response.status_code}. Resolve the error; then resume this folder.")
        job = response.json()["job"]
        if job["id"] != job_id or job["source"] != body["source"]:
            raise SystemExit("Job does not match the saved receipt")
        if job["status"] == "completed":
            break
        if job["status"] not in ("pending", "processing"):
            raise SystemExit("Job " + job["status"] + ". Inspect job.json; do not resubmit.")
        delay = response.headers.get("Retry-After", "5")
        if attempt == 11 or not delay.isdigit() or int(delay) > 60:
            raise SystemExit("Still running. Wait for Retry-After, then run the same command to resume.")
        time.sleep(max(1, int(delay)))
    result = call("GET", url + "/results", "result.pending.json")
    if result.status_code == 302:
        location = result.headers.get("Location", "")
        parsed = urlsplit(location)
        if parsed.scheme != "https" or not parsed.hostname or parsed.username or parsed.password:
            raise SystemExit("Expected an HTTPS storage URL")
        # Separate request: the API key is never sent to storage.
        result = call("GET", location, "result.pending.json", authenticated=False)
    if result.status_code != 200:
        raise SystemExit(f"HTTP {result.status_code}. Resolve the error, then resume this folder.")
    data = result.json()
else:
    print("Reading saved result; no API call.")
    data = read("result.json")
if not isinstance(data, dict) or data.get("source") != body["source"] or data.get("status") != "done":
    raise SystemExit("Result did not complete successfully")
items = data.get("results")
if not isinstance(items, list) or len(items) != 1 or not isinstance(items[0], dict) or items[0].get("videoId") != args.video_id:
    raise SystemExit("Expected the requested video in results")
item = items[0]
mapped = [{"video_id": item["videoId"], "url": "https://www.youtube.com/watch?v=" + item["videoId"],
           "title": item.get("title"), "description": item.get("description"),
           "views": item.get("viewCount"), "likes": item.get("likeCount"),
           "num_comments": item.get("commentCount"), "video_length": item.get("duration"),
           "channelName": item.get("channel"), "channelId": item.get("channelId"),
           "uploadDateRaw": item.get("uploadDate"), "captionLanguages": item.get("transcriptLanguages")}]
if not (out / "result.json").exists():
    (out / "result.pending.json").replace(out / "result.json")
(out / "video-records.json").write_text(json.dumps(mapped, ensure_ascii=False, indent=2), encoding="utf-8")
print(f"Saved {out}/video-records.json; actual usage: {json.dumps(data.get('usage'))}")

```

Ejecutar desde la misma carpeta:

```bash
python migrate-video.py FUfGcZ092b0 video-001
```

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

```bash
#!/usr/bin/env bash
# Save as migrate-video.sh in your working folder.
set -euo pipefail
umask 077
video_id="${1:?Use: VIDEO_ID OUTPUT_FOLDER}"
out="${2:?Use a folder name such as video-001}"
[[ "$video_id" =~ ^[A-Za-z0-9_-]{11}$ && "$out" =~ ^[A-Za-z0-9_-]+$ ]] || exit 2
body=$(jq -n --arg id "$video_id" '{source:"youtube_metadata", video_id:$id,
  params:{include_formats:false, include_chapters:true}}')
call() {
  local method="$1" url="$2" name="$3" authenticated="$4" payload="${5:-}"
  local -a options=(--silent --show-error --compressed --proto '=https'
    --connect-timeout 10 --max-time 120 --request "$method"
    --header 'Accept: application/json' --output "$out/$name"
    --dump-header "$out/$name.headers" --write-out '%{http_code}')
  if [[ "$authenticated" == yes ]]; 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}"
    options+=(--header "X-API-Key: $FLASHDATA_API_KEY")
  fi
  if [[ -n "$payload" ]]; then options+=(--header 'Content-Type: application/json' --data-binary "$payload"); fi
  curl "${options[@]}" "$url" > "$out/$name.http" || {
    echo 'Network outcome unknown. Keep this folder and check History; do not resubmit.' >&2; exit 1;
  }
  status=$(cat "$out/$name.http")
}
if [[ ! -e "$out" ]]; then
  mkdir -- "$out"
  printf '%s\n' "$body" > "$out/request.json"
  call POST 'https://data.flashdata.dev/v1/queries' submission.json yes "@$out/request.json"
  [[ "$status" =~ ^20[012]$ ]] || { echo "HTTP $status. Inspect submission.json and its headers." >&2; exit 1; }
else
  jq -e --argjson expected "$body" '. == $expected' "$out/request.json" >/dev/null || {
    echo 'Incomplete or different request. Check this folder and History.' >&2; exit 1;
  }
fi
[[ "$(cat "$out/submission.json.http")" =~ ^20[012]$ ]] || exit 1
id=$(jq -er 'select(.source == "youtube_metadata") | .id | select(type == "string" and test("^[A-Za-z0-9_-]+$"))' "$out/submission.json")
if [[ ! -f "$out/result.json" ]]; then
  url="https://api.flashdata.dev/v2/jobs/$id"
  for attempt in {1..12}; do
    call GET "$url" job.json yes
    [[ "$status" == 200 ]] || { echo "HTTP $status. Inspect job.json and its headers; resume after resolving." >&2; exit 1; }
    state=$(jq -er --arg id "$id" 'select(.job.id == $id and .job.source == "youtube_metadata") | .job.status' "$out/job.json")
    [[ "$state" == completed ]] && break
    [[ "$state" == pending || "$state" == processing ]] || { echo "Job $state. Do not resubmit." >&2; exit 1; }
    delay=$(awk 'tolower($1)=="retry-after:" {sub(/\r$/, "", $2); print $2}' "$out/job.json.headers")
    delay="${delay:-5}"
    [[ "$attempt" -lt 12 && "$delay" =~ ^[0-9]+$ && "$delay" -le 60 ]] || {
      echo 'Still running. Wait for Retry-After, then run the same command to resume.' >&2; exit 1;
    }
    [[ "$delay" -gt 0 ]] || delay=1
    sleep "$delay"
  done
  call GET "$url/results" result.pending.json yes
  if [[ "$status" == 302 ]]; then
    location=$(awk 'tolower($1)=="location:" {sub(/\r$/, "", $2); print $2}' "$out/result.pending.json.headers")
    [[ "$location" =~ ^https://[^/@[:space:]]+(/|$) ]] || { echo 'Expected HTTPS storage URL.' >&2; exit 1; }
    # Separate request, without the API key. Do not add -L to an authenticated request.
    call GET "$location" result.pending.json no
  fi
  [[ "$status" == 200 ]] || { echo "HTTP $status. Resolve it, then resume this folder." >&2; exit 1; }
  result="$out/result.pending.json"
else
  echo 'Reading saved result; no API call.'
  result="$out/result.json"
fi
mapped=$(jq -e --arg id "$video_id" '
  if .source != "youtube_metadata" or .status != "done" then error("Result 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 != $id then error("Wrong video") else . end
  | [{video_id:.videoId, url:("https://www.youtube.com/watch?v=" + .videoId), title, description,
      views:.viewCount, likes:.likeCount, num_comments:.commentCount, video_length:.duration,
      channelName:.channel, channelId, uploadDateRaw:.uploadDate, captionLanguages:.transcriptLanguages}]' "$result")
[[ "$result" == "$out/result.json" ]] || mv -- "$result" "$out/result.json"
printf '%s\n' "$mapped" > "$out/video-records.json"
printf 'Saved %s/video-records.json; actual usage: ' "$out"
jq -c '.usage' "$out/result.json"

```

Ejecutar desde la misma carpeta:

```bash
bash migrate-video.sh FUfGcZ092b0 video-001
```

Si sigue siendo running, repita el mismo comando para reanudar el trabajo guardado. Las ejecuciones completadas se reutilizan result.json sin una llamada API. Una nueva carpeta envía una nueva solicitud; verifique el Historial antes de volver a intentar un envío incierto. Mantenga las claves fuera del chat y nunca las reenvíe al almacenamiento firmado URLs.

### 3. Leer el registro mapeado

video-001/video-records.json preserva los nombres comunes de campo de vídeo; result.json conserva datos y usos crudos. Las métricas perdidas permanecen null. channelName es un nombre de pantalla, no una manija; uploadDateRaw no es una fecha normalizada. Los campos de transcripción y medios no están fabricados.

```json
[
  {
    "video_id": "FUfGcZ092b0",
    "url": "https://www.youtube.com/watch?v=FUfGcZ092b0",
    "title": "Example video",
    "description": "Example description",
    "views": 1200,
    "likes": null,
    "num_comments": null,
    "video_length": 197,
    "channelName": "Example channel",
    "channelId": "UC_EXAMPLE",
    "uploadDateRaw": "2025-01-15",
    "captionLanguages": [
      "en",
      "es"
    ]
  }
]
```

| Preocupación | Integración existente | FlashData cambio |
| --- | --- | --- |
| Selección de raspador | dataset_id=gd_lk56epmy2i5g7lzu0k | fuente=youtube_metadata; los subtítulos usan youtube_transcript por separado |
| Entrada | Un reloj URL en la matriz de entrada | Un carácter 11 video_id |
| Autenticación | Autorización: Portador | X-API-Key con el permiso de fuente solicitado |
| Enviar | POST /datasets/v3/trigger → snapshot_id | POST /v1/queries → identificación; guardar el recibo |
| Seguimiento | Progreso de la instantánea → ready | GET /v2/jobs/{id} → job.status=completed |
| recuperar | Descargue una instantánea como JSON, NDJSON o CSV | GET /v2/jobs/{id}/results → almacenamiento firmado URL; buscar sin la tecla API |
| Campos de vídeo | video_id, title, description, views, likes, num_comments, video_length | videoId, título, descripción, viewCount, likeCount, commentCount, duración (segundos) |
| Canal y fecha | youtuber es un mango; date_posted es una cita | Mantenga channelName, channelId y uploadDateRaw; no cambie el nombre de un nombre para mostrar a un identificador |
| Transcripción | Puede incluirse como transcripción y formatted_transcript en la grabación del vídeo. | Solicitud de seguimiento independiente; fullText y los segmentos usan segundos. Asigne marcas de tiempo si el analizador existente espera milisegundos |
| Medios directos URL | video_url es una transmisión URL | Utilice el flujo de trabajo de descarga YouTube independiente para la entrega a su almacenamiento |

### Subtítulos opcionales

Conceda permiso youtube_transcript. Envíe este cuerpo a POST https://data.flashdata.dev/v1/queries con X-API-Key y guarde su propio trabajo ID. Esto agrega una solicitud estándar por video:

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

auto=false selecciona los subtítulos proporcionados por quien subió el archivo. Preservar la lengua y el origen. Bright Data los tiempos de transcripción formateados utilizan milisegundos; FlashData los segmentos usan segundos. Multiplique por 1,000 para un analizador que espere milisegundos. [Receta de subtítulos ejecutables con marca de tiempo](https://flashdata.dev/es/docs/guides/timestamped-captions-recipe/reference.md).

### Recuperación

- Pending/processing: reanudar el ID guardado. Votar está ligado y honores numérico Retry-After.
- 401/403: resolver autenticación o permiso; detener la revocación.
- 402: restaura el saldo disponible del propietario antes de continuar.
- 429: dejar de enviar y respetar Retry-After; no reintente automáticamente los envíos.
- Tiempo de espera sin recibo: inspecciona el Historial antes de crear otra carpeta.

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

<a id="agents"></a>
## Una conexión, tareas reutilizables

Los agentes eligibles pueden comenzar con el crédito 1 (hasta las solicitudes de datos 100 estándar YouTube) para horas 72. Reutilizar el acceso guardado primero; los metadatos y las subtítulos comparten la asignación.

1. Descubra vídeos y preseleccione antes de enriquecerlos.
2. Obtenga un video, verifique los campos y la selección de subtítulos y guarde la salida sin procesar.
3. Haga que el propietario complete el registro/sign-in y apruebe los alcances y el saldo compartido. Los créditos temporales no utilizados no se transfieren.
4. Mantenga las credenciales y ejecute carpetas en tareas recurrentes. Reutilice los resultados y deténgalos en caso de revocación o saldo agotado.

```text
Migrate one Bright Data YouTube video lookup to FlashData.
Read https://flashdata.dev/auth.md and reuse saved access first.
Inspect the current video-record parser and list its required fields.
Fetch metadata for one known video. Request captions separately only if needed.
Keep channel handles, dates, caption origin and timestamp units explicit.
Save the submission receipt, job ID, raw JSON and normalized output.
Resume accepted work; do not submit again after a timeout or agent restart.
Verify the output before scheduling. Have the owner claim access and approve
the required permissions and shared balance for continued use.
Keep keys in the host's secret store. Stop on revoked access or insufficient balance.
```

[Juicio y reclamación](https://flashdata.dev/es/docs/guides/agent-onboarding/reference.md) · [Tareas recurrentes](https://flashdata.dev/es/docs/guides/recurring-tasks/reference.md) · [Guardar resultados](https://flashdata.dev/es/docs/guides/save-results/reference.md).

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

### ¿Es esta la comparación de búsqueda Bright Data Google?

Esta página cubre el YouTube Scraper API. Google La búsqueda utiliza el producto SERP de Bright Data, con diferentes unidades de precios y configuración de solicitud. La comparación de búsqueda Google tiene su propia página.

### ¿Bright Data cobra dos veces por los metadatos y una transcripción?

Su esquema de video YouTube incluye metadatos y campos de subtítulos en el registro de video devuelto. No cuente automáticamente dos registros. FlashData utiliza consultas de transcripción y metadatos separados; la carga de trabajo combinada en la calculadora cuenta dos FlashData solicitudes por vídeo. Es posible que un campo de título no esté disponible para un video en particular.

### ¿Qué proveedor tiene la mayor asignación gratuita?

Bright Data ofrece cuentas elegibles 5,000 créditos compartidos cada mes. La asignación de registro elegible de FlashData es un saldo inicial y su prueba de agente temporal es independiente. Estas ofertas tienen diferentes reglas de renovación. Utilice la entrada de registro libre restante para modelar Bright Data PAYG con precisión.

### ¿Puedo reemplazar cada raspador Bright Data?

Mueva los flujos de trabajo de metadatos, búsqueda, canales y subtítulos YouTube compatibles que necesite. Mantenga la recopilación de comentarios, otras plataformas sociales, conjuntos de datos administrados y las integraciones de almacenamiento y entrega existentes donde su aplicación aún dependa de ellos.

### ¿Ambos proveedores admiten agentes de IA?

Sí. Ambos ofrecen MCP, un CLI y habilidades de agente. El CLI independiente de FlashData, los permisos de fuente y el equilibrio de Google/YouTube compartido son útiles para un flujo de trabajo de investigación enfocado. Reutilice el acceso guardado y solicite al propietario que apruebe el acceso continuo a la cuenta antes de programar trabajos recurrentes.

### ¿Puedo reutilizar una instantánea ID después de migrar?

No. Guarde la instantánea Bright Data y el nuevo trabajo FlashData ID como identificadores separados. El ejemplo reutiliza solo su recibo FlashData guardado y verifica que el video devuelto coincida con el ID solicitado.

[Obtener una clave API](https://flashdata.dev/signup) · [Google Comparación de búsqueda](https://flashdata.dev/es/compare/brightdata/reference.md).
