# Bright Data Alternatywa dla YouTube Danych

Porównaj żądania FlashData YouTube z rekordami skrobaka Bright Data: płatne stawki, miesięczne dodatki, limity stanowisk i Python/Bash migracja ze migawek do zapisanych zadań.

Buduj badania wideo wokół próśb o źródła. Porównaj całe zadanie, a następnie przenieś przepływ pracy migawki do zapisanych zadań, które można wznowić.

To jest porównanie YouTube. [Bright Data Alternatywa dla Google Szukaj](https://flashdata.dev/pl/compare/brightdata/reference.md) to osobna strona.

Bright Data fakty zweryfikowane 2026-11-10. Stawki i uprawnienia FlashData korzystają z bieżących publicznych katalogów.

- [Funkcje](#features)
- [Ceny](#pricing)
- [Kwoty i limity](#limits)
- [Przeprowadź migrację zadania](#migration)
- [Przepływ pracy agenta](#agents)
- [Często zadawane pytania](#faq)

<a id="features"></a>
## Porównanie funkcji

### Niższe koszty związane z ukierunkowanym wyszukiwaniem filmów

| Funkcja | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Płatne wyszukiwanie metadanych · 1,000 filmów | $0.50 — 1,000 żądania źródła · PAYG | $1.50 — 1,000 dostarczyło nagrania wideo · PAYG |
| Metadane + istniejące napisy · 1,000 filmów | $1.00 — 2,000 żądania źródła · PAYG | $1.50 — 1,000 nagrań wideo, jeśli uwzględnione są pola napisów |
| Wstępny plan miesięczny | $49.00 — Micro/miesiąc; w tym saldo wspólnego wykorzystania | $499 — Scale/miesiąc · 384,000 rekordy zawarte |
| Płać zgodnie z rzeczywistym użyciem, bez miesięcznej subskrypcji | Tak | Tak |

### Znajdź filmy i stwórz bibliotekę badawczą

| Funkcja | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Odkrywaj filmy według słów kluczowych | Tak — Wyszukiwanie według daty, czasu trwania, typu i filtrów sortowania | Tak — Tryby wykrywania słów kluczowych i filtrów wyszukiwania |
| Metadane znanego filmu | Tak — Tytuł, kanał, czas trwania, miniatury i liczba interakcji | Tak — Nagrania wideo z polami tożsamości, kanału i zaangażowania |
| Znaczniki rozdziałów do nawigacji | Tak — include_chapters; czasy rozdziałów w sekundach | Tak — Tytuły rozdziałów, zapowiedzi i godziny rozpoczęcia w milisekundach |
| Odkryj dostępne języki napisów | Lista języków w metadanych | Lista utworów w nagraniu wideo — Zawiera informacje o języku i napisach automatycznych |

### Twórz podpisy, które mogą służyć jako dowód

| Funkcja | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Żądaj napisów bez odświeżania metadanych | Dedykowane źródło transkrypcji — Jedno standardowe żądanie na film | Pola podpisów w nagraniu wideo — YouTube Skrobak do filmów |
| Poproś o wiele języków napisów | Do 10 języków jawnych — Utwory i błędy w poszczególnych językach | Jeden wybrany język — Wybierz język podczas zbierania nagrania wideo |
| Wybierz osobę przesyłającą lub automatyczne pochodzenie napisów | Tak — params.auto wybiera jedno źródło bez powrotu między źródłami | Pochodzenie pokazane w metadanych utworu — Dla przeglądanego skrobaka wideo nie ma danych wejściowych dotyczących wyboru pochodzenia |
| Pełny tekst i cytaty ze znacznikiem czasu | Pełny tekst + segmenty czasowe — Start/end razy w sekundach | Pełny tekst + segmenty czasowe — Początek, koniec i czas trwania segmentu w milisekundach |

### Uruchom kolekcję w swojej aplikacji lub agencie

| Funkcja | FlashData | Bright Data YouTube |
| --- | --- | --- |
| Kolekcja interaktywna i tła | Czas rzeczywisty lub async — Wybierz tryb; zapisz zadanie ID do pracy w tle | Synchronizuj skrobanie lub wyzwalacz async — Synchronizacja trwająca dłużej niż jedną minutę jest kontynuowana w postaci migawki |
| Przetwórz dużą przygotowaną listę | Bulk Jobs z plikiem wideo-ID — Konsola lub API; części postępu, manifestu i wyniku | Asynchroniczne partie wejściowe — Uruchom kolekcję i pobierz lub dostarcz jej migawkę |
| Dane wyjściowe dla aplikacji i LLM | JSON, zwykły tekst lub Markdown | Formaty eksportu migawek — JSON, NDJSON i CSV |
| Zachowaj completed wyników do późniejszej analizy | Zapisz wyniki lub użyj pamięci zbiorczej — Przechowuj surowe dane i manifesty we własnym magazynie | Migawki i dostarczanie pamięci — Zrzuty ekranu przechowywane przez 30 dni |
| Samodzielny klient terminalowy | Natywny CLI — Linux, macOS i Windows; brak środowiska wykonawczego Node/Python | Node.js CLI — polecenie bdata zainstalowane na npm |
| MCP, umiejętności i SDK dostęp | Tak | Tak |

Stawki płatne nie obejmują bezpłatnych świadczeń. Obie oferują async miejsc pracy, zbiorcze zbieranie i narzędzia agenta. W razie potrzeby zachowaj gromadzenie komentarzy, inne platformy społecznościowe, zarządzane zbiory danych i istniejące integracje przechowywania i dostarczania.

### Zapłać za pola, których potrzebuje Twoje zadanie

Pobierz metadane dla swojej krótkiej listy. Poproś o napisy tylko do filmów, które będziesz analizować. Odświeżanie metadanych nie wymaga powtarzania etapu transkrypcji.

### Wybierz ścieżkę napisów bezpośrednio

Poproś o wybór języka i wybierz napisy dostarczone przez przesyłającego lub wygenerowane przez YouTube. Utrzymuj widoczne błędy językowe, zamiast po cichu zmieniać wkład badawczy.

### Zachowaj zadanie podczas sesji agenta

Zapisz zaakceptowaną ofertę pracy ID przed odpytywaniem. Późniejszy proces wznawia to samo zadanie i ponownie wykorzystuje pobrany wynik bez przesyłania kolejnego zapytania.

<a id="pricing"></a>
## Porównaj całe zadanie wideo

Nagranie wideo Bright Data może zawierać metadane i podpisy. FlashData wykorzystuje jedno żądanie metadanych i osobne żądanie podpisu. Jedno wejście wykrywające może zwrócić wiele rekordów podlegających rozliczeniu; ten kalkulator uwzględnia tylko wyszukiwania znanych filmów.

| Oferta Bright Data YouTube | Opłata miesięczna | Dołączone zapisy | Stawka płatna / 1,000 rekordów |
| --- | --- | --- | --- |
| Kwalifikujący się bezpłatny basen | $0 | Maksymalnie 5,000/miesiąc dzielone na kwalifikujące się produkty | W ramach zasiłku |
| Płatność za użycie | $0.00 | Brak dodatków płatnych | $1.50 |
| Scale · $499/month | $499.00 | 384,000 | $1.30 additional |
| Przedsiębiorstwo | Niestandardowe | Niestandardowe | Niestandardowe |

Scale zawiera 384,000 rekordów dla $499/miesiąc; dodatkowe rekordy kosztują $1.30 za 1,000. Niestandardowe dopasowanie depozytów korporacyjnych i promocyjnych nie jest modelowane.

| planu FlashData | Na 1,000 żądań | Opłata miesięczna | Żądania w abonamencie miesięcznym |
| --- | --- | --- | --- |
| Płatność za użycie | $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 |

Liczniki uwzględnionych żądań przydzielają pełne saldo planu wspólnego do standardowych YouTube danych. Rozszerzone wyszukiwanie i pobieranie mają osobne stawki. [Pełny cennik](https://flashdata.dev/pl/pricing/youtube-data).

### 10,000 filmów: płać według zużycia po obu stronach

| Zadanie | FlashData żądań | Modelowany rachunek FlashData | Zastosowano Bright Data bezpłatnych rekordów | Modelowany rachunek Bright Data |
| --- | --- | --- | --- | --- |
| Metadane wideo | 10,000 | $5.00 | 0 | $15.00 |
| Metadane wideo | 10,000 | $5.00 | 5,000 | $7.50 |
| Metadane + istniejące podpisy | 20,000 | $10.00 | 0 | $15.00 |
| Metadane + istniejące podpisy | 20,000 | $10.00 | 5,000 | $7.50 |

USD za miesiąc udanego wyszukiwania filmów. Jeden zwrócony zapis wideo Bright Data może zawierać metadane i istniejące napisy; połączone zadanie FlashData wykorzystuje dwa żądania źródłowe. Wykrywanie, komentarze, transkrypcja AI, wyszukiwanie rozszerzone i pobieranie multimediów są wyłączone. Wpisz tylko Bright Data darmowych kredytów nadal dostępnych dla tych rekordów; pula kredytów 5,000 jest współdzielona, ​​a odnawialne darmowe kredyty nie kumulują się z Scale. Ceny FlashData pochodzą z aktualnego katalogu publicznego; całe saldo wybranego planu jest tu przydzielane przed dodatkowym wykorzystaniem. FlashData salda początkowe i próby/agent rejestracji są wyłączone. Modelowany rachunek mierzy wykorzystanie plus ewentualną opłatę miesięczną, a nie zakup nowego portfela: doładowania FlashData rozpoczynają się od $10. Nie uwzględniono żadnych podatków, promocji związanych z depozytem, ​​stawek niestandardowych ani rabatów rocznych.

### Oferty startowe

Kwalifikowalne sprawdzone rejestry FlashData mogą otrzymać początkowy dodatek do standardu 4,000 YouTube. Jest to saldo początkowe, a nie powtarzalny limit miesięczny.

Kwalifikujące się konta Bright Data otrzymują 5,000 darmowych kredytów miesięcznie dzielonych na kwalifikujące się produkty, w tym Scraper API. Jeden dostarczony rekord YouTube zużywa jeden kredyt. Niewykorzystane darmowe środki nie przechodzą na inny; konta z wcześniejszym zatwierdzeniem nie otrzymują powtarzających się bezpłatnych kredytów. Nie łącz miesięcznej darmowej puli z Scale.

<a id="limits"></a>
## Dodatki, batch rozmiarów i running miejsc pracy

| Troska | FlashData | Bright Data Skrobak API |
| --- | --- | --- |
| Co pochłania zasiłek? | Każde zapytanie źródłowe; metadane i podpisy są oddzielne | Pomyślnie dostarczone rekordy; jedno wejście wykrywające może zwrócić wiele |
| Jedno interaktywne żądanie | POST /v1/queries/realtime; wybierz async do pracy w tle | POST /datasets/v3/scrape; po 1 minucie HTTP 202 zwraca migawkę ID i praca jest kontynuowana |
| Większe wejścia | Wielkość partii zależy od planu; użyj przetwarzania zbiorczego dla pliku IDs | Async /trigger akceptuje do 1 GB danych wejściowych; minimalna liczba wejść zależy od zgarniaka |
| Praca biegowa | Współbieżność konta zależy od wybranego planu, jak pokazano poniżej | 5,000 aktywnych stanowisk pracy/snapshots; przekroczenie limitu zwraca 429 |
| Odwrót | Honor Retry-After; Wersje próbne agentów tymczasowych pozwalają na jedno żądanie na sekundę | Honor Retry-After; 25 HTTP 429 odpowiedzi na adres IP w 5 minut mogą wywołać blok 1-godzinny API |
| Zapisane wyniki | Pobierz i przechowuj JSON we własnym magazynie zadań | Zrzuty ekranu przechowywane przez 30 dni; obsługa żądań pobierania do 5 GB, z częściowym pobieraniem w celu uzyskania większych wyników |

| planu FlashData | Równoczesne zapytania | Zapytania na żądanie wsadowe |
| --- | --- | --- |
| Płatność za użycie | 25 | 100 |
| Micro | 50 | 100 |
| Starter | 100 | 200 |
| Pro | 200 | 300 |
| Scale | 300 | 400 |
| Business | 400 | 500 |

Współbieżność to nie liczba żądań na sekundę. Kredyty nadal dotyczą każdego zapytania. [Czas rzeczywisty i async](https://flashdata.dev/pl/docs/reference/realtime-and-async/reference.md) · [Partyjne i luzem](https://flashdata.dev/pl/docs/reference/batch-and-bulk/reference.md) · [Odniesienie do przetwarzania zbiorczego](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md).

<a id="migration"></a>
## Od migawki do zapisanej pracy

### 1. Przygotuj dostęp i zmapuj żądanie

Utwórz lub użyj ponownie klucza z uprawnieniami youtube_metadata. [API kluczy](https://flashdata.dev/app/api-keys) · [Dostępne kredyty](https://flashdata.dev/app/billing). Zapisz FLASHDATA_API_KEY w tajnym magazynie lub wprowadź go w ukrytym wierszu skryptu.

Istniejące zgłoszenie Bright Data w celach informacyjnych dotyczących migracji:

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

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

### 2. Zapisz skrypt przed running nim

Wymagany Python 3.10+. Zainstaluj zależność poleceniem python -m pip install requests. W nowym katalogu roboczym zapisz poniższy pełny skrypt jako migrate-video.py, zanim go uruchomisz.

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

```

Uruchom z tego samego folderu:

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

Alternatywnie użyj Bash, cURL 7.76+ i jq 1.6+. Zapisz cały skrypt poniżej jako migrate-video.sh w nowym folderze roboczym.

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

```

Uruchom z tego samego folderu:

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

Jeśli nadal running, powtórz to samo polecenie, aby wznowić zapisane zadanie. Ukończone przebiegi ponownie wykorzystują result.json bez wywołania API. Nowy folder powoduje przesłanie nowego żądania; sprawdź Historię przed ponowną próbą niepewnego przesłania. Trzymaj klucze poza czatem i nigdy nie przesyłaj ich do podpisanego magazynu URLs.

### 3. Przeczytaj zmapowany zapis

Video-001/video-records.json zachowuje wspólne nazwy pól wideo; result.json zatrzymuje surowe dane i wykorzystanie. Brak metryki pozostaje null. channelName to nazwa wyświetlacza, a nie uchwyt; uploadDateRaw nie jest datą znormalizowaną. Pola transkrypcyjne i medialne nie są sfabrykowane.

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

| Troska | Istniejąca integracja | FlashData zmiany |
| --- | --- | --- |
| Wybór skrobaka | dataset_id=gd_lk56epmy2i5g7lzu0k | źródło=youtube_metadata; w podpisach użyj oddzielnie youtube_transcript |
| Wejście | Zegarek URL w tablicy wejściowej | Znak 11 video_id |
| Uwierzytelnianie | Autoryzacja: na okaziciela | X-API-Key z żądanym pozwoleniem na źródło |
| Prześlij | POST /datasets/v3/trigger → snapshot_id | POST /v1/queries → identyfikator; zapisz paragon |
| Śledź | Postęp migawki → ready | GET /v2/jobs/{id} → job.status=completed |
| Odzyskaj | Pobierz migawkę jako JSON, NDJSON lub CSV | GET /v2/jobs/{id}/results → podpisany magazyn URL; pobierz bez klucza API |
| Pola wideo | video_id, title, description, views, likes, num_comments, video_length | videoId, tytuł, opis, viewCount, likeCount, commentCount, czas trwania (sekundy) |
| Kanał i data | youtuber to uchwyt; date_posted to data | Zachowaj channelName, channelId i uploadDateRaw; nie zmieniaj nazwy wyświetlanej na uchwyt |
| Transkrypcja | Może zostać dołączony jako transkrypcja i formatted_transcript w nagraniu wideo | Oddzielne żądanie utworu; fullText i segmenty wykorzystują sekundy. Mapuj znaczniki czasu, jeśli istniejący analizator składni oczekuje milisekund |
| Media bezpośrednie URL | video_url to transmisja strumieniowa URL | Użyj osobnego procesu pobierania YouTube, aby dostarczyć go do swojego magazynu |

### Opcjonalne napisy

Przyznaj uprawnienia youtube_transcript. Prześlij to ciało do POST https://data.flashdata.dev/v1/queries z X-API-Key i zapisz własne zadanie ID. Spowoduje to dodanie jednego standardowego żądania na film:

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

auto=false wybiera podpisy dostarczone przez przesyłającego. Zachowaj język i pochodzenie. Czasy transkrypcji w formacie Bright Data używają milisekund; Segmenty FlashData wykorzystują sekundy. Pomnóż przez 1,000 dla parsera oczekującego milisekund. [Uruchamialny przepis na napisy ze znacznikiem czasu](https://flashdata.dev/pl/docs/guides/timestamped-captions-recipe/reference.md).

### Odzyskiwanie

- Pending/processing: wznawia zapisany ID. Sondaż jest ograniczony i honoruje numeryczne Retry-After.
- 401/403: usunąć uwierzytelnianie lub pozwolenie; zatrzymać się przy cofnięciu.
- 402: przywróć dostępne saldo właściciela przed kontynuowaniem.
- 429: przestań wysyłać i honoruj Retry-After; nie ponawiaj automatycznie przesyłania.
- Limit czasu bez potwierdzenia: sprawdź Historię przed utworzeniem kolejnego folderu.

[Błędy i kody stanu](https://flashdata.dev/pl/docs/errors/reference.md).

<a id="agents"></a>
## Jedno połączenie, zadania wielokrotnego użytku

Kwalifikujący się agenci mogą rozpocząć od kredytu 1 (do standardu 100 YouTube) dla godzin 72. Reuse zapisany dostęp pierwszy; metadane i podpisy podzielić uprawnienia.

1. Odkryj filmy i krótką listę przed wzbogaceniem.
2. Pobierz jeden film, sprawdź pola i wybór podpisów, a następnie zapisz nieprzetworzone dane wyjściowe.
3. Poproś właściciela o dokończenie rejestracji/sign-in i zatwierdzenie zakresów i współdzielonego salda. Niewykorzystane środki tymczasowe nie podlegają przeniesieniu.
4. Przechowuj dane uwierzytelniające i uruchamiaj foldery w ramach zadań cyklicznych. Wykorzystaj wyniki ponownie i zatrzymaj w przypadku odwołania lub wyczerpania salda.

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

[Próba i roszczenia](https://flashdata.dev/pl/docs/guides/agent-onboarding/reference.md) · [Powtarzające się zadania](https://flashdata.dev/pl/docs/guides/recurring-tasks/reference.md) · [Zapisz wyniki](https://flashdata.dev/pl/docs/guides/save-results/reference.md).

<a id="faq"></a>
## Pytania dotyczące migracji

### Czy to jest porównanie wyszukiwania Bright Data Google?

Na tej stronie opisano skrobak YouTube API. Wyszukiwarka Google wykorzystuje produkt SERP Bright Data z różnymi jednostkami cenowymi i konfiguracją żądań. Porównanie wyszukiwania Google ma swoją własną stronę.

### Czy Bright Data pobiera podwójną opłatę za metadane i transkrypcję?

Jego schemat wideo YouTube zawiera pola metadanych i podpisów w zwróconym zapisie wideo. Nie licz automatycznie dwóch rekordów. FlashData wykorzystuje oddzielne zapytania dotyczące metadanych i transkrypcji; łączne obciążenie w kalkulatorze liczy dwa żądania FlashData na film. Pole podpisu może być niedostępne w przypadku konkretnego filmu.

### Który dostawca ma większy bezpłatny limit?

Bright Data oferuje kwalifikujące się konta 5,000 współdzielone kredyty co miesiąc. Kwalifikujący się dodatek rejestracyjny FlashData stanowi saldo początkowe, a okres próbny dla agenta tymczasowego jest oddzielny. Oferty te mają różne zasady odnawiania. Użyj pozostałego wolnego wejścia do dokładnego modelowania Bright Data PAYG.

### Czy mogę wymienić każdy zgarniacz Bright Data?

Przenieś obsługiwane przepływy pracy związane z metadanymi, wyszukiwaniem, kanałami i napisami YouTube, których potrzebujesz. Zachowaj gromadzenie komentarzy, inne platformy społecznościowe, zarządzane zbiory danych i istniejące integracje pamięci masowej i dostarczania tam, gdzie Twoja aplikacja nadal od nich zależy.

### Czy obaj dostawcy obsługują agentów AI?

Tak. Obydwa oferują MCP, CLI i umiejętności agenta. Samodzielne CLI FlashData, uprawnienia źródłowe i współdzielone saldo Google/YouTube są przydatne w ukierunkowanym procesie badawczym. Wykorzystaj ponownie zapisany dostęp i poproś właściciela o zatwierdzenie dalszego dostępu do konta przed zaplanowaniem pracy cyklicznej.

### Czy po migracji mogę ponownie wykorzystać migawkę ID?

Nie. Zapisz migawkę Bright Data i nowe zadanie FlashData ID jako osobne identyfikatory. W przykładzie ponownie wykorzystano tylko zapisany paragon FlashData i sprawdzano, czy zwrócony film odpowiada żądanemu ID.

[Zdobądź klucz API](https://flashdata.dev/signup) · [Google Porównanie wyszukiwania](https://flashdata.dev/pl/compare/brightdata/reference.md).
