# ScrapeCreators Alternativa para YouTube Dados

Compare YouTube custos de metadados e legendas, pacotes pré-pagos e acessos de cache. Migre para FlashData com adaptadores de campo executáveis ​​Python e Bash para aplicativos e agentes.

Dados de vídeo atualizados. Um gasto inicial menor. Mova metadados YouTube e legenda chamadas enquanto mantém o restante da integração de dados sociais.

ScrapeCreators fatos revisados 2026-11-10. Preços FlashData e subsídios de julgamento vêm de seus catálogos públicos atuais.

- [Recursos](#features)
- [Preços e cache](#costs)
- [Migrar uma solicitação](#migration)
- [Fluxo de trabalho de pesquisa](#workflow)
- [Para agentes de IA](#agents)
- [Perguntas frequentes](#faq)

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

### Reduza o custo de dados YouTube novos

| Recurso | FlashData | ScrapeCreators |
| --- | --- | --- |
| Taxa de entrada paga / 1,000 metadados ou chamadas de legenda | $0.50 — Uso pré-pago | $1.88 — Freelance · novas chamadas de um crédito |
| Taxa unitária listada mais baixa / 1,000 chamadas | $0.20 — Plano mensal opcional; sua taxa ainda se aplica | $0.994 — Business · $497 pacote pré-pago; Empresa personalizada excluída |
| Primeira compra de crédito paga | De $10 | $47 — Pacote 25,000-créditos Freelance |
| Pague conforme o uso, sem mensalidade | Sim | Sim |

### Encontre vídeos e atualize os fatos que você precisa

| Recurso | FlashData | ScrapeCreators |
| --- | --- | --- |
| Encontre vídeos por palavra-chave e filtros | Sim — Filtros de data, duração, tipo e classificação | Sim — Filtros de pesquisa e paginação de token de continuação |
| Metadados de um vídeo conhecido | Sim — Título, canal, duração, miniaturas e contagens de engajamento | Sim — Video/Short Detalhes do ponto final |
| Marcadores de capítulo para navegação | Sim — include_chapters; títulos com início/end vezes quando presente | Sim — capítulos na resposta do vídeo quando presente |
| Descubra faixas de legenda disponíveis | Lista de idiomas de metadados — hasTranscripts e transcriptLanguages | Metadados captionTracks — Códigos de idioma e detalhes da faixa |

### Mantenha a seleção de legendas e evidências explícitas

| Recurso | FlashData | ScrapeCreators |
| --- | --- | --- |
| Texto e carimbos de data/hora da mesma resposta | Texto completo + segmentos cronometrados — Start/end vezes em segundos | Texto completo + segmentos cronometrados — startMs/endMs como cordas de milissegundos |
| Vários idiomas de legenda em uma solicitação | Até 10 idiomas — Faixas existentes mais erros por idioma | Um idioma selecionado — idioma ou seleção de original_audio por chamada de transcrição |
| Escolha a origem da legenda explicitamente | Uploader ou gerado por YouTube — params.auto seleciona uma origem | Seleção de idioma e áudio falado — original_audio não é uma opção de origem de legenda |
| Tratamento de legendas ausentes | Faixas existentes e erros explícitos — Matrizes de idiomas preservam trilhas bem-sucedidas e relatam seleções ausentes | Campos de transcrição nulos — As faixas solicitadas ausentes custam zero créditos; não YouTube Transcrição AI |
| Escolha a idade dos dados reutilizados | Política de cache em seu aplicativo — Salve os tempos de recuperação e decida quando buscar novamente | cache_max_age — Opções de 1–30 dias; acessos de cache custam zero créditos e expõem cached_at |

### Execute um fluxo de trabalho de dados repetível

| Recurso | FlashData | ScrapeCreators |
| --- | --- | --- |
| Processe um arquivo de vídeo salvo IDs | Jobs em massa gerenciados — Envie o arquivo, rastreie seu trabalho e recupere os resultados | Chamadas de endpoint por vídeo — Gerencie o loop de arquivos e o armazenamento de resultados em sua integração |
| Mova coleções longas para trabalhos em segundo plano | APIs assíncronas, em lote e em massa — Persista o trabalho IDs, rastreie o status e recupere resultados | Chamadas YouTube síncronas — Fila e checkpoint de chamadas por vídeo no seu trabalhador |
| Saída estruturada e legível | JSON, texto simples ou Markdown — Selecionado através de cabeçalhos de resposta API | Formatos JSON API e CLI — CLI também exporta CSV, tabelas e Markdown |
| Instalação de terminais | Executável independente — Linux, macOS e Windows; sem tempo de execução do Node/Python | npm CLI — @scrapecreators/cli |
| MCP e habilidades do agente | Sim | Sim |
| Continue desde os dados até a entrega de mídia hospedada | Sim — YouTube Baixe para seu armazenamento; permissão separada e preços baseados em GB | Fluxo de trabalho de download separado — YouTube metadados e APIs de transcrição não entregam arquivos de mídia |

Ambos oferecem acesso pré-pago, MCP, CLI e habilidades de agente. ScrapeCreators também cobre outras plataformas sociais e comentários YouTube. Os acessos de cache suportados são gratuitos.

### Atualize os vídeos de seu interesse

Taxas de uso mais baixas por solicitação são importantes quando você atualiza métricas variáveis ou coleta legendas para novos vídeos. Mantenha as transcrições salvas e solicite metadados somente quando precisar de atualização.

### Comece com uma compra menor

As recargas de crédito de FlashData começam em $10. Mova primeiro uma carga de trabalho YouTube, enquanto sua integração existente continua a lidar com comentários e outras plataformas sociais.

### Escolha a faixa de legenda exata

Selecione explicitamente as legendas fornecidas pelo uploader ou geradas por YouTube. Solicite até 10 idiomas existentes em uma solicitação de transcrição e lide com o resultado de cada idioma separadamente.

<a id="costs"></a>
## Compare novas solicitações, acessos ao cache e compras antecipadas

| ScrapeCreators oferta | Compra única | Créditos | Por 1,000 novas chamadas de um crédito | Mensalidade |
| --- | --- | --- | --- | --- |
| Oferta inicial gratuita | $0 | 100 uma vez | Subsídio inicial gratuito | $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 pré-pagos |

São pacotes pré-pagos sem renovação mensal. Business é exatamente $0.994 por 1,000 chamadas de um crédito; $0.99 é arredondado. Os créditos adquiridos não expiram de acordo com a política atual. Os créditos de bônus iniciais e ganhos estão excluídos do modelo.

| 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 FlashData alocam todo o saldo 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).

### Exemplo: metadados e legendas para 1,000 vídeos

2,000 solicitações, sem pesquisas de descoberta. FlashData pré-pago vs ScrapeCreators Freelance. Contar apenas ocorrências de cache observadas; solicitações evitadas por meio de seu próprio armazenamento local não são enviadas a nenhum dos provedores.

| Acessos de cache gratuitos | FlashData chamadas | 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, um mês de solicitações. Uma nova pesquisa de metadados, resultado de legenda nativa ou solicitação de pesquisa padrão usa um crédito ScrapeCreators. Metadados mais legendas usam duas solicitações em ambos os lados. Apenas os acessos de cache de metadados/transcript inseridos acima são deduzidos; o cache de pesquisa não é assumido. Este modelo conta as legendas retornadas, não as tentativas de rastreamento perdido, e exclui a geração de IA. FlashData usa seu padrão atual YouTube Preços de dados, alocando todo o limite do plano selecionado antes do uso extra. Pesquisa estendida e download custam separadamente. Saldos iniciais, avaliações, créditos de bônus, impostos e outros usos estão excluídos. As compras começam com saldo zero: recargas de FlashData têm mínimo de $10; ScrapeCreators as compras são arredondadas para pacotes inteiros selecionados. Os créditos adquiridos não utilizados podem servir para tarefas posteriores. ScrapeCreators não possui renovação mensal de pacote; um plano mensal FlashData selecionado ainda tem sua taxa com zero solicitações.

### Comportamento do cache

Em endpoints de metadados/transcript suportados, cache_max_age aceita 1d, 3d, 7d, 14d ou 30d. Os acessos usam zero créditos e reportam cached_at; erros usam a taxa normal. Os acertos do cache de pesquisa não são assumidos. Decida se os dados salvos são recentes o suficiente para a tarefa. [Salvar e reutilizar resultados](https://flashdata.dev/pt/docs/guides/save-results/reference.md).

### Ofertas iniciais

ScrapeCreators Começa com... 100 créditos gratuitos. As inscrições do FlashData podem receber uma permissão inicial de até 4,000 padrão YouTube pedidos de dados. Essas ofertas não recomeçam mensalmente. O julgamento do agente temporário separado aparece abaixo.

<a id="migration"></a>
## Migrar um vídeo e seus carimbos de data/hora de legenda

### 1. Configure o acesso e escolha a faixa

Crie ou reutilize uma chave com permissão youtube_transcript, mais youtube_metadata para a chamada opcional de metadados. [API Chaves](https://flashdata.dev/app/api-keys) · [Créditos](https://flashdata.dev/app/billing). Armazene FLASHDATA_API_KEY no ambiente ou use o prompt oculto do script; nunca cole no chat.

Solicitação existente, apenas para mapeamento:

```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 com X-API-Key e este corpo JSON:

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

original_audio=true escolhe o idioma falado. FlashData params.auto=true seleciona legendas geradas por YouTube. Especifique o idioma e a origem separadamente.

### 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 creator-research.py antes de executá-lo.

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

```

Execute a partir dessa pasta usando um vídeo com uma faixa em inglês existente. Os metadados são uma solicitação opcional separada; em um teste temporário, deixe pelo menos um segundo entre as chamadas.

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

Para legendas fornecidas pelo uploader, anexe o manual --origin. O padrão são legendas em inglês geradas por YouTube.

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

```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 legendas fornecidas pelo uploader, anexe o manual. Cada nova pasta de saída envia uma solicitação. Os mesmos argumentos e reutilização de pasta salvaram a saída; use uma nova pasta para uma atualização intencional após inspecionar a tentativa anterior.

### 3. Leia a saída mapeada e o uso real

Legendas...001/normalized.json é um adaptador de campo; response.json retém a resposta crua e o uso real. languageCode e isAutoGenerated preservam a faixa selecionada. Esta não é uma resposta completa: sem saldos de crédito fabricados, bandeiras de cache, atribuição de uploader ou campos de data. Metadados preservam métricas desaparecidas como null e sua data original como 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 integração | FlashData mudança |
| --- | --- |
| GET /v1/youtube/video?url=… | POST a consulta API com fonte: youtube_metadata e video_id. Leia os resultados[0], não a raiz da resposta. |
| GET /v1/youtube/video/transcript?url=… | Fonte de uso: youtube_transcript. Defina params.language e params.auto explicitamente. |
| transcrição[].startMs / endMs | FlashData início/fim são segundos. Multiplique cada um por 1,000 e serialize como strings para um leitor de milissegundos existente. |
| original_audio=true | Seleciona o idioma falado em ScrapeCreators, não em legendas geradas automaticamente. Resolva o idioma necessário em seu aplicativo; params.auto seleciona a origem da legenda. |
| idioma e transcript_only_text | Mapa languageName e fullText. Mantenha languageCode separadamente; um nome de idioma e um código de idioma são campos diferentes. |
| viewCountInt, likeCountInt, commentCountInt | Mapa viewCount, likeCount, commentCount. Preservar null quando uma métrica estiver ausente. |
| durationMs e publishDate | Converta segundos de duração em milissegundos. Preserve uploadDate como um campo bruto até que seu aplicativo valide o formato de data necessário. |
| canal / uploader / ownerByline | FlashData canal e channelId não reproduzem todas as três identidades. Mapeie apenas os campos que seu leitor precisa; mantenha um caminho separado para atribuição de crédito musical. |
| cached, cached_at, credits_charged | Mantenha a resposta e o uso brutos de FlashData. Registre seu próprio tempo de busca; não fabricamos sinalizadores de cache de provedores nem traduzimos saldos de crédito entre provedores. |

[Esquema de transcrição](https://flashdata.dev/pt/docs/sources/youtube_transcript/reference.md) · [Esquema de metadados](https://flashdata.dev/pt/docs/sources/youtube_metadata/reference.md)

### Se a primeira solicitação falhar

- 401/403: verifique a chave salva e permissão de origem; pare se revogada.
- 402: reabasteça o saldo do proprietário antes de retomar.
- 429: lê o cabeçalho Retry-After salvo; reduzir a frequência de solicitações. Os testes temporários permitem uma solicitação por segundo.
- Trilha ausente: verifique o idioma e a origem disponíveis. ScrapeCreators pode retornar uma resposta bem-sucedida com uma transcrição null; não confunda isso com uma faixa completed FlashData.
- Tempo limite ou pasta incompleta: inspecione o histórico e a saída antes de tentar novamente. Os scripts preservam a tentativa sem reenvio automático.

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

<a id="workflow"></a>
## Encontrar → lista → enriquecer → citar

| Passo | Trabalho | Contagem de solicitações |
| --- | --- | --- |
| Descubra | Execute solicitações de pesquisa P YouTube | P solicitações de pesquisa padrão. Conte as solicitações reais, e não todos os vídeos retornados como uma pesquisa separada. |
| Selecione | Desduplicar e selecionar vídeo N IDs | Filtragem local; nenhuma solicitação de metadados ou legenda ainda. |
| Enriquecer | Obtenha metadados para os IDs selecionados | N solicitações de metadados; repita apenas quando as métricas precisarem ser atualizadas. |
| Citar | Busque uma faixa de legenda existente por ID | N solicitações de transcrição quando disponíveis. Armazene o idioma, a origem e os tempos de sugestão com a fonte URL. |
| Reutilizar | Leia os resultados salvos para a próxima tarefa | Nenhuma solicitação do provedor quando seu aplicativo pode reutilizar seu próprio arquivo salvo. |

10 solicitações de pesquisa mais 50 vídeos selecionados com metadados e legendas exigem 110 solicitações padrão antes da reutilização local. Separe os custos de descoberta do enriquecimento. Um resultado de pesquisa não é em si uma solicitação de pesquisa separada.

### A pesquisa não é uma migração de cursor drop-in

ScrapeCreators pode retornar vários tipos de resultados com continuationToken. A pesquisa padrão de FlashData retorna resultados de vídeo; sua pesquisa estendida tem limites e preços separados. Inicie uma nova execução de descoberta em vez de reutilizar um cursor antigo.

[YouTube Referência de pesquisa](https://flashdata.dev/pt/docs/sources/youtube_search/reference.md)

### Mantenha as evidências com a resposta

Armazene o vídeo ID, URL, idioma escolhido, origem da legenda e hora de início do segmento. Um link de citação pode apontar para esse carimbo de data/hora. Não rotule uma faixa de legenda ausente como uma transcrição vazia e bem-sucedida.

[Receita de legendas com carimbo de data/hora](https://flashdata.dev/pt/docs/guides/timestamped-captions-recipe/reference.md)

### Scale a lista ID separadamente

Depois que uma pesquisa funcionar, use solicitações batch para uma lista ou processamento em massa para um arquivo. Rastreie o trabalho IDs, salve as saídas completed e tente novamente apenas os itens failed. Mantenha seu corredor responsável pelo cronograma.

[Referência de processamento em massa](https://flashdata.dev/pt/docs/reference/bulk-processing/reference.md)

<a id="agents"></a>
## Comprove a migração antes de agendá-la

Agentes elegíveis podem começar com 1 credit (até 100 padrão YouTube Pedidos de dados para 72 Horas. Metadados, legendas e buscas dividem a mesada.

1. Inspecione os campos obrigatórios, a intenção e a atualização da legenda. Reutilize o acesso salvo; manter chamadas de dados sociais não relacionadas.
2. Execute um vídeo conhecido usando CLI, SDK ou MCP. Salve a saída e verifique o tempo, os valores nulos e o uso real.
3. O proprietário entra ou se inscreve, verifica o e-mail e aprova reivindicações, escopos e uso de saldo compartilhado. Os créditos de avaliação não utilizados não são transferidos.
4. Persista a credencial do proprietário para uso recorrente. Reutilize as saídas e pare em caso de revogação ou 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.
```

[Julgamento e reivindicação](https://flashdata.dev/pt/docs/guides/agent-onboarding/reference.md) · [Autônomo CLI](https://flashdata.dev/pt/docs/guides/flashdata-cli/reference.md) · [MCP configuração](https://flashdata.dev/pt/docs/integrations/mcp-clients/reference.md)

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

### Essas assinaturas são mensais?

ScrapeCreators Freelance e Business são pacotes pré-pagos, não assinaturas. Ambos têm uma taxa mensal de $0. FlashData tem créditos pré-pagos, além de planos mensais opcionais. Compare o uso consumido e a compra necessária do seu saldo atual separadamente.

### E se a maioria das minhas solicitações ScrapeCreators estiverem armazenadas em cache?

Os acessos de metadados e cache de transcrição suportados custam zero créditos. Insira os acertos observados na calculadora. Se o seu aplicativo aceitar a idade deles, eles poderão custar menos do que novas solicitações de FlashData. Você também pode salvar a saída de qualquer provedor localmente e evitar fazer a próxima solicitação.

### Os créditos não utilizados expiram?

ScrapeCreators diz que os créditos adquiridos não expiram de acordo com sua política atual. Sua oferta inicial de crédito 100 grátis não é uma recarga mensal. O teste de agente temporário de FlashData expira; suas páginas de preços e contas descrevem os termos de saldo do proprietário aplicáveis.

### original_audio=true funcionará como params.auto=true?

Não. O primeiro escolhe um idioma com base no áudio falado; o segundo escolhe legendas geradas por YouTube. Defina um idioma e uma origem deliberadamente. Nenhum dos endpoints de legenda nativa do serviço cria fala para texto quando uma faixa correspondente está ausente.

### Posso substituir todas as minhas chamadas de dados sociais?

Esta migração abrange YouTube metadados de vídeo e legendas existentes. Mantenha comentários, publicações na comunidade, perfis sociais e quaisquer outros campos de resposta não suportados no caminho existente. FlashData também oferece Google Pesquisa e download YouTube hospedado, com suas próprias permissões e preços.

### ScrapeCreators também oferece suporte a agentes de IA?

Sim. Oferece MCP, OAuth, CLI e habilidades de agente. O fluxo do agente FlashData adiciona uma avaliação temporária elegível, reivindicação do proprietário e credenciais salvas para uso continuado. Escolha o API e o fluxo de trabalho que sua tarefa precisa; MCP o suporte por si só não faz a diferença.
