# Supadata Alternatywa dla YouTube Danych

Porównaj koszty transkrypcji i metadanych wynoszące YouTube, natywne funkcje napisów i dostęp agenta. Przeprowadź migrację z Supadata z uruchamialnymi przykładami Python i Bash.

Supadata faktów sprawdzonych 2026-11-10. Ceny i uprawnienia próbne FlashData korzystają z aktualnych katalogów publicznych.

- [Funkcje](#features)
- [Porównaj koszty](#costs)
- [Przenieś transkrypcję](#migration)
- [Metadane i zbiorcze](#workflows)
- [Dla agentów AI](#agents)
- [Często zadawane pytania](#faq)

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

Dla aplikacji i agentów gromadzących istniejące YouTube podpisów i metadanych.

### Zachowaj ekonomiczne pobieranie płatnych YouTube

| Funkcja | FlashData | Supadata |
| --- | --- | --- |
| Płatne użytkowanie bez subskrypcji | Tak — Kredyty typu pay-as-you-go; zakupy od $10 | Płatne plany — Basic: $60/rok · Pro: $17/miesiąc |
| Natywny transkrypcja lub metadane · cena za 1,000 | $0.50 — Płać zgodnie z rzeczywistym użyciem · bez miesięcznych opłat | $5.67 na Pro — $17 / 3,000 included credits; full allowance wykorzystano |
| Pakiet bez planu miesięcznego | Do 100 zapytań / Partia — Klucz właściciela płatności zgodnie z rzeczywistym użyciem; limit próbny jest odrębny | Pro i więcej — Wideo i transkrypcja batch punktów końcowych |

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

| Funkcja | FlashData | Supadata |
| --- | --- | --- |
| Znajdź filmy według tematu | Tak — Wyszukiwanie słów kluczowych z filtrami daty, czasu trwania, typu i sortowania | Tak — Wyszukiwanie filmów, kanałów i list odtwarzania za pomocą filtrów |
| Odśwież metadane wideo bez pobierania napisów | Tak — Tytuł, kanał, czas trwania, miniatury i liczba interakcji | Tak — Oddzielny punkt końcowy metadanych z polami autora, multimediów i statystyk |
| Języki napisów w metadanych wideo | Tak — hasTranscripts i transcriptLanguages | W odpowiedzi transkrypcyjnej — availableLangs; oddzielny schemat metadanych |

### Zachowaj transkrypcje przydatne do cytowania i analiz

| Funkcja | FlashData | Supadata |
| --- | --- | --- |
| Tekst ze znacznikiem czasu w przypadku cytatów źródłowych | JSON segmentów w ciągu kilku sekund — Tekst z czasem rozpoczęcia i zakończenia | JSON fragmentów w milisekundach — Tekst z przesunięciem i czasem trwania |
| Pełny tekst i sygnatury czasowe tej samej odpowiedzi | Tak — fullText i segmenty są zwracane razem | Wybierz tekst lub fragmenty — tekst=true zwraca ciąg znaków; w przeciwnym razie dołącz fragmenty w swojej aplikacji |
| Wiele istniejących języków napisów w jednym żądaniu | Do 10 języków — Śledzi i błędy w poszczególnych językach | Jeden preferowany język — lang w punkcie końcowym transkrypcji |
| Wybierz napisy dostarczone przez przesyłającego lub wygenerowane przez YouTube | Tak — Wyraźne params.auto=false lub true | Nie udokumentowano żadnego selektora pochodzenia — tryb wybiera pobieranie natywne zamiast generowania AI |
| Obsługuj niedostępne podpisy w sposób jawny | Tylko istniejące utwory — Tablice językowe zwracają ścieżki i błędy; brak nowej transkrypcji | Wybierz opcję natywną lub rezerwową AI — mode=auto może generować zamianę mowy na tekst; natywny ogranicza pobieranie do istniejących napisów |

### Przejdź od jednego żądania do powtarzalnego przepływu pracy

| Funkcja | FlashData | Supadata |
| --- | --- | --- |
| Żądania interaktywne i w tle | Czas rzeczywisty lub async — Wybierz tryb wykonania i zapisz zadanie ID | Wynik lub transkrypcja zadania — HTTP 200 zwraca dane; HTTP 202 zwraca pracę ID |
| Przetwórz przygotowaną listę filmów | Partia API lub Bulk Jobs konsoli — Prześlij plik ID; zachowaj części manifestu i wyniku | Asynchronicznie batch API · Pro+ — Akceptuje listy wideo, playlisty i kanały |
| Zbierz całą playlistę lub kanał | Dostarcz wyraźny film IDs — Przygotuj listę przed przetwarzaniem wsadowym lub masowym | Filmiki Lista odtwarzania lub kanał batch — Regular videos; excludes Shorts and live |
| Dane wyjściowe dla aplikacji i LLM | JSON, zwykły tekst lub Markdown — Wybierz odpowiedź i format treści | JSON z tekstem lub fragmentami — Użyj treści transkrypcji w swojej aplikacji lub monicie |
| Pakiety SDK języka | Python, TypeScript i Start | Python i JavaScript / TypeScript |
| Dostęp MCP dla hosta agenta | Tak — Zdalny MCP z klawiszem OAuth lub API | Tak — Serwer MCP z poświadczeniami Supadata |
| Programowa wersja próbna przed zarejestrowaniem właściciela | Tak — Do 100 żądań transkrypcji natywnych · 72 godzin | Najpierw klucz konta API — 100 darmowych kredytów co miesiąc po rejestracji |

Supadata obsługuje transkrypcję generowaną przez sztuczną inteligencję i wiele platform społecznościowych. Punkty końcowe napisów FlashData pobierają istniejące ścieżki YouTube. Obie usługi oferują MCP i SDK.

### Zachowaj przystępną cenę niewielkiego nakładu pracy badawczej

Zapłać za YouTube żądań danych, z których korzystasz. Dodaj subskrypcję później, jeśli jej niższa stawka i zawarte w niej saldo odpowiadają Twojemu wolumenowi.

[Wyceń swój nakład pracy](#costs)

### Podaj wyraźnie źródło napisów

Wybierz napisy wygenerowane przez YouTube lub dostarczone przez przesyłającego, zachowaj zwrócony język i sygnatury czasowe cytatów. Poproś o istniejące ścieżki w kilku językach bez generowania nowej zamiany mowy na tekst.

[Zamapuj swój czytnik transkrypcji](#migration)

### Rozwijaj się od jednego filmu do potoku

Użyj tego samego kształtu żądania dla pracy realtime, async i batch. Dodaj Google Szukaj do przepływu pracy badawczej, korzystając z tego samego konta i wspólnego salda.

[Zbuduj następny krok](#workflows)

<a id="costs"></a>
## Wyceń cały proces wideo

USD. Jedna transkrypcja natywna w jednym języku lub jedno wyszukiwanie metadanych to jedno żądanie i jeden kredyt Supadata. Metadane plus natywna transkrypcja to dwa żądania na film. FlashData korzysta ze swojego aktualnego katalogu danych YouTube, stosując uwzględnioną wartość kredytu przed dalszym wykorzystaniem. Wyświetlana stawka jednostkowa to wskaźnik wykorzystania; Supadata to opłata za plan podzielona przez pełny miesięczny dodatek. Basic jest tylko roczny: $60 płatne z góry, pokazywane jako równowartość $5/miesiąc z 300 kredytów co miesiąc, a nie 3,600 dostępne natychmiast. Inne plany Supadata korzystają z miesięcznych cen katalogowych. Automatyczne ładowanie jest wyłączone w tym oszacowaniu, dopóki nie zostanie wybrane; w przypadku wybrania najmniejsze całe opublikowane pakiety pokrywają niedobór. Rzeczywisty czas automatycznego doładowania może zostać zakupiony wcześniej. Kwoty zakupu nie zakładają salda początkowego. Doładowania FlashData rozpoczynają się o $10; zakup może pozostawić środki na później. Supadata miesięczne kredyty nie podlegają przeniesieniu. Kredyty próbne, podatek, inne wykorzystanie API, roczne zniżki na inne plany, generowanie i tłumaczenie AI nie są uwzględnione. Przy zerowych żądaniach wybrana opłata planowa pozostaje, a efektywna stawka jest nieokreślona.

### FlashData YouTube Plany danych

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

[Pełna cena YouTube danych](https://flashdata.dev/pl/pricing/youtube-data)

### Supadata opublikowało plany

| planu Supadata | Zaplanuj płatność | Kredyty / miesiąc | Za 1,000 przy pełnym limicie | Pakiet automatycznego ładowania |
| --- | --- | --- | --- | --- |
| Bezpłatnie | $0.00 / miesiąc | 100 | $0.00 | Niedostępne |
| Basic · annual only | $60.00 / rok ($5.00 / odpowiednik miesiąca) | 300 | $16.67 | $10.00 / 1,000 kredytów |
| Pro · monthly | $17.00 / miesiąc | 3,000 | $5.67 | $10.00 / 1,000 kredytów |
| Mega · monthly | $47.00 / miesiąc | 30,000 | $1.57 | $10.00 / 5,000 kredytów |
| Giga · monthly | $297.00 / miesiąc | 300,000 | $0.99 | $20.00 / 20,000 kredytów |
| Supa · monthly | $897.00 / miesiąc | 1,000,000 | $0.90 | $20.00 / 20,000 kredytów |

### Przykład: metadane i natywna transkrypcja każdego filmu

FlashData płatności na bieżąco w porównaniu do Supadata Mega miesięcznie, z uwzględnieniem automatycznego doładowania. To jest jedno wyraźne porównanie planów; samodzielnie wybierz inne plany w kalkulatorze HTML.

| Filmy / miesiąc | Żądania danych | FlashData modelowane użycie | Supadata Mega + całe pakiety doładowań | Pakiety doładowania |
| --- | --- | --- | --- | --- |
| 100 | 200 | $0.10 | $47.00 | 0 |
| 1,000 | 2,000 | $1.00 | $47.00 | 0 |
| 10,000 | 20,000 | $10.00 | $47.00 | 0 |
| 100,000 | 200,000 | $100.00 | $387.00 | 34 |

### Bezpłatny dostęp i generowanie AI

Supadata Darmowe doładowania 100 kredytów miesięcznie. Jego natywna transkrypcja wykorzystuje jeden kredyt; Generowanie sztucznej inteligencji zużywa dwa kredyty na minutę. Dlatego też transkrypcja wygenerowana o długości 30 minut wykorzystuje 60 kredytów. Domyślny tryb automatyczny może wywołać generację; mode=native pozwala uniknąć tego błędu awaryjnego. Z tego porównania wyłączone są generowanie, tłumaczenie i wyszukiwanie rozszerzone.

Kwalifikujące się zweryfikowane rejestracje FlashData mogą otrzymać początkowy dodatek w wysokości do 4,000 standardowych YouTube żądań danych. To nie jest miesięczny bezpłatny poziom.

<a id="migration"></a>
## Przeprowadź migrację natywnego czytnika transkrypcji

| Zmień | Supadata | FlashData | Co robić |
| --- | --- | --- | --- |
| Żądanie | GET /v1/transcript z adresem URL, językiem, tekstem i trybem | POST /v1/queries/realtime ze źródłem, video_id i parametrami | Wyodrębnij znak 11 YouTube ID. Klucz Supadata nie uwierzytelnia do FlashData. |
| Uwierzytelnianie | x-api-key: Twój klucz Supadata | X-API-Key: Twój klucz FlashData | Utwórz lub wykorzystaj ponownie dane uwierzytelniające z uprawnieniami youtube_transcript. W nazwach nagłówków wielkość liter nie jest rozróżniana; zmiany wiarygodności. |
| Natywny kontra wygenerowany | mode=native pobiera istniejące napisy; auto może wrócić do AI; generuj zawsze używa sztucznej inteligencji | youtube_transcript czyta istniejące podpisy YouTube | Najpierw przenieś pobieranie natywne. W przypadku filmów wymagających nowej transkrypcji zachowaj osobny etap zamiany mowy na tekst. |
| Pochodzenie napisów | tryb wybiera pobieranie zamiast generowania | params.auto=true wybiera napisy wygenerowane przez YouTube; false wybiera podpisy dostarczone przez przesyłającego | Te ustawienia automatyczne nie są równoważne. FlashData auto nigdy nie rozpoczyna zamiany mowy na tekst. |
| Język | preferowany jest język; niedostępne języki mogą powrócić do pierwszego dostępnego | params.language jest jednoznaczne; auto=true wypróbowuje wariant -orig, a następnie żądany kod | Sprawdź languageCode i requestedLanguageCode. FlashData nie wybiera po cichu innego języka ani pochodzenia napisów. |
| Segmenty | content[]: tekst, przesunięcie i czas trwania w milisekundach | wyniki[0].segments[]: tekst, początek i koniec w sekundach | offset = round(początek × 1000); czas trwania = runda ((koniec - początek) × 1000). Zachowaj nakładanie się, zamiast zmieniać wskazówki. |
| Zwykły tekst | tekst=true zwraca treść jako ciąg znaków | wyniki[0].fullText | Przeczytaj fullText dla podsumowania i zachowaj segmenty dla cytatów ze znacznikami czasu. |
| Odkrycie języka | availableLangs w odpowiedzi transkrypcyjnej | transcriptLanguages w youtube_metadata | Pobieraj metadane, gdy Twoja aplikacja potrzebuje pełnej listy języków. Nie wymyślaj availableLangs z jednego zwróconego utworu. |
| Zakończenie | HTTP 200 wynik lub HTTP 202 + jobId | Stan w czasie rzeczywistym=done; async zgłoszenia powrót FlashData praca IDs | Obsługuj stany każdego dostawcy osobno. Zakończ istniejące Supadata zadań przed migracją nowych. |

### 1. Skonfiguruj dostęp

Utwórz lub użyj ponownie klucza FlashData z uprawnieniami youtube_transcript w [API kluczy](https://flashdata.dev/app/api-keys). Dodaj youtube_metadata dla opcjonalnego zadania dotyczącego metadanych. Sprawdź [dostępne kredyty](https://flashdata.dev/app/billing) lub użyj [dostęp próbny uprawnionego agenta](#agents). Przechowuj klucze w środowisku lub tajnym magazynie.

Zastępuje się żądanie natywne Supadata:

```bash
# Existing Supadata call: use your saved SUPADATA_API_KEY.
curl --get --fail-with-body --silent --show-error \
  'https://api.supadata.ai/v1/transcript' \
  --header "x-api-key: $SUPADATA_API_KEY" \
  --data-urlencode 'url=https://www.youtube.com/watch?v=FUfGcZ092b0' \
  --data-urlencode 'lang=en' --data-urlencode 'text=false' \
  --data-urlencode 'mode=native'
```

FlashData zamiennik JSON korpusu dla POST /v1/queries/realtime:

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

### 2. Zapisz skrypt, a następnie uruchom go

Wybierz Python lub Bash. Każdy nowy folder wyjściowy przesyła jedno żądanie; ponowne użycie folderu odczytuje zapisane dane wyjściowe bez kolejnego wywołania API. Wersje mają wspólny format zapisanego pliku. Wybierz film z żądaną ścieżką napisów.

#### Python

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

```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")
    content = []
    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")
        content.append({"text": text, "offset": round(start * 1000),
                        "duration": round((end - start) * 1000)})
    normalized = {"content": content, "lang": item["languageCode"].removesuffix("-orig")}
else:
    normalized = {name: item.get(name) for name in (
        "videoId", "title", "channel", "duration", "viewCount", "likeCount",
        "commentCount", "hasTranscripts", "transcriptLanguages", "chapters")}
(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'))}")

```

Uruchom z tego folderu roboczego:

```bash
python youtube-migrate.py transcript FUfGcZ092b0 transcript-001
```

Spowoduje to wybranie napisów w języku angielskim wygenerowanych przez YouTube. Dodaj --origin instrukcję dla ścieżki dostarczonej przez przesyłającego lub --language KOD, aby wybrać język.

Opcjonalne oddzielne żądanie metadanych:

```bash
python youtube-migrate.py metadata FUfGcZ092b0 metadata-001
```

#### Bash

Wymaga Bash, cURL 7.76+ i jq 1.6+. Zapisz cały skrypt jako youtube-migrate.sh w swoim folderze roboczym przed running:

```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
      {videoId, title, channel, duration, viewCount, likeCount, commentCount,
       hasTranscripts, transcriptLanguages, chapters}
    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
      | {lang: (.languageCode | sub("-orig$"; "")), content: [.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, offset: (.start * 1000 | round), duration: ((.end - .start) * 1000 | round)} 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"

```

Uruchom z tego folderu roboczego:

```bash
bash youtube-migrate.sh transcript FUfGcZ092b0 transcript-001
```

Opcjonalne argumenty po folderze to język i pochodzenie; na przykład en manual wybiera angielskie napisy dostarczone przez przesyłającego.

Opcjonalne oddzielne żądanie metadanych:

```bash
bash youtube-migrate.sh metadata FUfGcZ092b0 metadata-001
```

Aby uzyskać tymczasowy dostęp próbny, uruchamiaj żądania sekwencyjnie w odstępie co najmniej jednej sekundy.

### 3. Przeczytaj wynik

response.json zachowuje surowy wynik i wykorzystanie. normalized.json konwertuje sekundy segmentu transkrypcji na przesunięcie/duration milisekundy. Jest to adapter segmentowy, a nie pełna odpowiedź zgodna z Supadata: availableLangs nie jest produkowana. Dane wyjściowe metadanych zachowują wartości null. Nieudane lub przerwane żądania zachowaj dowody i przestań.

Przykładowe normalized.json:

```json
{
  "content": [
    {
      "text": "Example caption text.",
      "offset": 1250,
      "duration": 2250
    }
  ],
  "lang": "en"
}
```

[Schemat transkrypcji](https://flashdata.dev/pl/docs/sources/youtube_transcript/reference.md)

<a id="workflows"></a>
## Metadane i masowe przepływy pracy

| Dane | Supadata /v1/metadata | FlashData youtube_metadata |
| --- | --- | --- |
| Tożsamość wideo | id | wyniki[0].videoId |
| Tytuł i opis | tytuł, opis | wyniki[0].tytuł, wyniki[0].opis |
| Kanał | author.displayName; additionalData.channelId | wyniki[0].kanał; wyniki[0].channelId |
| Zaangażowanie | stats.views, stats.likes, stats.comments | wyniki[0].viewCount, likeCount, commentCount |
| Czas trwania | media.duration (sekundy) | wyniki[0].czas trwania (sekundy) |
| Miniatura | media.thumbnailUrl | wyniki[0].thumbnails[]; wybierz rozmiar, jakiego potrzebuje Twoja aplikacja |
| Data publikacji | createdAt | wyniki[0].uploadDate; znormalizuj jego format w swojej aplikacji |
| Odkrycie napisów | Przeczytaj availableLangs z odpowiedzi w transkrypcie | wyniki[0].hasTranscripts i transcriptLanguages |

### Kilka istniejących języków w jednym żądaniu

Wyślij tablicę językową, aby otrzymać ścieżki i błędy, nawet w przypadku tablicy zawierającej jeden język. Sprawdź błędy, nawet jeśli status to done. Są to istniejące utwory, a nie przetłumaczone lub wygenerowane napisy.

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

### Wzbogać bibliotekę naukową

Pobierz metadane raz, zapisz wideo ID i dostępne języki napisów, a następnie pobierz potrzebny utwór. Zachowaj liczbę zerowych interakcji jako null zamiast konwertować je na zero.

[YouTube Najlepsze praktyki dotyczące danych](https://flashdata.dev/pl/docs/guides/youtube-data-guide/reference.md)

### Przetwórz listę filmów IDs

Rozszerz swoje dane wejściowe na jawne wideo IDs, a następnie użyj pliku wsadowego lub pliku zbiorczego. FlashData nie akceptuje Supadata playlistId jako wejścia batch. Zapisz status i dane wyjściowe poszczególnych elementów przed ponowną próbą failed elementów.

[Odniesienie do przetwarzania zbiorczego](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md)

### Prowadź badania zgodnie z harmonogramem

Zachowaj dane logowania właściciela, sprawdź completed filmów i przeczytaj zapisane dane wyjściowe po ponownym uruchomieniu. Zatrzymaj w przypadku cofnięcia dostępu lub niewystarczającego salda; nie twórz kolejnej wersji próbnej, aby kontynuować zaplanowane zadanie.

[Powtarzające się zadania agenta](https://flashdata.dev/pl/docs/guides/recurring-tasks/reference.md)

### Production decyzji migracyjnych

- Rozwiąż wejścia playlisty/channel na jawne wideo IDs przed FlashData Wsadowe lub masowe przetwarzanie plików; Supadata playlistId nie jest wejściem typu drop-in.
- Wyszukiwanie Supadata kosztuje jeden kredyt na stronę z wynikami 20 lub ceil(limit/20) z limitem. FlashData standard YouTube Wyszukiwanie obsługuje do 20 wyników; Wyszukiwanie rozszerzone ma osobną stawkę. Mapuj filtry i nie przesyłaj tokenów stron.
- Supadata dokumentuje jednogodzinne okno wyników zadania transkrypcji completed. Opróżnij istniejące zadania i zapisz wyniki przed migracją nowych zadań. Zachowaj osobne zadanie specyficzne dla dostawcy IDs.
- Zachowaj wieloplatformowe multimedia, ekstrakcję AI, tłumaczenie i transkrypcję audio na istniejących ścieżkach, chyba że wdrożono równoważny przepływ pracy.

<a id="agents"></a>
## Okres próbny agenta, zgłaszanie roszczeń i powtarzające się użycie

Kwalifikujący się agenci mogą zacząć od 1 kredytów, aż do 100 wniosków o transkrypcję natywną na 72 godzin. Metadane i transkrypcje korzystają z tego dodatku.

1. Najpierw ponownie wykorzystaj istniejący dostęp; w przeciwnym razie rozpocznij jeden kwalifikujący się okres próbny z jedynie niezbędnymi uprawnieniami.
2. Zwróć użyteczny wynik, zapisz surowe dane wyjściowe i użycie oraz zachowaj ten sam profil i katalog stanu.
3. Właściciel loguje się lub rejestruje, weryfikuje adres e-mail i zatwierdza roszczenia, zakresy i dostęp do salda współdzielonego.
4. Użyj ponownie poświadczeń właściciela do zadań cyklicznych. Niewykorzystane kredyty próbne nie są przenoszone. Zatrzymaj się po odwołaniu lub niewystarczającym saldzie; nigdy nie twórz kolejnej wersji próbnej, aby kontynuować.

```text
Migrate the native YouTube transcript part of this project from Supadata to FlashData.
Read https://flashdata.dev/auth.md and https://flashdata.dev/docs/sources/youtube_transcript/reference.md.
Reuse a saved FlashData credential before requesting an eligible temporary trial.
Use youtube_transcript permission and one explicit video ID, language and caption origin.
Do not map Supadata mode=auto to FlashData auto=true: the latter selects existing YouTube-generated captions.
Save the raw response and actual usage. Convert segment seconds to milliseconds if my reader expects offset/duration.
Do not fabricate captions or available languages. Report missing tracks and keep AI generation separate.
Ask the owner to claim access before recurring use. Store credentials outside chat and source control.
Reuse saved outputs on restart and stop after revocation; never create repeated trials to keep running.
```

[Próba i roszczenia](https://flashdata.dev/pl/docs/guides/agent-onboarding/reference.md) · [Samodzielny CLI](https://flashdata.dev/pl/docs/guides/flashdata-cli/reference.md) · [Połączenie MCP](https://flashdata.dev/pl/docs/integrations/mcp-clients/reference.md)

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

### Czy FlashData może zastąpić transkrypcję AI Supadata?

Źródła transkrypcji i napisów FlashData pobierają napisy już obecne w YouTube. Nie dokonują transkrypcji dźwięku, nie tłumaczą tekstu ani nie przeprowadzają analizy wizualnej. Przenieś natywne pobieranie YouTube do FlashData; zachowaj osobną usługę zamiany mowy na tekst, międzyplatformową ekstrakcję wideo lub sztuczną inteligencję, gdy aplikacja tego potrzebuje.

### Co kupuje jedno żądanie?

Kalkulator obejmuje jedną istniejącą transkrypcję w jednym języku lub jedno wyszukiwanie metadanych wideo. Pobranie obu wymaga dwóch żądań na film. Supadata rachunki za każdą z tych operacji w ramach jednego kredytu. FlashData wykorzystuje szybkość transmisji danych YouTube wybranego planu. Wyszukiwanie rozszerzone, transkrypcja AI, tłumaczenie i dostarczanie multimediów wykraczają poza te szacunki.

### Czy FlashData zawsze jest tańsze?

Porównaj swoje rzeczywiste obciążenie pracą i wybrane plany. Supadata obejmuje 100 kredytów co miesiąc za darmo. Okres próbny agenta tymczasowego FlashData jest ograniczony i wygasa; nie jest to miesięczny bezpłatny poziom. Przy niskim wolumenie bezpłatny dodatek może pokryć całe zadanie. Opłaty za plan płatny, pakiety doładowań i niewykorzystane salda wpływają na kwotę, którą płacisz.

### Czy Supadata obsługuje już MCP i SDK?

Tak. Obie usługi obsługują integracje MCP i Python/JavaScript. FlashData zapewnia także wersję Go SDK, samodzielną wersję CLI oraz wersję próbną agenta tymczasowego, do której można ubiegać się o dostęp okresowy. Wybierz interfejs obsługiwany przez Twojego hosta; Sam MCP nie jest powodem do zmiany.

### Co się stanie, jeśli brakuje ścieżki z napisami?

Potraktuj to jako lukę w danych. FlashData nie przełącza pomiędzy napisami dostarczonymi przez przesyłającego i wygenerowanymi przez YouTube ani nie syntezuje transkrypcji. W przypadku tablicy językowej sprawdź błędy, nawet jeśli żądanie to done. Supadata może wygenerować transkrypcję w trybie automatycznym, podczas gdy tryb natywny może zwrócić HTTP 206 w przypadku niedostępnego transkrypcji; jego dokumentacja wystawia tę odpowiedź na jeden kredyt.

### Czy mogę zachować istniejący kształt odpowiedzi aplikacji?

Zachowaj swój własny adapter. Przykład konwertuje segmenty FlashData na wpisy treści z przesunięciem i czasem trwania w milisekundach, ale nie zapewnia pełnej odpowiedzi zgodnej z Supadata. Przeczytaj metadane FlashData, jeśli potrzebujesz dostępnych języków, i bezpośrednio migruj status zadania, błędy i obsługę użycia.

[Zdobądź klucz API](https://flashdata.dev/signup)
