# Bright Data Alternativa a YouTube Dati

Confronta le richieste di FlashData YouTube con i record di Bright Data scraper: tariffe pagate, indennità mensili, limiti di lavoro e migrazione Python/Bash dalle istantanee ai lavori salvati.

Costruisci ricerche video attorno alle richieste di origine. Confronta l'intera attività, quindi sposta un flusso di lavoro con snapshot in lavori salvati e ripristinabili.

Questo è il confronto di YouTube. [Bright Data Alternativa per Google Cerca](https://flashdata.dev/it/compare/brightdata/reference.md) è una pagina separata.

I fatti Bright Data hanno recensito 2026-11-10. Le aliquote e gli assegni FlashData utilizzano i suoi attuali cataloghi pubblici.

- [Caratteristiche](#features)
- [Prezzi](#pricing)
- [Quote e limiti](#limits)
- [Migrare un lavoro](#migration)
- [Flussi di lavoro dell'agente](#agents)
- [Domande frequenti](#faq)

<a id="features"></a>
## Confronto delle funzionalità

### Costi pagati inferiori per ricerche video mirate

| Caratteristica | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Ricerca di metadati a pagamento · 1,000 video | $0.50 — 1,000 richieste di origine · PAYG | $1.50 — 1,000 registrazioni video consegnate · PAYG |
| Metadati + didascalie esistenti · 1,000 video | $1.00 — 2,000 richieste di origine · PAYG | $1.50 — 1,000 registrazioni video quando sono inclusi i campi di didascalia |
| Piano mensile di ingresso | $49.00 — Micro/mese; bilancia di utilizzo condivisa inclusa | $499 — Scale/mese · record 384,000 inclusi |
| Paga in base al consumo senza abbonamento mensile | Sì | Sì |

### Trova video e crea una libreria di ricerca

| Caratteristica | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Scopri i video per parola chiave | Sì — Cerca con data, durata, tipologia e filtri di ordinamento | Sì — Modalità di rilevamento delle parole chiave e dei filtri di ricerca |
| Metadati per un video noto | Sì — Titolo, canale, durata, miniature e conteggio del coinvolgimento | Sì — Registrazioni video con campi identità, canale e coinvolgimento |
| Indicatori di capitolo per la navigazione | Sì — include_chapters; tempi dei capitoli in secondi | Sì — Titoli dei capitoli, anteprime e orari di inizio in millisecondi |
| Scopri le lingue dei sottotitoli disponibili | Elenco delle lingue nei metadati | Elenco dei brani nella registrazione video — Include informazioni sulla lingua e sui sottotitoli automatici |

### Rendi le didascalie utilizzabili come prova

| Caratteristica | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Richiedi sottotitoli senza aggiornare i metadati | Fonte di trascrizione dedicata — Una richiesta standard per video | Campi didascalia nella registrazione video — YouTube Raschietto video |
| Richiedi più lingue dei sottotitoli | Fino a 10 lingue esplicite — Tiene traccia degli errori per lingua | Una lingua selezionata — Seleziona la lingua durante la raccolta della registrazione video |
| Seleziona l'autore del caricamento o l'origine dei sottotitoli automatici | Sì — params.auto seleziona un'origine senza fallback tra origini | Origine mostrata nei metadati della traccia — Nessun input per la selezione dell'origine elencato per lo scraper Video recensito |
| Testo completo e citazioni con timestamp | Testo completo + segmenti temporizzati — Start/end volte in secondi | Testo completo + segmenti temporizzati — Inizio, fine e durata del segmento in millisecondi |

### Esegui la raccolta nell'applicazione o nell'agente

| Caratteristica | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Raccolta interattiva e di sfondo | In tempo reale o async — Scegli la modalità; salva il lavoro ID per il lavoro in background | Sincronizza lo scraping o il trigger async — Il lavoro di sincronizzazione che supera un minuto continua come snapshot |
| Elabora un ampio elenco preparato | Bulk Jobs con un file video-ID — Console o API; parti di progresso, manifesto e risultato | Batch di input asincroni — Attiva una raccolta e recupera o consegna la sua istantanea |
| Output per applicazioni e LLM | JSON, testo semplice o Markdown | Formati di esportazione delle istantanee — JSON, NDJSON e CSV |
| Conserva completed risultati per analisi successive | Salva i risultati o utilizza l'archiviazione collettiva — Conserva i dati grezzi e i manifest nel tuo spazio di archiviazione | Snapshot e consegna dello storage — Istantanee conservate per 30 giorni |
| Client terminale autonomo | Nativo CLI — Linux, macOS e Windows; nessun runtime del Node/Python | Node.js CLI — Comando bdata installato da npm |
| MCP, competenze e SDK accesso | Sì | Sì |

Le tariffe pagate escludono le indennità gratuite. Entrambi offrono async posti di lavoro, raccolta in blocco e strumenti per agenti. Conserva la raccolta dei commenti, altre piattaforme social, i set di dati gestiti e le integrazioni di distribuzione dello storage esistenti dove necessario.

### Paga per i campi di cui ha bisogno la tua attività

Recupera i metadati per la tua lista. Richiedi didascalie solo per i video che analizzerai. Non è necessario che un aggiornamento dei metadati ripeta il passaggio di trascrizione.

### Scegli esplicitamente la traccia dei sottotitoli

Richiedi una lingua e seleziona i sottotitoli forniti dall'autore del caricamento o generati da YouTube. Mantieni visibili gli errori linguistici invece di modificare silenziosamente l'input della ricerca.

### Mantieni il lavoro tra le sessioni dell'agente

Salva il lavoro accettato ID prima del sondaggio. Un processo successivo riprende lo stesso lavoro e riutilizza il risultato scaricato senza inviare un'altra query.

<a id="pricing"></a>
## Confronta l'attività video completa

La registrazione video di Bright Data può includere metadati e didascalie. FlashData utilizza una richiesta di metadati e una richiesta di didascalia separata. Un input di rilevamento può restituire molti record fatturabili; questo calcolatore copre solo le ricerche di video noti.

| Bright Data YouTube offerta | Canone mensile | Record inclusi | Tasso pagato / 1,000 record |
| --- | --- | --- | --- |
| Piscina gratuita idonea | $0 | Fino a 5,000/mese condivisi tra i prodotti idonei | Entro l'indennità |
| Pagamento a consumo | $0.00 | Nessuna indennità del piano retribuito | $1.50 |
| Scale · $499/month | $499.00 | 384,000 | $1.30 additional |
| Impresa | Personalizzato | Personalizzato | Personalizzato |

Scale include 384,000 record per $499/mese; i record aggiuntivi costano $1.30 per 1,000. L'azienda personalizzata e la corrispondenza del deposito promozionale non sono modellate.

| Piano FlashData | Per 1,000 richieste | Canone mensile | Richieste incluse al mese |
| --- | --- | --- | --- |
| Pagamento a consumo | $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 |

I conteggi delle richieste incluse assegnano l'intero saldo del piano condiviso ai dati standard YouTube. La ricerca estesa e il download hanno tariffe separate. [Prezzo intero](https://flashdata.dev/it/pricing/youtube-data).

### 10,000 video: paga in base al consumo su entrambi i lati

| Compito | FlashData richieste | FlashData fattura modellata | Bright Data record gratuiti applicati | Bright Data fattura modellata |
| --- | --- | --- | --- | --- |
| Metadati video | 10,000 | $5.00 | 0 | $15.00 |
| Metadati video | 10,000 | $5.00 | 5,000 | $7.50 |
| Metadati + didascalie esistenti | 20,000 | $10.00 | 0 | $15.00 |
| Metadati + didascalie esistenti | 20,000 | $10.00 | 5,000 | $7.50 |

USD per un mese di ricerche video riuscite. Un record video Bright Data restituito può contenere metadati e didascalie esistenti; l'attività combinata FlashData utilizza due richieste di origine. Sono esclusi rilevamento, commenti, trascrizione AI, ricerca estesa e download di contenuti multimediali. Inserisci solo Bright Data crediti gratuiti ancora disponibili per questi record; il pool di crediti 5,000 è condiviso e i crediti gratuiti ricorrenti non si cumulano con Scale. FlashData i prezzi provengono dal suo attuale catalogo pubblico; l'intero saldo del piano selezionato viene allocato qui prima dell'utilizzo aggiuntivo. Sono esclusi i saldi iniziali FlashData e le prove di iscrizione/agent. La fattura modellata misura l'utilizzo più eventuali tariffe mensili, non un nuovo acquisto nel portafoglio: FlashData le ricariche iniziano a $10. Non sono incluse tasse, promozioni di deposito, tariffe personalizzate o sconti annuali.

### Offerte di partenza

I registri verificati eleggibili FlashData possono ricevere un'indennità iniziale fino alle richieste di dati 4,000 standard YouTube. Si tratta di un saldo iniziale, non di una quota mensile ricorrente.

Gli account idonei da Bright Data ricevono 5,000 crediti gratuiti al mese condivisi tra prodotti idonei, incluso Scraper API. Un record YouTube consegnato consuma un credito. I crediti gratuiti non utilizzati non vengono trasferiti; gli account con impegno preliminare non ricevono crediti gratuiti ricorrenti. Non impilare il pool gratuito mensile con Scale.

<a id="limits"></a>
## Indennità, batch dimensioni e running posti di lavoro

| Preoccupazione | FlashData | Bright Data Raschietto API |
| --- | --- | --- |
| Cosa consuma l'indennità? | Ogni query di origine; metadati e didascalie sono separati | Record consegnati con successo; un input di scoperta può restituirne molti |
| Una richiesta interattiva | POST /v1/queries/realtime; scegli async per il lavoro in background | POST /datasets/v3/scrape; dopo 1 minuto, HTTP 202 restituisce un'istantanea ID e il lavoro continua |
| Ingressi più grandi | La dimensione del lotto dipende dal piano; utilizzare l'elaborazione in blocco per un file di IDs | Asincrono /trigger accetta fino a 1 GB di input; il conteggio minimo degli input dipende dal raschiatore |
| Lavoro in corso | La concorrenza dell'account dipende dal piano selezionato, mostrato di seguito | 5,000 posti di lavoro attivi/snapshots; il superamento del limite restituisce 429 |
| Backoff | Onore Retry-After; le prove con agente temporaneo consentono una richiesta al secondo | Onore Retry-After; 25 HTTP 429 risposte per IP in 5 minuti possono attivare un blocco di 1 ore API |
| Risultati salvati | Scarica e conserva JSON nella memoria delle tue attività | Istantanee conservate per 30 giorni; le richieste di download supportano fino a 5 GB, con recupero parziale per risultati più grandi |

| Piano FlashData | Interrogazioni simultanee | Query per richiesta batch |
| --- | --- | --- |
| Pagamento a consumo | 25 | 100 |
| Micro | 50 | 100 |
| Starter | 100 | 200 |
| Pro | 200 | 300 |
| Scale | 300 | 400 |
| Business | 400 | 500 |

La concorrenza non è costituita da richieste al secondo. I crediti continuano ad applicarsi a ciascuna query. [In tempo reale e async](https://flashdata.dev/it/docs/reference/realtime-and-async/reference.md) · [Lotto e massa](https://flashdata.dev/it/docs/reference/batch-and-bulk/reference.md) · [Riferimento all'elaborazione in blocco](https://flashdata.dev/it/docs/reference/bulk-processing/reference.md).

<a id="migration"></a>
## Da uno snapshot a un lavoro salvato

### 1. Preparare l'accesso e mappare la richiesta

Crea o riutilizza una chiave con l'autorizzazione youtube_metadata. [API Chiavi](https://flashdata.dev/app/api-keys) · [Crediti disponibili](https://flashdata.dev/app/billing). Conserva FLASHDATA_API_KEY in un negozio segreto o inseriscilo nel prompt nascosto dello script.

Invio esistente di Bright Data, per riferimento alla migrazione:

```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. Salva lo script prima di running

Richiede Python 3.10+. Installa la dipendenza con python -m pip install requests. In una nuova cartella di lavoro, salva lo script completo seguente come migrate-video.py prima di eseguirlo.

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

```

Esegui dalla stessa cartella:

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

In alternativa, usa Bash, cURL 7.76+ e jq 1.6+. Salva lo script completo di seguito come migrate-video.sh in una nuova cartella di lavoro.

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

```

Esegui dalla stessa cartella:

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

Se ancora running, ripetere lo stesso comando per riprendere il lavoro salvato. Le esecuzioni completate riutilizzano result.json senza una chiamata API. Una nuova cartella invia una nuova richiesta; controlla la cronologia prima di ritentare un invio incerto. Tieni le chiavi fuori dalla chat e non inoltrarle mai all'archivio firmato URLs.

### 3. Leggi il record mappato

video-001/video-records.json conserva i nomi dei campi video comuni; result.json mantiene dati e l'utilizzo grezzi. Le metriche mancanti rimangono null. channelName è un nome di visualizzazione, non una maniglia; uploadDateRaw non è una data normalizzata. I campi trascritti e media non sono fabbricati.

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

| Preoccupazione | Integrazione esistente | FlashData cambiamento |
| --- | --- | --- |
| Selezione del raschiatore | dataset_id=gd_lk56epmy2i5g7lzu0k | fonte=youtube_metadata; le didascalie utilizzano youtube_transcript separatamente |
| Ingresso | Un orologio URL nell'array di input | Un carattere 11 video_id |
| Autenticazione | Autorizzazione: portatore | X-API-Key con l'autorizzazione della fonte richiesta |
| Invia | POST /datasets/v3/trigger → snapshot_id | POST /v1/queries → id; salva la ricevuta |
| Traccia | Avanzamento dell'istantanea → ready | GET /v2/jobs/{id} → job.status=completed |
| Recuperare | Scarica un'istantanea come JSON, NDJSON o CSV | GET /v2/jobs/{id}/results → archiviazione firmata URL; recuperare senza il tasto API |
| Campi video | video_id, title, description, views, likes, num_comments, video_length | videoId, titolo, descrizione, viewCount, likeCount, commentCount, durata (secondi) |
| Canale e data | YouTube è un handle; date_posted è una data | Conserva channelName, channelId e uploadDateRaw; non rinominare un nome visualizzato in un handle |
| Trascrizione | Può essere incluso come trascrizione e formatted_transcript nella registrazione video | Richiesta di traccia separata; fullText e i segmenti utilizzano i secondi. Mappa i timestamp se il parser esistente prevede millisecondi |
| Media diretti URL | video_url è uno streaming URL | Utilizza il flusso di lavoro di download YouTube separato per la consegna al tuo archivio |

### Didascalie facoltative

Concedi l'autorizzazione youtube_transcript. Invia questo corpo a POST https://data.flashdata.dev/v1/queries con X-API-Key e salva il proprio lavoro ID. Ciò aggiunge una richiesta standard per video:

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

auto=false seleziona i sottotitoli forniti dall'autore del caricamento. Preservare la lingua e l'origine. Bright Data i tempi di trascrizione formattata utilizzano millisecondi; I segmenti FlashData utilizzano i secondi. Moltiplicare per 1,000 per un parser che prevede millisecondi. [Ricetta di sottotitoli con timestamp eseguibile](https://flashdata.dev/it/docs/guides/timestamped-captions-recipe/reference.md).

### Recupero

- Pending/processing: riprendere il ID salvato. L'inquinamento è limitato e onora Retry-After numerico.
- 401/403: risolvere l'autenticazione o il permesso; interrompere la revoca.
- 402: ripristina il saldo proprietario disponibile prima di continuare.
- 429: smetti di inviare e onora Retry-After; non ritentare automaticamente gli invii.
- Timeout senza ricevuta: controlla la cronologia prima di creare un'altra cartella.

[Errori e codici di stato](https://flashdata.dev/it/docs/errors/reference.md).

<a id="agents"></a>
## Una connessione, attività riutilizzabili

Gli agenti idonei possono iniziare con il credito 1 (fino alle richieste 100 standard YouTube Data) per le ore 72. Riutilizzo salvato prima l'accesso; metadati e didascalie condividono la franchigia.

1. Scopri i video e la lista dei candidati prima di arricchirli.
2. Recupera un video, verifica i campi e la selezione dei sottotitoli e salva l'output non elaborato.
3. Chiedi al proprietario di completare la registrazione/sign-in e di approvare gli ambiti e il saldo condiviso. I crediti temporanei non utilizzati non vengono trasferiti.
4. Conserva le credenziali ed esegui le cartelle nelle attività ricorrenti. Riutilizza i risultati e interrompi la revoca o l'esaurimento del saldo.

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

[Processo e rivendicazione](https://flashdata.dev/it/docs/guides/agent-onboarding/reference.md) · [Compiti ricorrenti](https://flashdata.dev/it/docs/guides/recurring-tasks/reference.md) · [Salva risultati](https://flashdata.dev/it/docs/guides/save-results/reference.md).

<a id="faq"></a>
## Domande sulla migrazione

### È questo il confronto di ricerca Bright Data Google?

Questa pagina copre il YouTube Raschietto API. Google La ricerca utilizza il prodotto SERP di Bright Data, con diverse unità di prezzo e configurazione della richiesta. Il confronto di ricerca Google ha una propria pagina.

### Bright Data addebita due volte i metadati e una trascrizione?

Il suo schema video YouTube include metadati e campi di didascalia nel record video restituito. Non contare automaticamente due record. FlashData utilizza metadati e query di trascrizione separati; il carico di lavoro combinato nel calcolatore conta due richieste FlashData per video. Un campo didascalia potrebbe non essere disponibile per un particolare video.

### Quale fornitore ha la franchigia gratuita maggiore?

Bright Data offre conti idonei 5,000 crediti condivisi ogni mese. L'indennità di iscrizione idonea di FlashData è un saldo iniziale e la sua prova di agente temporaneo è separata. Queste offerte hanno regole di rinnovo diverse. Utilizza l'input rimanente del record libero per modellare Bright Data PAYG in modo accurato.

### Posso sostituire ogni Bright Data raschietto?

Sposta i YouTube flussi di lavoro supportati di metadati, ricerca, canali e sottotitoli di cui hai bisogno. Mantieni la raccolta dei commenti, altre piattaforme social, set di dati gestiti e integrazioni di distribuzione dello storage esistenti laddove la tua applicazione dipende ancora da essi.

### Entrambi i fornitori supportano gli agenti AI?

Sì. Entrambi offrono MCP, CLI e abilità di agente. Il CLI autonomo di FlashData, le autorizzazioni di origine e il saldo Google/YouTube condiviso sono utili per un flusso di lavoro di ricerca mirato. Riutilizza l'accesso salvato e chiedi al proprietario di approvare l'accesso continuato all'account prima di pianificare lavori ricorrenti.

### Posso riutilizzare uno snapshot ID dopo la migrazione?

No. Salva lo snapshot Bright Data e il nuovo lavoro FlashData ID come identificatori separati. L'esempio riutilizza solo la ricevuta FlashData salvata e controlla che il video restituito corrisponda alla richiesta ID.

[Ottieni una chiave API](https://flashdata.dev/signup) · [Google Confronto delle ricerche](https://flashdata.dev/it/compare/brightdata/reference.md).
