# ScrapeCreators Alternatywa dla YouTube Danych

Porównaj koszty metadanych i napisów wynoszące YouTube, pakiety przedpłacone i trafienia w pamięci podręcznej. Przeprowadź migrację do FlashData z uruchamialnymi adapterami terenowymi Python i Bash dla aplikacji i agentów.

Świeże dane wideo. Mniejsze wydatki początkowe. Przenieś metadane i podpisy YouTube, zachowując resztę integracji danych społecznościowych.

ScrapeCreators fakty zweryfikowane 2026-11-10. Ceny FlashData i dodatki próbne pochodzą z jego obecnych publicznych katalogów.

- [Funkcje](#features)
- [Ceny i pamięć podręczna](#costs)
- [Przenieś żądanie](#migration)
- [Przepływ pracy badawczej](#workflow)
- [Dla agentów AI](#agents)
- [Często zadawane pytania](#faq)

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

### Obniż koszt świeżych YouTube danych

| Funkcja | FlashData | ScrapeCreators |
| --- | --- | --- |
| Wstęp płatny / 1,000 metadanych lub połączeń z napisami | $0.50 — Korzystanie z płatności zgodnie z rzeczywistym użyciem | $1.88 — Freelance · nowe połączenia jednokredytowe |
| Najniższa wymieniona stawka jednostkowa / 1,000 połączeń | $0.20 — Opcjonalny plan miesięczny; jego opłata nadal obowiązuje | $0.994 — Business · $497 pakiet przedpłacony; niestandardowe przedsiębiorstwo wyłączone |
| Pierwszy płatny zakup kredytowy | Od $10 | $47 — Pakiet 25,000-kredytów Freelance |
| Płać na bieżąco, bez miesięcznej opłaty | Tak | Tak |

### Znajdź filmy i odśwież potrzebne fakty

| Funkcja | FlashData | ScrapeCreators |
| --- | --- | --- |
| Znajdź filmy według słów kluczowych i filtrów | Tak — Filtry daty, czasu trwania, typu i sortowania | Tak — Filtry wyszukiwania i paginacja tokenów kontynuacji |
| Metadane znanego filmu | Tak — Tytuł, kanał, czas trwania, miniatury i liczba interakcji | Tak — Video/Short Punkt końcowy Szczegóły |
| Znaczniki rozdziałów do nawigacji | Tak — include_chapters; tytuły z czasami start/end, jeśli są obecne | Tak — rozdziały w odpowiedzi wideo, jeśli są obecne |
| Odkryj dostępne ścieżki z napisami | Lista języków metadanych — hasTranscripts i transcriptLanguages | Metadane captionTracks — Kody języków i szczegóły utworu |

### Zachowaj jednoznaczność wyboru podpisów i dowodów

| Funkcja | FlashData | ScrapeCreators |
| --- | --- | --- |
| Tekst i sygnatury czasowe tej samej odpowiedzi | Pełny tekst + segmenty czasowe — Start/end razy w sekundach | Pełny tekst + segmenty czasowe — startMs/endMs jako struny milisekundowe |
| Kilka języków napisów w jednym żądaniu | Do 10 języków — Istniejące utwory i błędy w poszczególnych językach | Jeden wybrany język — wybór języka lub original_audio na połączenie transkrypcyjne |
| Wybierz wyraźnie pochodzenie podpisu | Wygenerowano przez osobę przesyłającą lub YouTube — params.auto wybiera jedno źródło | Wybór języka i dźwięku mówionego — original_audio nie jest przełącznikiem pochodzenia napisów |
| Obsługa brakujących napisów | Istniejące utwory i wyraźne błędy — Tablice językowe zachowują udane ścieżki i zgłaszają brakujące selekcje | Pola transkrypcji o wartości null — Brakujące żądane utwory kosztują zero kredytów; brak transkrypcji AI YouTube |
| Wybierz, ile lat mogą mieć ponownie wykorzystywane dane | Polityka pamięci podręcznej w Twojej aplikacji — Oszczędzaj czas pobierania i decyduj, kiedy pobrać ponownie | cache_max_age — opcje 1–30-dniowe; trafienia w pamięci podręcznej kosztują zero kredytów i ujawniają cached_at |

### Uruchom powtarzalny przepływ danych

| Funkcja | FlashData | ScrapeCreators |
| --- | --- | --- |
| Przetwórz zapisany plik wideo IDs | Zarządzane zadania zbiorcze — Prześlij plik, śledź jego zadanie i pobierz wyniki | Połączenia z punktem końcowym dla poszczególnych wideo — Zarządzaj pętlą plików i przechowywaniem wyników w swojej integracji |
| Przenieś długie kolekcje do zadań w tle | Interfejsy API asynchroniczne, wsadowe i zbiorcze — Utrzymaj zadanie IDs, śledź status i pobieraj wyniki | Synchroniczne wywołania YouTube — Kolejkuj i sprawdzaj połączenia wideo w swoim pracowniku |
| Ustrukturyzowane i czytelne dane wyjściowe | JSON, zwykły tekst lub Markdown — Wybrano poprzez API nagłówków odpowiedzi | Formaty JSON API i CLI — CLI eksportuje również CSV, tabele i Markdown |
| Instalacja terminala | Samodzielny plik wykonywalny — Linux, macOS i Windows; brak środowiska wykonawczego Node/Python | npm CLI — @scrapecreators/cli |
| MCP i umiejętności agenta | Tak | Tak |
| Przejdź od danych do hostowanego dostarczania multimediów | Tak — YouTube Pobierz na swoją pamięć; oddzielne pozwolenie i ceny oparte na GB | Oddzielny przepływ pracy modułu pobierania — Interfejsy API metadanych i transkrypcji YouTube nie dostarczają plików multimedialnych |

Obydwa oferują dostęp przedpłacony, MCP, CLI i umiejętności agenta. ScrapeCreators obejmuje także inne platformy społecznościowe i YouTube komentarze. Obsługiwane trafienia w pamięci podręcznej są bezpłatne.

### Odśwież filmy, na których Ci zależy

Niższe wskaźniki wykorzystania na żądanie mają znaczenie, gdy odświeżasz zmieniające się dane lub zbierasz napisy do nowych filmów. Przechowuj zapisane transkrypcje i żądaj metadanych tylko wtedy, gdy wymagają one aktualizacji.

### Zacznij od mniejszego zakupu

Doładowania kredytu o wartości FlashData rozpoczynają się o godzinie $10. Najpierw przenieś jedno obciążenie YouTube, podczas gdy istniejąca integracja będzie nadal obsługiwać komentarze i inne platformy społecznościowe.

### Wybierz dokładną ścieżkę napisów

Wybierz bezpośrednio napisy dostarczone przez przesyłającego lub wygenerowane przez YouTube. Zażądaj aż do 10 istniejących języków w jednym żądaniu transkrypcji i obsługuj wyniki dla każdego języka oddzielnie.

<a id="costs"></a>
## Porównaj nowe żądania, trafienia w pamięci podręcznej i zakupy z góry

| Oferta ScrapeCreators | Jednorazowy zakup | Kredyty | Za 1,000 świeżych połączeń o wartości jednego kredytu | Opłata miesięczna |
| --- | --- | --- | --- | --- |
| Pierwsza bezpłatna oferta | $0 | 100 raz | Bezpłatny dodatek na start | $0 |
| Freelance | $47.00 | 25,000 | $1.88 | $0 |
| Business | $497.00 | 500,000 | $0.994 | $0 |
| Przedsiębiorstwo | Niestandardowe | 1,000,000+ | Niestandardowe | $0 dla kredytów przedpłaconych |

Są to pakiety przedpłacone, bez miesięcznego odnawiania. Business to dokładnie $0.994 na 1,000 jednokredytowe połączenie; $0.99 jest zaokrąglone. Zakupione kredyty nie mają terminu ważności zgodnie z obecną polityką. Początkowe i zarobione punkty bonusowe są wyłączone z modelu.

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

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

### Przykład: metadane i napisy do 1,000 filmów

2,000 żądań, żadnych poszukiwań. FlashData płatność na bieżąco vs ScrapeCreators Freelance. Licz tylko zaobserwowane trafienia w pamięci podręcznej; żądania unikane za pośrednictwem własnego lokalnego magazynu nie są przesyłane do żadnego dostawcy.

| Darmowe trafienia w pamięci podręcznej | FlashData połączeń | FlashData użycia | FlashData zakupu | ScrapeCreators kredytów | ScrapeCreators wartość użytkowa | ScrapeCreators zakupu |
| --- | --- | --- | --- | --- | --- | --- |
| 0 | 2,000 | $1.00 | $10.00 | 2,000 | $3.76 | $47.00 |
| 1,000 | 2,000 | $1.00 | $10.00 | 1,000 | $1.88 | $47.00 |
| 2,000 | 2,000 | $1.00 | $10.00 | 0 | $0.00 | $0.00 |

USD, jeden miesiąc żądań. Jedno świeże wyszukiwanie metadanych, wynik napisów natywnych lub standardowe żądanie wyszukiwania zużywają jeden kredyt ScrapeCreators. Metadane i podpisy korzystają z dwóch żądań po obu stronach. Odejmowane są tylko wprowadzone powyżej trafienia w pamięci podręcznej metadanych/transcript; nie zakłada się buforowania wyszukiwania. Ten model uwzględnia zwrócone napisy, a nie próby braku ścieżki i wyklucza generowanie sztucznej inteligencji. FlashData korzysta ze swojego obecnego standardu YouTube Ceny danych, przydzielając cały wybrany limit planu przed dodatkowym wykorzystaniem. Rozszerzone wyszukiwanie i pobieranie są wyceniane osobno. Salda początkowe, okresy próbne, kredyty bonusowe, podatki i inne zastosowania są wyłączone. Zakupy rozpoczynają się od salda zerowego: doładowania FlashData mają minimum $10; ScrapeCreators zakupy zaokrąglamy w górę do całych wybranych pakietów. Niewykorzystane zakupione kredyty mogą posłużyć do późniejszych zadań. ScrapeCreators nie ma miesięcznego odnawiania pakietu; wybrany plan miesięczny FlashData nadal ma opłatę na poziomie zerowych żądań.

### Zachowanie pamięci podręcznej

Na obsługiwanych punktach końcowych metadanych /transcript cache_max_age akceptuje 1d, 3d, 7d, 14d lub 30d. Trafienia wymagają zerowych kredytów i zgłaszają cached_at; nie korzysta z normalnej stawki. Nie zakłada się trafień w pamięci podręcznej wyszukiwania. Zdecyduj, czy zapisane dane są wystarczająco aktualne, aby wykonać zadanie. [Zapisz i wykorzystaj wyniki ponownie](https://flashdata.dev/pl/docs/guides/save-results/reference.md).

### Oferty startowe

ScrapeCreators rozpoczyna się od darmowych kredytów 100. Kwalifikowalne sprawdzone rejestry FlashData mogą otrzymać początkowy dodatek do standardu 4,000 YouTube. Te oferty nie resetują miesięcznie. Poniżej znajduje się odrębny proces członków personelu tymczasowego.

<a id="migration"></a>
## Przenieś jeden film i jego sygnatury czasowe napisów

### 1. Skonfiguruj dostęp i wybierz ścieżkę

Utwórz lub użyj ponownie klucza z uprawnieniami youtube_transcript plus youtube_metadata dla opcjonalnego wywołania metadanych. [API kluczy](https://flashdata.dev/app/api-keys) · [Kredyty](https://flashdata.dev/app/billing). Zapisz FLASHDATA_API_KEY w środowisku lub użyj ukrytego monitu skryptu; nigdy nie wklejaj tego na czacie.

Istniejące żądanie, tylko dla mapowania:

```bash
# Existing call, for mapping only; reuse your saved key.
curl --get --fail-with-body --silent --show-error \
  'https://api.scrapecreators.com/v1/youtube/video/transcript' \
  --header "x-api-key: $SCRAPECREATORS_API_KEY" \
  --data-urlencode 'url=https://www.youtube.com/watch?v=FUfGcZ092b0' \
  --data-urlencode 'language=en'
```

FlashData POST https://data.flashdata.dev/v1/queries/realtime z X-API-Key i tym JSON ciałem:

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

original_audio=true wybiera język mówiony. FlashData params.auto=true wybiera napisy wygenerowane przez YouTube. Określ język i pochodzenie oddzielnie.

### 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 creator-research.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")
    transcript = []
    for cue in item["segments"]:
        if not isinstance(cue, dict):
            raise SystemExit("Invalid caption segment")
        start, end, text = cue.get("start"), cue.get("end"), cue.get("text")
        if (type(start) not in (int, float) or type(end) not in (int, float)
                or not math.isfinite(start) or not math.isfinite(end)
                or start < 0 or end < start or not isinstance(text, str)):
            raise SystemExit("Invalid caption segment")
        transcript.append({"text": text,
                           "startMs": str(math.floor(start * 1000 + 0.5)),
                           "endMs": str(math.floor(end * 1000 + 0.5)),
                           "startTimeText": f"{int(start) // 60}:{int(start) % 60:02d}"})
    normalized = {"videoId": item["videoId"],
                  "url": "https://www.youtube.com/watch?v=" + item["videoId"],
                  "transcript": transcript, "transcript_only_text": item.get("fullText"),
                  "language": item.get("languageName"), "languageCode": item["languageCode"],
                  "isAutoGenerated": item["isAutoGenerated"]}
else:
    duration = item.get("duration")
    if duration is not None and (type(duration) not in (int, float)
                                or not math.isfinite(duration) or duration < 0):
        raise SystemExit("Invalid video duration")
    normalized = {"id": item["videoId"], "title": item.get("title"),
                  "url": "https://www.youtube.com/watch?v=" + item["videoId"],
                  "description": item.get("description"),
                  "viewCountInt": item.get("viewCount"), "likeCountInt": item.get("likeCount"),
                  "commentCountInt": item.get("commentCount"),
                  "durationMs": None if duration is None else math.floor(duration * 1000 + 0.5),
                  "channel": {"id": item.get("channelId"), "title": item.get("channel")},
                  "uploadDateRaw": item.get("uploadDate")}
(out / "normalized.json").write_text(
    json.dumps(normalized, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
)
print(f"Saved {out}/normalized.json; actual usage: {json.dumps(data.get('usage'))}")

```

Uruchom z tego folderu, używając wideo z istniejącą ścieżką w języku angielskim. Metadane stanowią osobne, opcjonalne żądanie; w ramach tymczasowego okresu próbnego pozostaw co najmniej jedną sekundę pomiędzy połączeniami.

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

Do napisów dostarczonych przez przesyłającego dołącz instrukcję --origin. Domyślnie są to napisy w języku angielskim generowane przez YouTube.

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

```bash
#!/usr/bin/env bash
set -euo pipefail
operation="${1:?Use: transcript|metadata VIDEO_ID OUTPUT_FOLDER [LANGUAGE] [auto|manual]}"
video_id="${2:?Set VIDEO_ID}"
out="${3:?Set OUTPUT_FOLDER}"
language="${4:-en}"
origin="${5:-auto}"
[[ "$operation" == transcript || "$operation" == metadata ]] || exit 1
[[ "$video_id" =~ ^[A-Za-z0-9_-]{11}$ ]] || exit 1
[[ "$origin" == auto || "$origin" == manual ]] || exit 1
body=$(jq -n --arg source "youtube_$operation" --arg id "$video_id" \
  --arg language "$language" --arg origin "$origin" '
  {source: $source, video_id: $id, params:
    (if $source == "youtube_transcript" then {language: $language, auto: ($origin == "auto")}
     else {include_formats: false, include_chapters: true} end)}')
if [[ ! -e "$out" ]]; then
  if [[ -z "${FLASHDATA_API_KEY:-}" ]]; then
    read -r -s -p 'FlashData API key: ' FLASHDATA_API_KEY; printf '\n'
  fi
  : "${FLASHDATA_API_KEY:?An API key is required}"
  mkdir -p -- "$out"
  printf '%s\n' "$body" > "$out/request.json"
  curl --fail-with-body --silent --show-error --max-time 120 \
    --request POST 'https://data.flashdata.dev/v1/queries/realtime' \
    --header "X-API-Key: $FLASHDATA_API_KEY" \
    --header 'Content-Type: application/json' --header 'Accept: application/json' \
    --data-binary "@$out/request.json" --output "$out/response.json" \
    --dump-header "$out/response-headers.txt" --write-out '%{http_code}' \
    > "$out/http-status.txt" || {
      printf 'Request failed. Keep the output folder and inspect History before retrying.\n' >&2
      exit 1
    }
else
  printf 'Reading saved output; no API call.\n'
fi
jq -e --argjson expected "$body" '. == $expected' "$out/request.json" >/dev/null
[[ "$(cat "$out/http-status.txt")" == 200 ]] || {
  printf 'Inspect the saved HTTP status, response and Retry-After header.\n' >&2; exit 1;
}
normalized=$(jq -e --argjson request "$body" '
  if .source != $request.source or .status != "done" then error("Request not done") else . end
  | .results | if type != "array" then error("Expected results")
    elif length != 1 then error("Expected one result") else .[0] end
  | if .videoId != $request.video_id then error("Wrong video") else . end
  | if $request.source == "youtube_metadata" then
      if .duration == null then .
      elif (.duration | type) != "number" then error("Invalid video duration")
      elif (.duration | isfinite | not) or .duration < 0 then error("Invalid video duration") else . end
      | {id: .videoId, title, url: ("https://www.youtube.com/watch?v=" + .videoId), description,
         viewCountInt: .viewCount, likeCountInt: .likeCount, commentCountInt: .commentCount,
         durationMs: (if .duration == null then null else (.duration * 1000 | round) end),
         channel: {id: .channelId, title: .channel}, uploadDateRaw: .uploadDate}
    else
      if (.languageCode != $request.params.language and
          ($request.params.auto != true or ($request.params.language | endswith("-orig")) or
           .languageCode != ($request.params.language + "-orig"))) or
          .isAutoGenerated != $request.params.auto then error("Wrong language or origin") else . end
      | if (.segments | type) != "array" then error("Expected caption segments") else . end
      | {videoId, url: ("https://www.youtube.com/watch?v=" + .videoId),
         transcript_only_text: .fullText, language: .languageName, languageCode, isAutoGenerated,
         transcript: [.segments[] |
          if (.start | type) != "number" or (.end | type) != "number" or (.text | type) != "string"
          then error("Invalid caption segment")
          elif (.start | isfinite | not) or (.end | isfinite | not) or .start < 0 or .end < .start
          then error("Invalid caption timing")
          else {text, startMs: (.start * 1000 | round | tostring), endMs: (.end * 1000 | round | tostring),
            startTimeText: (((.start / 60 | floor) | tostring) + ":" +
              ((.start | floor) % 60 | if . < 10 then "0" + tostring else tostring end))} end]}
    end' "$out/response.json")
printf '%s\n' "$normalized" > "$out/normalized.json"
printf 'Saved %s/normalized.json; actual usage: ' "$out"
jq -c '.usage' "$out/response.json"

```

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

W przypadku napisów dostarczonych przez przesyłającego dołącz instrukcję. Każdy nowy folder wyjściowy przesyła jedno żądanie. Te same argumenty i folder ponownie wykorzystują zapisane dane wyjściowe; użyj nowego folderu do celowego odświeżenia po sprawdzeniu poprzedniej próby.

### 3. Przeczytaj zmapowane dane wyjściowe i rzeczywiste wykorzystanie

captions- 001/normalized.json jest adapterem polowym; response.json zachowuje pierwotną odpowiedź i rzeczywiste wykorzystanie. Sekundy stają się milisekundami strun. languageCode i isAutoGenerated zachowują wybrany utwór. Nie jest to kompletny drop- w odpowiedzi: brak wytworzonych sald kredytowych, flagi pamięci podręcznej, przypisywanie do pliku lub pola daty. Metadane zachowuje brakujące wskaźniki jako null oraz jego pierwotną datę uploadDateRaw.

```json
{
  "videoId": "FUfGcZ092b0",
  "url": "https://www.youtube.com/watch?v=FUfGcZ092b0",
  "transcript": [
    {
      "text": "Example caption text.",
      "startMs": "1250",
      "endMs": "3500",
      "startTimeText": "0:01"
    }
  ],
  "transcript_only_text": "Example caption text.",
  "language": "English",
  "languageCode": "en-orig",
  "isAutoGenerated": true
}
```

| Integracja ScrapeCreators | FlashData zmiany |
| --- | --- |
| GET /v1/youtube/video?url=… | POST zapytanie API ze źródłem: youtube_metadata i video_id. Przeczytaj wyniki[0], a nie katalog główny odpowiedzi. |
| GET /v1/youtube/video/transcript?url=… | Użyj źródła: youtube_transcript. Ustaw params.language i params.auto jawnie. |
| transkrypcja [].startMs / endMs | FlashData początek/koniec to sekundy. Pomnóż każdy przez 1,000 i serializuj jako ciągi znaków dla istniejącego czytnika milisekundowego. |
| original_audio=true | Wybiera język mówiony w ScrapeCreators, a nie w napisach generowanych automatycznie. Rozwiąż wymagany język w swojej aplikacji; params.auto zamiast tego wybiera pochodzenie podpisu. |
| język i transcript_only_text | Mapa languageName i fullText. Trzymaj languageCode oddzielnie; nazwa języka i kod języka to różne pola. |
| viewCountInt, likeCountInt, commentCountInt | Mapa viewCount, likeCount, commentCount. Zachowaj null, gdy nie ma metryki. |
| durationMs i publishDate | Konwertuj sekundy trwania na milisekundy. Zachowaj uploadDate jako nieprzetworzone pole, dopóki aplikacja nie sprawdzi wymaganego formatu daty. |
| kanał / przesyłający / ownerByline | Kanał FlashData i channelId nie odtwarzają wszystkich trzech tożsamości. Mapuj tylko pola, których potrzebuje Twój czytelnik; zachowaj osobną ścieżkę do przypisania autorstwa muzyki. |
| cached, cached_at, credits_charged | Zachowaj surową odpowiedź i użycie FlashData. Nagraj swój własny czas pobierania; nie twórz flag pamięci podręcznej dostawców ani nie tłumacz sald kredytowych pomiędzy dostawcami. |

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

### Jeśli pierwsze żądanie nie powiedzie się

- 401/403: sprawdź zapisany klucz i pozwolenie źródłowe; zatrzymaj się jeśli cofnięto.
- 402: uzupełnij saldo właściciela przed wznowieniem.
- 429: przeczytaj zapisany nagłówek Retry-After; zmniejszyć częstotliwość żądań. Tymczasowe wersje próbne pozwalają na jedno żądanie na sekundę.
- Brakujący utwór: sprawdź dostępny język i pochodzenie. ScrapeCreators może zwrócić pomyślną odpowiedź z transkrypcją null; nie myl tego ze ścieżką completed FlashData.
- Przekroczono limit czasu lub niekompletny folder: sprawdź historię i dane wyjściowe przed ponowną próbą. Skrypty zachowują próbę bez automatycznego ponownego przesyłania.

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

<a id="workflow"></a>
## Znajdź → krótka lista → wzbogacaj → cytuj

| Krok | Praca | Liczba żądań |
| --- | --- | --- |
| Odkryj | Uruchom żądania wyszukiwania P YouTube | P standardowe żądania wyszukiwania. Licz rzeczywiste żądania, a nie każdy zwrócony film jako osobne wyszukiwanie. |
| Wybierz | Deduplikuj i umieszczaj na krótkiej liście wideo N IDs | Filtrowanie lokalne; nie ma jeszcze prośby o metadane ani podpisy. |
| Wzbogać | Pobierz metadane dla krótkiej listy IDs | N żądań metadanych; powtarzaj tylko wtedy, gdy metryki wymagają odświeżenia. |
| Cytuj | Pobierz jedną istniejącą ścieżkę napisów na ID | N próśb o transkrypcję, jeśli są dostępne. Przechowuj język, pochodzenie i czasy sygnalizacji w źródle URL. |
| Użyj ponownie | Przeczytaj zapisane wyniki dla następnego zadania | Brak żądania dostawcy, gdy aplikacja może ponownie wykorzystać własny zapisany plik. |

10 żądań wyszukiwania oraz 50 filmów wideo z krótkiej listy z metadanymi i napisami wymaga 110 standardowych żądań przed ponownym wykorzystaniem lokalnym. Oddziel koszty odkrywania od wzbogacania. Wynik wyszukiwania sam w sobie nie jest oddzielnym żądaniem wyszukiwania.

### Wyszukiwanie nie jest migracją kursora typu drop-in

ScrapeCreators może zwrócić kilka typów wyników z continuationToken. Standardowe wyszukiwanie FlashData zwraca wyniki wideo; jego wyszukiwanie rozszerzone ma osobne limity i ceny. Rozpocznij nowy proces wykrywania zamiast ponownie używać starego kursora.

[YouTube Szukaj odniesienia](https://flashdata.dev/pl/docs/sources/youtube_search/reference.md)

### Zachowaj dowód wraz z odpowiedzią

Zapisz wideo ID, URL, wybrany język, pochodzenie napisów i czas rozpoczęcia segmentu. Link do cytatu może wskazywać na ten znacznik czasu. Nie oznaczaj brakującej ścieżki napisów jako pustej, pomyślnej transkrypcji.

[Przepis na napisy ze znacznikiem czasu](https://flashdata.dev/pl/docs/guides/timestamped-captions-recipe/reference.md)

### Scale listę ID oddzielnie

Gdy jedno wyszukiwanie zadziała, użyj żądań batch dla listy lub masowego przetwarzania pliku. Śledź zadanie IDs, zapisz wyniki completed i spróbuj ponownie tylko failed elementów. Niech Twój biegacz będzie odpowiedzialny za harmonogram.

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

<a id="agents"></a>
## Udowodnij migrację przed jej zaplanowaniem

Kwalifikujący się przedstawiciele mogą rozpocząć od: 1 credit (do 100 standard YouTube Wnioski o dane) 72 godzin. Metadane, podpisy i wyszukiwarki dzielą zasiłek.

1. Sprawdź wymagane pola, treść i aktualność napisów. Wykorzystaj ponownie zapisany dostęp; prowadź niepowiązane rozmowy w sieciach społecznościowych.
2. Uruchom jeden znany film, używając CLI, SDK lub MCP. Zapisz dane wyjściowe i sprawdź czas, wartości null i rzeczywiste wykorzystanie.
3. Właściciel loguje się lub rejestruje, weryfikuje adres e-mail i zatwierdza roszczenia, zakresy i wykorzystanie salda współdzielonego. Niewykorzystane kredyty próbne nie są przenoszone.
4. Zachowaj dane uwierzytelniające właściciela do ponownego użycia. Wykorzystaj ponownie wyjścia i zatrzymaj je w przypadku odwołania lub niewystarczającego salda.

```text
Migrate only this app's YouTube metadata and native-caption calls to FlashData.
Read https://flashdata.dev/auth.md and https://flashdata.dev/agents.md first.
Reuse saved access; start an eligible trial only if needed. Keep credentials out of chat.
Inspect our current fields, language choice, original_audio behavior and cache freshness requirements.
Keep comments, other social platforms and unsupported fields on their existing path.
Run one known video with explicit language and caption origin. Save the raw response and usage.
Map timestamps from seconds to string milliseconds; preserve null counts and missing-track errors.
Reuse saved output before requesting it again. Do not retry an uncertain submission automatically.
Before recurring use, ask the owner to claim access and approve permissions and shared-balance use.
Persist the resulting credential and stop on revocation or insufficient balance.
```

[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) · [Konfiguracja MCP](https://flashdata.dev/pl/docs/integrations/mcp-clients/reference.md)

<a id="faq"></a>
## Zanim się przełączysz

### Czy to są miesięczne subskrypcje?

ScrapeCreators Freelance i Business to pakiety przedpłacone, a nie subskrypcje. Obydwa mają miesięczną opłatę w wysokości $0. FlashData oferuje kredyty typu pay-as-you-go oraz opcjonalne plany miesięczne. Porównaj oddzielnie zużycie i wymagany zakup z bieżącego salda.

### Co się stanie, jeśli większość moich ScrapeCreators żądań będzie przechowywana w pamięci podręcznej?

Obsługiwane trafienia w pamięci podręcznej metadanych i transkrypcji kosztują zero kredytów. Wprowadź zaobserwowane trafienia do kalkulatora. Jeśli Twoja aplikacja zaakceptuje ich wiek, mogą kosztować mniej niż nowe FlashData żądań. Możesz także zapisać lokalnie dane wyjściowe dowolnego dostawcy i całkowicie uniknąć tworzenia kolejnego żądania.

### Czy niewykorzystane środki tracą ważność?

ScrapeCreators twierdzi, że zakupione kredyty nie wygasają zgodnie z obecną polityką. Oferta początkowa bezpłatnego kredytu w wysokości 100 nie obejmuje comiesięcznego doładowania. Okres próbny agenta tymczasowego FlashData wygasa; na stronach z cenami i kontami opisano obowiązujące warunki dotyczące salda właściciela.

### Czy original_audio=true będzie działać jako params.auto=true?

Nie. Pierwszy wybiera język na podstawie mówionego dźwięku; drugi wybiera napisy wygenerowane przez YouTube. Celowo ustaw język i pochodzenie. Punkt końcowy napisów natywnych w żadnej z usług nie tworzy zamiany mowy na tekst, jeśli nie ma pasującej ścieżki.

### Czy mogę zastąpić wszystkie moje połączenia danych w mediach społecznościowych?

Ta migracja obejmuje YouTube metadanych wideo i istniejących napisów. Zachowaj komentarze, posty społeczności, profile społecznościowe i inne nieobsługiwane pola odpowiedzi na ich istniejącej ścieżce. FlashData oferuje również Google wyszukiwanie i hostowane YouTube pobieranie, z własnymi uprawnieniami i cenami.

### Czy ScrapeCreators obsługuje także agentów AI?

Tak. Oferuje MCP, OAuth, CLI i umiejętności agenta. Przepływ agenta FlashData dodaje kwalifikującą się tymczasową wersję próbną, żądanie właściciela i zapisane dane uwierzytelniające do dalszego użytku. Wybierz API i przepływ pracy, jakiego potrzebuje Twoje zadanie; Samo wsparcie MCP nie stanowi różnicy.
