# Oxylabs Alternatywa dla YouTube Dane | FlashData

Porównaj FlashData i Oxylabs dla YouTube metadanych i podpisów: jednostki rozliczeniowe, koszty subskrypcji, dostęp agenta i Python/Bash migracja z wersji klasycznej lub internetowej API.

Badania wideo bez miesięcznego zobowiązania. Przenieś metadane i zadania z podpisami do FlashData PAYG, zachowując język, pochodzenie i znaczniki czasu.

Ta strona obejmuje YouTube danych. [Oxylabs Alternatywa SERP](https://flashdata.dev/pl/compare/oxylabs/reference.md) obejmuje Google Szukaj osobno.

Oxylabs zweryfikowane fakty 2026-11-10; Ceny i uprawnienia FlashData korzystają z bieżących publicznych katalogów.

- [Funkcje](#features)
- [Ceny](#pricing)
- [Migracja](#migration)
- [Production i agenci](#production)
- [Pytania](#faq)

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

### Flexible wydatków na badania wideo

| Funkcja | FlashData | Oxylabs YouTube |
| --- | --- | --- |
| Płatne korzystanie bez miesięcznego abonamentu | Tak — PAYG; doładowania kredytu zaczynają się od $10 | Nie — Obecna płatna samoobsługa wymaga aktywnej subskrypcji |
| Wyszukiwanie tylko metadanych · 1,000 filmów | $0.50 — 1,000 standardowe żądania źródła · PAYG | Potwierdź szybkość punktu końcowego — Cena API publicznych danych wideo jest ceną za GB, a nie wyceną żądania metadanych |
| Wyszukiwanie tylko z napisami · 1,000 filmów | $0.50 — Jeden wybrany istniejący utwór na film · PAYG | Dedykowany punkt końcowy napisów — Potwierdź jednostkę rozliczeniową na swoim koncie |
| Wspólne wyszukiwanie Google i saldo YouTube | Tak | Tak — Wspólne saldo kredytu produktowego |

### Znajdź filmy i odśwież ich metadane

| Funkcja | FlashData | Oxylabs YouTube |
| --- | --- | --- |
| Odkrywanie słów kluczowych i sugestie wyszukiwania | Tak — Źródła wyszukiwania, wyszukiwania rozszerzonego i sugestii | Tak — YouTube wyszukiwanie, wyszukiwanie/max i autouzupełnianie punktów końcowych |
| Metadane znanego filmu ID | Tak — Tytuł, kanał, czas trwania, miniatury i liczba interakcji | Tak — Dedykowany punkt końcowy metadanych akceptuje wideo ID |
| Rozdziały i dostępne języki napisów | Tak — Opcjonalne rozdziały plus transcriptLanguages | Tak — Znaczniki rozdziałów i języki napisów w metadanych |

### Kontroluj, które podpisy docierają do Twojej aplikacji

| Funkcja | FlashData | Oxylabs YouTube |
| --- | --- | --- |
| Pobieraj podpisy niezależnie od metadanych | Tak — Dedykowane źródła transkrypcji i napisów | Tak — Dedykowany punkt końcowy napisów YouTube |
| Wybierz język napisów i pochodzenie | Tak — Jawny język i automatyczny wybór | Tak — language_code i subtitle_origin |
| Kilka języków w jednym żądaniu | Do 10 wybranych języków — Jawna tablica języka zwraca ścieżki i błędy | Jeden wybrany język lub wszystkie — Pomiń language_code dla wszystkich języków; pomiń subtitle_origin dla obu źródeł |
| Tekst i czas cytowań źródłowych | Znormalizowane segmenty + fullText — JSON start/end razy w sekundach | YouTube ładunków ścieżek napisów — Tekst i czasy pogrupowane według języka i pochodzenia |
| Niedostępne żądane utwory | Błędy dla poszczególnych języków w żądaniach tablicowych — Zachowaj udane ścieżki; sprawdzaj błędy, nawet jeśli status to done | Pusty wynik dla brakującej ścieżki — Prawidłowy kod języka bez dopasowania zwraca {} |
| Przygotuj dane do aplikacji lub LLM | JSON, zwykły tekst lub Markdown — Wybierz odpowiedź i format treści API | Śledź dane lub niestandardową ekstrakcję JSON — Wyodrębnianie napisów akceptuje monit lub schemat |

### Przetwarzaj listy i zapewniaj możliwość ponownego wykorzystania dostępu agentów

| Funkcja | FlashData | Oxylabs YouTube |
| --- | --- | --- |
| Tryby interaktywne, async i batch | Tak — Ten sam kształt żądania źródłowego w różnych trybach wykonania | Tak — Internetowa synchronizacja metadanych i napisów API, async i batch |
| Prześlij przygotowaną listę filmów | ID plik w Bulk Jobs — Konsola lub API; monitoruj postęp i pobieraj części wyników | Tablica ID w partii API — Wspólne parametry dotyczą każdego zadania w batch |
| Zapisz dużą kolekcję w swoim magazynie | Manifesty zbiorcze i części wyników — Zarządzana pamięć masowa lub pamięć masowa przeznaczona dla klientów | Asynchroniczne dostarczanie magazynu — Pamięć kompatybilna z S3, S3, GCS i TOS |
| Wersja próbna agenta przed konfiguracją konta właściciela | Tak — Kwalifikujący się agenci: do 100 standardowych żądań, następnie roszczenia właściciela | Najpierw zarejestruj konto — $5 jednorazowy kredyt powitalny na drużynę |
| Samodzielny CLI bez Node.js lub Python | Tak — Linux, macOS i Windows | HTTP API, MCP i umiejętności — Żaden odpowiednik samodzielnego pliku binarnego nie został zweryfikowany w przeglądanych dokumentach instalacyjnych |
| MCP i umiejętności dla hosta-agenta | Tak — Ponownie użyj zatwierdzonego dostępu właściciela do bieżących zadań | Tak — Umiejętności serwera i agenta Web API MCP |

### Utrzymuj okazjonalne badania w przystępnej cenie

FlashData płatność na bieżąco nie obejmuje opłat miesięcznych. Pobierz filmy potrzebne do wykonania zadania i zachowaj równowagę dla Google wyszukiwania i YouTube.

### Budżet w żądaniach źródłowych

Licz oddzielnie pobieranie metadanych i podpisów. Odświeżenie metadanych nie wymaga kolejnego żądania napisów; zapisana ścieżka napisów może służyć późniejszej analizie.

### Zachowaj dowody, a nie tylko streszczenie

Zapisz tekst podpisu z jego językiem, pochodzeniem i znacznikami czasu. Przykłady migracji tworzą linki źródłowe dla każdego segmentu i zachowują surową odpowiedź i użycie.

<a id="pricing"></a>
## Porównaj plany i jednostki rozliczeniowe

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

FlashData zlicza jedno wyszukiwanie metadanych i jedno wyszukiwanie napisów jako dwa żądania na film. Uwzględnione zliczenia przydzielają pełne saldo współdzielone do standardowych danych YouTube; Rozszerzone wyszukiwanie i pobieranie korzystają z odrębnych stawek. Doładowania PAYG rozpoczynają się od $10. [Pełny cennik](https://flashdata.dev/pl/pricing/youtube-data).

| planu Oxylabs | Opłata miesięczna | Zawiera wspólne saldo | Opublikowane dane wideo API szybkość | Uwzględniono żądania metadanych/caption |
| --- | --- | --- | --- | --- |
| Starter | $15.00 | $15.00 | $2.00/GB | Nie opublikowano ustalonej liczby |
| Basic | $100.00 | $100.00 | $2.00/GB | Nie opublikowano ustalonej liczby |
| Flexible | $500.00 | $500.00 | $1.60/GB | Nie opublikowano ustalonej liczby |

Przedsiębiorstwo zaczyna się od $2,500/miesiąc na dostosowanych warunkach. USD; z wyłączeniem podatków, innych zastosowań produktów i umów niestandardowych.

Oxylabs wyświetla dane wideo API w GB. Jego tabela publiczna nie ustala ceny za żądanie dla punktów końcowych metadanych i napisów. Użyj jednostki rozliczeniowej i stawki swojego konta dla tych połączeń; ogólna cena Scrape „od” nie jest kwotą YouTube. Limitu GB nie można zamienić na stałą liczbę filmów.

Oxylabs płatna samoobsługa korzysta z aktywnego abonamentu i współdzielonego miesięcznego salda kredytowego. Niewykorzystane saldo wygasa w momencie odnowienia; usługa wstrzymuje się od zera do czasu doładowania lub aktualizacji. Kredyt powitalny $5 to jednorazowy dodatek zespołowy, a nie kwota miesięczna. Istniejące umowy klasyczne lub niestandardowe mogą mieć inne warunki.

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

<a id="migration"></a>
## Przeprowadź migrację istniejącej ścieżki napisów

### 1. Zidentyfikuj istniejące żądanie

Są to prośby o referencje dotyczące tego samego utworu wygenerowanego w języku angielskim, wygenerowanego przez YouTube. Obydwa używają wideo ID, a nie URL. Klasyczny wykorzystuje wpisy kontekstowe; Sieć API korzysta z opcji najwyższego poziomu.

```bash
# Existing Classic request; use your current credential environment.
curl --fail-with-body --silent --show-error \
  --user "$OXYLABS_USERNAME:$OXYLABS_PASSWORD" \
  --header 'Content-Type: application/json' \
  --data '{
    "source": "youtube_subtitles",
    "query": "FUfGcZ092b0",
    "context": [
      {"key": "language_code", "value": "en"},
      {"key": "subtitle_origin", "value": "auto_generated"}
    ]
  }' \
  'https://realtime.oxylabs.io/v1/queries'
```

```bash
# Newer Web API request; query is a video ID, not a URL.
curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $OXYLABS_API_KEY" \
  --header 'Content-Type: application/json' \
  --data '{
    "query": "FUfGcZ092b0",
    "language_code": "en",
    "subtitle_origin": "auto_generated"
  }' \
  'https://webapi.oxylabs.io/v1/scrape/media/youtube/subtitles'
```

### 2. Skonfiguruj FlashData i zapisz pliki

Utwórz lub użyj ponownie klucza z uprawnieniami youtube_captions. [API kluczy](https://flashdata.dev/app/api-keys) · [Dostępne kredyty](https://flashdata.dev/app/billing). Przeczytaj FLASHDATA_API_KEY z tajnego magazynu lub skorzystaj z ukrytego podpowiedzi skryptu. Trzymaj dane uwierzytelniające poza czatem i kontrolą źródła.

Utwórz youtube-migration/ i zapisz to jako youtube-migration/request.json:

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

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-migration/captions.py, zanim go uruchomisz.

```python
import argparse
import getpass
import json
import math
import os
import re
from datetime import datetime, timezone
from pathlib import Path

import requests

parser = argparse.ArgumentParser()
parser.add_argument("folder", help="New output folder, or an existing saved caption request")
out = Path(parser.parse_args().folder)

if not out.exists():
    body = Path("request.json").read_bytes()
    request = json.loads(body)
    if (not isinstance(request, dict) or request.get("source") != "youtube_captions"
            or not isinstance(request.get("video_id"), str)
            or not re.fullmatch(r"[A-Za-z0-9_-]{11}", request["video_id"])):
        raise SystemExit("Use youtube_captions and an 11-character video_id")
    options = request.get("params")
    if (not isinstance(options, dict) or not isinstance(options.get("language"), str)
            or not re.fullmatch(r"[A-Za-z0-9-]{1,35}", options["language"])
            or type(options.get("auto")) is not bool):
        raise SystemExit("Set one language code and auto: true or false explicitly")
    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()
    (out / "request.json").write_bytes(body)
    (out / "requested-at.txt").write_text(
        datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"), encoding="utf-8"
    )
    try:
        response = requests.post(
            "https://data.flashdata.dev/v1/queries/realtime",
            headers={"X-API-Key": key, "Content-Type": "application/json",
                     "Accept": "application/json"},
            data=body, timeout=120, allow_redirects=False,
        )
    except requests.RequestException:
        raise SystemExit(f"Request interrupted. Keep {out} and check History before retrying.")
    (out / "result.json").write_bytes(response.content)
    (out / "response-headers.txt").write_text(
        "\n".join(f"{k}: {v}" for k, v in response.headers.items()), encoding="utf-8"
    )
    (out / "http-status.txt").write_text(str(response.status_code), encoding="utf-8")
else:
    print(f"Reading saved response from {out}; no API call.")

if not (out / "http-status.txt").exists():
    raise SystemExit("Incomplete attempt. Keep the folder and check History before retrying.")
status = (out / "http-status.txt").read_text().strip()
if status != "200":
    raise SystemExit(f"HTTP {status}: inspect {out}/result.json and response-headers.txt")
try:
    data = json.loads((out / "result.json").read_bytes())
except ValueError:
    raise SystemExit("Invalid JSON; inspect the saved result.json")
request = json.loads((out / "request.json").read_bytes())
if not isinstance(data, dict) or data.get("source") != "youtube_captions" or data.get("status") != "done":
    raise SystemExit("Caption request did not finish successfully; inspect result.json")
tracks = data.get("results")
if not isinstance(tracks, list) or len(tracks) != 1 or not isinstance(tracks[0], dict):
    raise SystemExit("Expected one caption track; inspect result.json")
track = tracks[0]
language = request["params"]["language"]
allowed_languages = [language]
if request["params"]["auto"] and not language.endswith("-orig"):
    allowed_languages.append(language + "-orig")
if (track.get("videoId") != request["video_id"]
        or track.get("languageCode") not in allowed_languages
        or track.get("requestedLanguageCode", track.get("languageCode")) != language
        or track.get("isAutoGenerated") is not request["params"]["auto"]):
    raise SystemExit("Returned video, language or caption origin does not match the request")
if not isinstance(track.get("segments"), list):
    raise SystemExit("Expected a segments array; inspect result.json")
segments = []
for cue in track["segments"]:
    if not isinstance(cue, dict):
        raise SystemExit("Expected caption segment objects")
    start, end, text = cue.get("start"), cue.get("end"), cue.get("text")
    if (type(start) not in (int, float) or not math.isfinite(start) or start < 0
            or type(end) not in (int, float) or not math.isfinite(end) or end < start
            or not isinstance(text, str)):
        raise SystemExit("Invalid caption timing or text; inspect result.json")
    segments.append({**cue, "url": f"https://www.youtube.com/watch?v={track['videoId']}&t={math.floor(start)}s"})
captions = {**track, "segments": segments}
record = {"request": request, "requested_at": (out / "requested-at.txt").read_text().strip(),
          "usage": data.get("usage"), "segment_count": len(segments), "result_file": "result.json"}
for filename, value in (("captions.json", captions), ("record.json", record)):
    (out / filename).write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
print(f"Saved {len(segments)} segments to {out}/captions.json")
if not any(cue["text"].strip() for cue in segments):
    print("No caption text to cite. Keep the empty track and report the gap.")

```

Z poziomu youtube-migration/ uruchom:

```bash
python captions.py track-001
python -m json.tool track-001/captions.json
python -m json.tool track-001/record.json
```

Alternatywnie użyj Bash, cURL 7.76+ i jq 1.6+. Zapisz cały skrypt jako youtube-migration/captions.sh:

```bash
#!/usr/bin/env bash
set -euo pipefail
out="${1:?Usage: bash captions.sh OUTPUT_FOLDER}"

if [[ ! -e "$out" ]]; then
  jq -e '.source == "youtube_captions" and
    (.video_id | if type == "string" then length == 11 and test("^[A-Za-z0-9_-]{11}$") else false end) and
    (.params.language | if type == "string" then length > 0 and length <= 35 and
      (test("[^A-Za-z0-9-]") | not) else false end) and
    (.params.auto | type == "boolean")' request.json > /dev/null
  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 -- "$out"
  cp request.json "$out/request.json"
  date -u +'%Y-%m-%dT%H:%M:%SZ' > "$out/requested-at.txt"
  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" \
    --dump-header "$out/response-headers.txt" --output "$out/result.json" \
    --write-out '%{http_code}' > "$out/http-status.txt" || {
      printf 'Request failed. Keep %s and inspect its saved files before retrying.\n' "$out" >&2
      exit 1
    }
else
  printf 'Reading saved response from %s; no API call.\n' "$out"
fi

if [[ ! -f "$out/http-status.txt" ]] || [[ "$(cat "$out/http-status.txt")" != 200 ]]; then
  printf 'Incomplete or failed attempt. Inspect the saved files and History before retrying.\n' >&2
  exit 1
fi
captions=$(jq -e --slurpfile request "$out/request.json" '
  if .source != "youtube_captions" or .status != "done"
  then error("Expected a successful youtube_captions response") else . end
  | .results
  | if type != "array" then error("Expected a results array")
    elif length != 1 then error("Expected exactly one track") else .[0] end
  | $request[0].params.language as $language
  | if type != "object" then error("Expected a caption object")
    elif .videoId != $request[0].video_id or (.requestedLanguageCode // .languageCode) != $language
      or (.languageCode != $language and ($request[0].params.auto != true
        or ($language | endswith("-orig")) or .languageCode != ($language + "-orig")))
      or .isAutoGenerated != $request[0].params.auto
    then error("Returned video, language or caption origin does not match the request") else . end
  | if (.segments | type) != "array" then error("Expected a segments array") else . end
  | .videoId as $id
  | .segments |= map(
      if type != "object" then error("Expected caption segment objects") else . end
      | if (.start | type) != "number" or (.end | type) != "number" or (.text | type) != "string"
        then error("Invalid caption timing or text")
        elif (.start | isfinite | not) or (.end | isfinite | not) or .start < 0 or .end < .start
        then error("Invalid caption timing")
        else . + {url: ("https://www.youtube.com/watch?v=" + $id + "&t=" + (.start | floor | tostring) + "s")} end
    )' "$out/result.json")
printf '%s\n' "$captions" > "$out/captions.json"
jq --slurpfile request "$out/request.json" --slurpfile captions "$out/captions.json" \
  --arg requested_at "$(tr -d '\r\n' < "$out/requested-at.txt")" \
  '{request: $request[0], requested_at: $requested_at, usage,
    segment_count: ($captions[0].segments | length), result_file: "result.json"}' \
  "$out/result.json" > "$out/record.json"
printf 'Saved %s segments to %s/captions.json\n' "$(jq '.segments | length' "$out/captions.json")" "$out"
if ! jq -e 'any(.segments[]; .text | test("\\S"))' "$out/captions.json" > /dev/null; then
  printf 'No caption text to cite. Keep the empty track and report the gap.\n'
fi

```

Z poziomu youtube-migration/ uruchom:

```bash
bash captions.sh track-001
jq . track-001/captions.json
jq . track-001/record.json
```

Nowy folder przesyła jedno żądanie. Powtórz to samo polecenie, aby odczytać zapisaną odpowiedź bez wywołania API. Każdy folder jest właścicielem swojego żądania; zmiana request.json nie zmienia istniejącego przebiegu. Rozwiąż niekompletne próby przed utworzeniem kolejnego folderu.

### 3. Sprawdź utwór, zanim go zacytujesz

Ślady...001/captions.json zawiera sprawdzone segmenty z linkami źródłowymi; record.json zachowuje wniosek, czas i wykorzystanie; result.json jest surową reakcją. Skrypt weryfikuje wideo, język i pochodzenie, akceptuje pasujący wariant auto- caption -orig i zachowuje nakładające się na siebie segmenty. Segment to sekunda. Brakujące lub puste podpisy są luką danych, a nie generowanym transkryptem.

Przykładowy fragment captions.json:

```json
{
  "videoId": "FUfGcZ092b0",
  "languageCode": "en",
  "isAutoGenerated": true,
  "segments": [
    {
      "start": 12.5,
      "end": 16.2,
      "text": "Illustrative caption text; the actual track varies.",
      "url": "https://www.youtube.com/watch?v=FUfGcZ092b0&t=12s"
    }
  ]
}
```

| Troska | Istniejąca integracja Oxylabs | FlashData zmiany |
| --- | --- | --- |
| Uwierzytelnianie | Klasyczny: HTTP Basic nazwa użytkownika/password. Sieć API: Klucz nośnika API. | X-API-Key: FLASHDATA_API_KEY. Istniejące dane uwierzytelniające Oxylabs nie są przenoszone. |
| Metadane | Klasyczny youtube_metadata; Zapytanie internetowe API /media/youtube/metadata. to wideo ID. | źródło: youtube_metadata, video_id: ten sam znak 11 ID. |
| Napisy | Klasyczny youtube_subtitles; Sieć API /media/youtube/subtitles. | źródło: youtube_captions tekstu i czasu; youtube_transcript, gdy twój parser również potrzebuje fullText. |
| Język i pochodzenie | Klasyczne wpisy kontekstowe; Sieć API language_code i subtitle_origin. Pominięcie ich może spowodować zwrócenie wielu utworów. | Ustaw jawnie params.language i params.auto. auto: true = YouTube-wygenerowane; false = dostarczone przez przesyłającego. Nigdy po cichu nie zastępuj utworu. |
| Analizator odpowiedzi | Klasyczny i Web API mają różne obwiednie wyników i pogrupowane napisy. | Sprawdź status: done, następnie wyniki[].videoId, languageCode, isAutoGenerated i segmenty. Początek segmentu/end to sekundy. |
| Asynchronicznie IDs | Web API metadata.request_id; Klasyczne zadanie IDs używa własnych punktów końcowych wyników. | Zapisz potwierdzenie przesłania FlashData i użyj punktów końcowych zadania zarządzania. Zachowaj dostawcę IDs oddzielnie; nie używaj ponownie odpytywania Oxylabs URL. |

### Opcjonalne zadanie metadanych

Przyznaj uprawnienia youtube_metadata. POST tego ciała do https://data.flashdata.dev/v1/queries/realtime z X-API-Key. Jest to oddzielny standardowy wniosek. Sprawdź status: done przed odczytaniem wyników[0].

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

[Pola napisów](https://flashdata.dev/pl/docs/sources/youtube_captions/reference.md) · [Pola metadanych](https://flashdata.dev/pl/docs/sources/youtube_metadata/reference.md).

<a id="production"></a>
## Zadania powtarzające się i odzyskiwanie

Zbierz raz, analizuj wiele razy. Wykorzystuj ponownie zapisaną ścieżkę do podsumowań i osadzania; odświeżaj dane źródłowe tylko wtedy, gdy zadanie tego potrzebuje.

| Sytuacja | Co robić |
| --- | --- |
| Wybrany utwór jest nieobecny | Oxylabs może zwrócić pusty obiekt dla prawidłowego języka bez pasujących napisów. Traktuj brakujący lub pusty tekst podpisu jako lukę w danych; nie twórz transkrypcji. |
| Częściowo akceptowane jest duże batch | Oxylabs Sieć API dokumentuje do 5,000 stanowisk pracy na batch i osobne zaakceptowane wpisy/rejected. Zachowaj zaakceptowany IDs. Dla FlashData podziel się na maxBatchSize konta i zachowaj każde zwrócone zadanie ID. |
| Upłynął limit czasu połączenia realtime | Zachowaj folder żądań i sprawdź historię przed ponownym przesłaniem. W przypadku długich kolejek wynoszących running użyj zgłoszenia async, natychmiast zapisz jego potwierdzenie i odpytuj istniejące zadanie. |
| Zmiany konta lub danych uwierzytelniających | Przechowuj klucze API w tajnym magazynie hosta. Zatrzymaj się na 401/403; rozwiązać saldo na 402; honoruj ​​Retry-After na 429. Nie rozpoczynaj nowych prób, aby ominąć wyczerpaną równowagę. |

| 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ę. W przypadku zestawów danych o rozmiarze pliku użyj przetwarzania zbiorczego. [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) · [Zbiorcze punkty końcowe](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md) · [Błędy](https://flashdata.dev/pl/docs/errors/reference.md).

Kwalifikujący się agenci mogą rozpocząć od kredytu 1 (do standardowych żądań 100) dla godzin 72.

Najpierw ponownie wykorzystaj istniejący dostęp. W przypadku powtarzalnego użytku właściciel przejmuje połączenie i zatwierdza uprawnienia oraz dostęp do salda współdzielonego. Niewykorzystane środki tymczasowe nie podlegają przeniesieniu. Zachowaj dane uwierzytelniające pomiędzy uruchomieniami i zatrzymuj je w przypadku unieważnienia lub wyczerpania salda.

```text
Migrate one Oxylabs YouTube subtitle task to FlashData.
Read https://flashdata.dev/auth.md and reuse existing access first.
Use youtube_captions with the same video ID, language and caption origin.
Keep the source request, raw response, usage and timestamped segments.
Check the video, language and origin; report an absent track instead of inventing text.
Save the script before running it, and reuse a completed output folder.
For recurring work, finish owner claiming and store its credential securely.
Stop on revoked access or depleted balance. Never paste credentials into chat.
```

[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 FlashData jest zamiennikiem typu drop-in?

Nie. Zmień uwierzytelnianie, pola żądań, analizę odpowiedzi i pobieranie zadań. Przykłady adaptują jedno zadanie napisów do stabilnego rekordu aplikacji; nie imitują koperty odpowiedzi Oxylabs.

### Czy mogę zachować integrację z Classic Oxylabs podczas migracji?

Tak. Przenoś jedno zadanie na raz, zachowaj zapisane wyniki klasyczne i przechowuj dane uwierzytelniające oraz zadanie IDs oddzielnie według dostawcy. Mapowanie obejmuje zarówno żądania klasycznego źródła/context, jak i nowsze żądania punktu końcowego sieci Web API.

### Czy FlashData generuje transkrypcję, gdy brakuje napisów?

Źródła te pobierają istniejące YouTube napisów. auto: true wybiera napisy wygenerowane przez YouTube; nie wymaga świeżej zamiany mowy na tekst. Zgłoś brakujące utwory lub zajmij się transkrypcją w ramach osobnego procesu.

### A co z pobraniem samego filmu?

YouTube Download to oddzielny produkt FlashData z własnym zezwoleniem i ceną opartą na bajtach. To porównanie i przykłady obejmują metadane i podpisy; nie pobierają plików wideo ani audio.

### Co powinno pozostać w moim istniejącym przepływie pracy Oxylabs?

Zachowaj infrastrukturę proxy, inne platformy społecznościowe i wszelkie niestandardowe umowy dotyczące ekstrakcji, wywołania zwrotnego lub dostawy magazynu, których nadal wymaga Twoja aplikacja. Obaj dostawcy wspierają async pracę, batch kolekcję, MCP i umiejętności; Same te możliwości nie są powodem do migracji.

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