# Bright Data Alternativa para YouTube Dados

Compare solicitações FlashData YouTube com registros de scraper Bright Data: taxas pagas, subsídios mensais, limites de trabalho e migração Python/Bash de instantâneos para trabalhos salvos.

Crie pesquisas de vídeo em torno de solicitações de origem. Compare toda a tarefa e, em seguida, mova um fluxo de trabalho de instantâneo para tarefas salvas e retomáveis.

Esta é a comparação YouTube. [Bright Data Alternativa para Google Pesquisa](https://flashdata.dev/pt/compare/brightdata/reference.md) é uma página separada.

Bright Data fatos revisados 2026-11-10. Taxas e licenças FlashData usam seus catálogos públicos atuais.

- [Recursos](#features)
- [Preços](#pricing)
- [Cotas e limites](#limits)
- [Migrar um trabalho](#migration)
- [Fluxos de trabalho do agente](#agents)
- [Perguntas frequentes](#faq)

<a id="features"></a>
## Comparação de funcionalidades

### Custos pagos mais baixos para pesquisas de vídeo focadas

| Recurso | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Pesquisa de metadados pagos · 1,000 vídeos | $0.50 — 1,000 solicitações de origem · PAYG | $1.50 — 1,000 registros de vídeo entregues · PAYG |
| Metadados + legendas existentes · 1,000 vídeos | $1.00 — 2,000 solicitações de origem · PAYG | $1.50 — 1,000 gravações de vídeo quando campos de legenda são incluídos |
| Plano mensal de entrada | $49.00 — Micro/mês; saldo de uso compartilhado incluído | $499 — Scale/mês · Registros 384,000 incluídos |
| Pague conforme o uso, sem uma assinatura mensal | Sim | Sim |

### Encontre vídeos e crie uma biblioteca de pesquisa

| Recurso | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Descubra vídeos por palavra-chave | Sim — Pesquise com filtros de data, duração, tipo e classificação | Sim — Modos de descoberta de palavras-chave e filtros de pesquisa |
| Metadados de um vídeo conhecido | Sim — Título, canal, duração, miniaturas e contagens de engajamento | Sim — Registros de vídeo com campos de identidade, canal e engajamento |
| Marcadores de capítulo para navegação | Sim — include_chapters; tempos de capítulo em segundos | Sim — Títulos de capítulos, visualizações e horários de início em milissegundos |
| Descubra os idiomas de legenda disponíveis | Lista de idiomas em metadados | Lista de faixas na gravação de vídeo — Inclui informações de idioma e legenda automática |

### Torne as legendas utilizáveis como evidência

| Recurso | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Solicite legendas sem atualizar metadados | Fonte de transcrição dedicada — Uma solicitação padrão por vídeo | Campos de legenda na gravação de vídeo — YouTube Raspador de vídeos |
| Solicite vários idiomas de legenda | Até 10 idiomas explícitos — Faixas mais erros por idioma | Um idioma selecionado — Selecione o idioma ao coletar a gravação de vídeo |
| Selecione o remetente ou a origem da legenda automática | Sim — params.auto seleciona uma origem sem substituto de origem cruzada | Origem mostrada nos metadados da trilha — Nenhuma entrada de seleção de origem listada para o raspador de vídeos revisado |
| Texto completo e citações com carimbo de data/hora | Texto completo + segmentos cronometrados — Start/end vezes em segundos | Texto completo + segmentos cronometrados — Início, fim e duração do segmento em milissegundos |

### Execute a coleta em seu aplicativo ou agente

| Recurso | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Coleção interativa e de fundo | Tempo real ou async — Escolha o modo; salve o trabalho ID para trabalho em segundo plano | Rascunho de sincronização ou gatilho async — O trabalho de sincronização que excede um minuto continua como um instantâneo |
| Processe uma grande lista preparada | Bulk Jobs com um arquivo de vídeo ID — Console ou API; partes de progresso, manifesto e resultado | Lotes de entrada assíncronos — Acione uma coleção e recupere ou entregue seu snapshot |
| Saída para aplicativos e LLMs | JSON, texto simples ou Markdown | Formatos de exportação de instantâneo — JSON, NDJSON e CSV |
| Preservar resultados completed para análise posterior | Salve os resultados ou use o armazenamento em massa — Mantenha dados brutos e manifestos em seu próprio armazenamento | Instantâneos e entrega de armazenamento — Instantâneos retidos por 30 dias |
| Cliente de terminal independente | Nativo CLI — Linux, macOS e Windows; sem tempo de execução do Node/Python | Node.js CLI — Comando bdata instalado pelo npm |
| MCP, habilidades e SDK acesso | Sim | Sim |

As taxas pagas excluem licenças gratuitas. Ambos oferecem async empregos, coleta em massa e ferramentas de agente. Mantenha a coleta de comentários, outras plataformas sociais, conjuntos de dados gerenciados e integrações existentes de armazenamento e entrega quando necessário.

### Pague pelos campos que sua tarefa precisa

Busque metadados para sua lista. Solicite legendas apenas para os vídeos que você irá analisar. Uma atualização de metadados não precisa repetir a etapa de transcrição.

### Escolha a faixa de legenda explicitamente

Solicite um idioma e selecione legendas fornecidas pelo remetente ou geradas por YouTube. Mantenha os erros de linguagem visíveis em vez de alterar silenciosamente os dados da pesquisa.

### Mantenha o trabalho nas sessões do agente

Salve o trabalho aceito ID antes da votação. Um processo posterior retoma o mesmo trabalho e reutiliza o resultado baixado sem enviar outra consulta.

<a id="pricing"></a>
## Compare a tarefa de vídeo completa

A gravação de vídeo de Bright Data pode incluir metadados e legendas. FlashData usa uma solicitação de metadados e uma solicitação de legenda separada. Uma entrada de descoberta pode retornar muitos registros faturáveis; esta calculadora cobre apenas pesquisas de vídeos conhecidos.

| Bright Data YouTube oferta | Mensalidade | Registros incluídos | Taxa paga / 1,000 registros |
| --- | --- | --- | --- |
| Pool gratuito qualificado | $0 | Até 5,000/mês compartilhados entre produtos qualificados | Dentro do subsídio |
| Pagamento por uso | $0.00 | Sem subsídio de plano pago | $1.50 |
| Scale · $499/month | $499.00 | 384,000 | $1.30 additional |
| Empresa | Personalizado | Personalizado | Personalizado |

Scale inclui registros 384,000 para $499/mês; registros adicionais custam $1.30 por 1,000. A correspondência personalizada de depósito empresarial e promocional não é modelada.

| FlashData plano | Por 1,000 solicitações | Mensalidade | Solicitações incluídas por mês |
| --- | --- | --- | --- |
| Pagamento 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 |

As contagens de solicitações incluídas alocam o saldo total do plano compartilhado aos dados YouTube padrão. A pesquisa estendida e o download têm taxas separadas. [Preço total](https://flashdata.dev/pt/pricing/youtube-data).

### 10,000 vídeos: pague conforme usar em ambos os lados

| Tarefa | FlashData solicitações | FlashData fatura modelada | Bright Data registros gratuitos aplicados | Bright Data fatura modelada |
| --- | --- | --- | --- | --- |
| Metadados de vídeo | 10,000 | $5.00 | 0 | $15.00 |
| Metadados de vídeo | 10,000 | $5.00 | 5,000 | $7.50 |
| Metadados + legendas existentes | 20,000 | $10.00 | 0 | $15.00 |
| Metadados + legendas existentes | 20,000 | $10.00 | 5,000 | $7.50 |

USD por um mês de pesquisas de vídeo bem-sucedidas. Um registro de vídeo Bright Data retornado pode conter metadados e legendas existentes; a tarefa FlashData combinada usa duas solicitações de origem. Descoberta, comentários, transcrição de IA, pesquisa estendida e downloads de mídia estão excluídos. Insira apenas Bright Data créditos gratuitos ainda disponíveis para esses registros; o conjunto de créditos 5,000 é compartilhado e os créditos gratuitos recorrentes não se acumulam com Scale. FlashData os preços vêm de seu catálogo público atual; todo o saldo do plano selecionado é alocado aqui antes do uso adicional. FlashData saldos iniciais e testes de inscrição/agent estão excluídos. A fatura modelada mede o uso mais qualquer taxa mensal, não uma nova compra de carteira: as recargas de FlashData começam em $10. Não estão incluídos impostos, promoções de correspondência de depósito, taxas personalizadas ou descontos anuais.

### Ofertas iniciais

As inscrições do FlashData podem receber uma permissão inicial de até 4,000 padrão YouTube pedidos de dados. Este é um saldo inicial, não uma cota mensal recorrente.

As contas Bright Data qualificadas recebem 5,000 créditos gratuitos por mês, compartilhados entre produtos qualificados, incluindo Scraper API. Um registro YouTube entregue consome um crédito. Os créditos gratuitos não utilizados não são acumulados; contas pré-comprometidas não recebem créditos gratuitos recorrentes. Não acumule o pool mensal gratuito com Scale.

<a id="limits"></a>
## Subsídios, batch tamanhos e running empregos

| Preocupação | FlashData | Bright Data Raspador API |
| --- | --- | --- |
| O que consome o subsídio? | Cada consulta de origem; metadados e legendas são separados | Registros entregues com sucesso; uma entrada de descoberta pode retornar muitos |
| Uma solicitação interativa | POST /v1/queries/realtime; escolha async para trabalho em segundo plano | POST /datasets/v3/scrape; após 1 minuto, HTTP 202 retorna um instantâneo ID e o trabalho continua |
| Entradas maiores | O tamanho do lote depende do plano; use processamento em massa para um arquivo de IDs | Async /trigger aceita até 1 GB de entrada; contagem mínima de entrada depende do raspador |
| Trabalho em execução | A simultaneidade da conta depende do plano selecionado, mostrado abaixo | 5,000 empregos ativos/snapshots; exceder o limite retorna 429 |
| Recuo | Honra Retry-After; testes de agentes temporários permitem uma solicitação por segundo | Honra Retry-After; 25 HTTP 429 respostas por IP em 5 minutos podem acionar um bloqueio de 1 horas API |
| Resultados salvos | Baixe e mantenha o JSON em seu próprio armazenamento de tarefas | Instantâneos retidos por 30 dias; solicitações de download suportam até 5 GB, com recuperação baseada em partes para resultados maiores |

| FlashData plano | Consultas simultâneas | Consultas por solicitação em lote |
| --- | --- | --- |
| Pagamento por uso | 25 | 100 |
| Micro | 50 | 100 |
| Starter | 100 | 200 |
| Pro | 200 | 300 |
| Scale | 300 | 400 |
| Business | 400 | 500 |

A simultaneidade não é solicitações por segundo. Os créditos ainda se aplicam a cada consulta. [Em tempo real e async](https://flashdata.dev/pt/docs/reference/realtime-and-async/reference.md) · [Lote e massa](https://flashdata.dev/pt/docs/reference/batch-and-bulk/reference.md) · [Referência de processamento em massa](https://flashdata.dev/pt/docs/reference/bulk-processing/reference.md).

<a id="migration"></a>
## De um instantâneo a um trabalho salvo

### 1. Preparar o acesso e mapear a solicitação

Crie ou reutilize uma chave com permissão youtube_metadata. [API Chaves](https://flashdata.dev/app/api-keys) · [Créditos disponíveis](https://flashdata.dev/app/billing). Armazene FLASHDATA_API_KEY em um armazenamento secreto ou insira-o no prompt oculto do script.

Envio Bright Data existente, para referência de migração:

```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 com X-API-Key:

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

### 2. Salve o script antes de running

Requer Python 3.10+. Instale a dependência com python -m pip install requests. Em uma nova pasta de trabalho, salve o script completo abaixo como migrate-video.py antes de executá-lo.

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

```

Execute da mesma pasta:

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

Alternativamente, use Bash, cURL 7.76+ e jq 1.6+. Salve o script completo abaixo como migrate-video.sh em uma nova pasta de trabalho.

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

```

Execute da mesma pasta:

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

Se ainda for running, repita o mesmo comando para retomar o trabalho salvo. Execuções concluídas reutilizam result.json sem uma chamada API. Uma nova pasta envia uma nova solicitação; verifique o histórico antes de tentar novamente um envio incerto. Mantenha as chaves fora do bate-papo e nunca as encaminhe para armazenamento assinado URLs.

### 3. Leia o registro mapeado

O vídeo-001/video-records.json preserva nomes comuns de campos de vídeo; o result.json mantém dados brutos e uso. Faltam métricas. null. channelName é um nome de exibição, não uma alça; uploadDateRaw Não é uma data normalizada. Transcrição e meios de comunicação não são 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"
    ]
  }
]
```

| Preocupação | Integração existente | FlashData mudança |
| --- | --- | --- |
| Seleção de raspador | dataset_id=gd_lk56epmy2i5g7lzu0k | fonte=youtube_metadata; legendas usam youtube_transcript separadamente |
| Entrada | Um relógio URL na matriz de entrada | Um caractere 11 video_id |
| Autenticação | Autorização: Portador | X-API-Key com a permissão da fonte solicitada |
| Enviar | POST /datasets/v3/trigger → snapshot_id | POST /v1/queries → identificação; guarde o recibo |
| Rastrear | Progresso do instantâneo → ready | GET /v2/jobs/{id} → job.status=completed |
| Recuperar | Baixe um instantâneo como JSON, NDJSON ou CSV | GET /v2/jobs/{id}/results → armazenamento assinado URL; buscar sem a chave API |
| Campos de vídeo | video_id, title, description, views, likes, num_comments, video_length | videoId, título, descrição, viewCount, likeCount, commentCount, duração (segundos) |
| Canal e data | youtuber é um identificador; date_posted é uma data | Mantenha channelName, channelId e uploadDateRaw; não renomeie um nome de exibição para um identificador |
| Transcrição | Pode ser incluído como transcrição e formatted_transcript na gravação do vídeo | Solicitação de faixa separada; fullText e os segmentos usam segundos. Mapeie carimbos de data/hora se o analisador existente espera milissegundos |
| Mídia direta URL | video_url é um streaming URL | Use o fluxo de trabalho de download YouTube separado para entrega em seu armazenamento |

### Legendas opcionais

Conceda permissão youtube_transcript. Envie este corpo para POST https://data.flashdata.dev/v1/queries com X-API-Key e salve seu próprio trabalho ID. Isso adiciona uma solicitação padrão por vídeo:

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

auto=false seleciona legendas fornecidas pelo uploader. Preservar a língua e a origem. Bright Data tempos de transcrição formatados usam milissegundos; FlashData segmentos usam segundos. Multiplique por 1,000 para um analisador que espera milissegundos. [Receita executável de legendas com carimbo de data/hora](https://flashdata.dev/pt/docs/guides/timestamped-captions-recipe/reference.md).

### Recuperação

- Pending/processing: retomar o salvo ID. A votação é limitada e honra o Retry-After numérico.
- 401/403: resolver autenticação ou permissão; parar na revogação.
- 402: restaura o saldo disponível do proprietário antes de continuar.
- 429: pare de enviar e honre Retry-After; não tente novamente os envios automaticamente.
- Tempo limite sem recibo: inspecione o Histórico antes de criar outra pasta.

[Erros e códigos de status](https://flashdata.dev/pt/docs/errors/reference.md).

<a id="agents"></a>
## Uma conexão, tarefas reutilizáveis

Agentes elegíveis podem começar com crédito 1 (até 100 padrão YouTube pedidos de dados) para 72 horas. Reuse o acesso salvo primeiro, metadados e legendas compartilham a mesada.

1. Descubra vídeos e uma lista antes de enriquecer.
2. Busque um vídeo, verifique os campos e a seleção de legenda e salve a saída bruta.
3. Faça com que o proprietário conclua a inscrição/sign-in e aprove os escopos e o saldo compartilhado. Os créditos temporários não utilizados não são transferidos.
4. Mantenha credenciais e execute pastas em tarefas recorrentes. Reutilize os resultados e pare em caso de revogação ou saldo esgotado.

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

[Julgamento e reivindicação](https://flashdata.dev/pt/docs/guides/agent-onboarding/reference.md) · [Tarefas recorrentes](https://flashdata.dev/pt/docs/guides/recurring-tasks/reference.md) · [Salvar resultados](https://flashdata.dev/pt/docs/guides/save-results/reference.md).

<a id="faq"></a>
## Perguntas sobre migração

### Esta é a comparação de pesquisa Bright Data Google?

Esta página cobre o raspador YouTube API. Google Search utiliza o produto SERP de Bright Data, com diferentes unidades de preços e configurações de solicitação. A comparação de pesquisa Google possui sua própria página.

### Bright Data cobra duas vezes pelos metadados e pela transcrição?

Seu esquema de vídeo YouTube inclui metadados e campos de legenda no registro de vídeo retornado. Não conte automaticamente dois registros. FlashData usa metadados separados e consultas de transcrição; a carga de trabalho combinada na calculadora conta duas FlashData solicitações por vídeo. Um campo de legenda pode estar indisponível para um vídeo específico.

### Qual provedor tem a maior franquia gratuita?

Bright Data oferece contas elegíveis 5,000 créditos compartilhados todos os meses. O subsídio de inscrição elegível de FlashData é um saldo inicial e seu teste de agente temporário é separado. Essas ofertas têm regras de renovação diferentes. Use a entrada de registro livre restante para modelar Bright Data PAYG com precisão.

### Posso substituir cada raspador Bright Data?

Mova os fluxos de trabalho de metadados, pesquisa, canais e legendas suportados YouTube que você precisa. Mantenha a coleta de comentários, outras plataformas sociais, conjuntos de dados gerenciados e integrações existentes de entrega de armazenamento onde seu aplicativo ainda depende deles.

### Ambos os provedores oferecem suporte a agentes de IA?

Sim. Ambos oferecem MCP, CLI e habilidades de agente. O CLI autônomo de FlashData, as permissões de origem e o equilíbrio Google/YouTube compartilhado são úteis para um fluxo de trabalho de pesquisa focado. Reutilize o acesso salvo e peça ao proprietário para aprovar o acesso contínuo à conta antes de agendar trabalhos recorrentes.

### Posso reutilizar um instantâneo ID após a migração?

Não. Salve o instantâneo Bright Data e o novo trabalho FlashData ID como identificadores separados. O exemplo reutiliza apenas o recibo FlashData salvo e verifica se o vídeo retornado corresponde ao ID solicitado.

[Obtenha uma chave API](https://flashdata.dev/signup) · [Google Comparação de pesquisa](https://flashdata.dev/pt/compare/brightdata/reference.md).
