# API przetwarzania Bulk

Tworzenie i kontrola zadań opartych na plikach YouTube, a następnie pobieranie ich manifestów i części wyników.

Odniesienie kanoniczne: https://flashdata.dev/pl/docs/reference/bulk-processing
Przegląd: 2026-11-05 przez FlashData

<a id="playground"></a>

## Plac testowy API

Wybierz źródło i skopiuj kompletny strumień pracy Python lub Bash, pojedyncze żądanie lub odpowiedź próbki. Plac zabaw przedstawia kod; nie przedstawia pracy. Kompletne przepływy pracy obsługują wysyłanie, sprawdzanie stanu i pobieranie każdej części wyników.

- [Uwierzytelnianie i wymagania dotyczące plików](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#prepare)
- [Przeglądaj punkty końcowe](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#endpoints)
- [Batch czy Bulk?](https://flashdata.dev/pl/docs/reference/batch-and-bulk/reference.md)

<a id="endpoints"></a>

## Punkty końcowe

Wszystkie punkty końcowe stosowania https://api.flashdata.dev/v2. Utwórz zadanie → wysyłaj plik wideo-ID → start → monitor → pobrać manifest i każdą część wyniku.

| Metoda | Ścieżka | Działanie |
| --- | --- | --- |
| POST | /v2/bulk-jobs | Utwórz zadanie Bulk |
| POST | /v2/bulk-jobs/{bulkId}/start | Wyślij i uruchom |
| GET | /v2/bulk-jobs/{bulkId} | Uzyskaj status pracy |
| GET | /v2/bulk-jobs | Lista miejsc pracy |
| POST | /v2/bulk-jobs/{bulkId}/pause | Wstrzymać pracę |
| PATCH | /v2/bulk-jobs/{bulkId} | Aktualizacja opcji pracy |
| POST | /v2/bulk-jobs/{bulkId}/resume | Wznowienie pracy |
| DELETE | /v2/bulk-jobs/{bulkId} | Anuluj pracę |
| GET | /v2/bulk-jobs/{bulkId}/results | Uzyskaj manifest wyników |
| GET | /v2/bulk-jobs/{bulkId}/results/{partNumber} | Pobieranie części wyników |

- [Batch czy Bulk?](https://flashdata.dev/pl/docs/reference/batch-and-bulk/reference.md)
- [Przewodnik po Bulk](https://flashdata.dev/pl/docs/guides/bulk/reference.md)
- [Specyfikacja OpenAPI](https://flashdata.dev/docs/openapi.json)

<a id="prepare"></a>

## Uwierzytelnianie i wprowadzanie

Ustaw FLASHDATA_API_KEY na klucz z dostępem do wybranego źródła. Ponowne wykorzystanie tego samego klucza i rozliczenie tworzenia, kontroli i wyników. Przetwarzanie wykorzystuje saldo konta i normalne ceny per-source. YouTube Download wymaga dostępu właściciela i options.storage.

Utwórz folder roboczy o nazwie bulk- api / i uruchom z niego te przykłady. Kompletny obieg pracy Python wykorzystuje standardową bibliotekę Python 3.10 +; poszczególne przykłady punktów końcowych Python poniżej wymagają zapytania; przykłady cURL wykorzystują Bash, cURL 7.76 +, jq i gzip. Wybierz jeden język dla każdej akcji, aby nie tworzyć lub rozpocząć duplikat pracy.

Input to plik UTF-8 z jednym znakiem 11- YouTube ID na linię, do 2 GiB. Należy stosować IDs, a nie URLs. Przed wysłaniem należy usunąć duplikat IDs; powtarzalne IDs są przetwarzane oddzielnie.

| Źródło | Wspólne opcje |
| --- | --- |
| youtube_metadata | include_formats, include_chapters |
| youtube_transcript | language, auto |
| youtube_captions | language, auto |
| youtube_trainability | Brak opcji |
| youtube_download | Opcje medialne i cel przechowywania |

### Zależność Python

```bash
python -m pip install requests
```

- [Klucze i nagłówki API](https://flashdata.dev/pl/docs/guides/headers-and-authentication/reference.md)
- [Pola przechowywania](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#storage)

<a id="request-body"></a>

## Utwórz pola żądania

| Pole | Rodzaj | Stosowanie |
| --- | --- | --- |
| source | string | Wymagane. Jedno obsługiwane źródło dla każdego wejścia ID. |
| options | object | Opcje wspólnego źródła. Źródła danych mogą ustawiać result_storage; YouTube Download wymaga przechowywania. |
| callback_url | string | Fakultatywne publiczne wywołanie zakończenia HTTPS. Wysłany po jawnej publikacji. |

- [Schemat pełnego żądania](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-CreateBulkJobRequest)
- [Obróbka haczykowa](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#webhooks)

<a id="createBulkJob"></a>

## Utwórz zadanie Bulk

Utwórz zadanie, wgraj plik tekstowy UTF-8 z jednym znakiem 11- YouTube wideo ID na linię do upload.href, a następnie wywołaj start. Sama praca nie zaczyna się przetwarzać.

Przykład ten zapisuje video-ids.txt i zapisuje paragon 201 na bulk-created.json. Zachowaj ten paragon w tajemnicy i ponownie użyj job.id na każde późniejsze żądanie. Tworzenie zadania pozostawia go w awaiting_upload; wysyłanie URL wygasa po 15 minut.

### Punkt końcowy

```http
POST https://api.flashdata.dev/v2/bulk-jobs
X-API-Key: YOUR_API_KEY
```

### Python

Zapisz bulk_create.py w bulk- api / obok bulk-created.json. Skopiuj kompletny skrypt, a następnie uruchom polecenie poniżej.

#### bulk_create.py

```python
import json
import os
from pathlib import Path

import requests

os.umask(0o077)
Path("video-ids.txt").write_bytes(b"jNQXAC9IVRw\ndQw4w9WgXcQ\n")
response = requests.post(
    "https://api.flashdata.dev/v2/bulk-jobs",
    headers={"X-API-Key": os.environ["FLASHDATA_API_KEY"]},
    json={"source": "youtube_metadata", "options": {"include_formats": False}},
    timeout=30, allow_redirects=False,
)
response.raise_for_status()
receipt = response.json()
Path("bulk-created.json").write_text(json.dumps(receipt, indent=2), encoding="utf-8")
print(json.dumps(receipt["job"], indent=2))
```

#### Uruchom z bulk- api /

```bash
python bulk_create.py
```


### cURL / Bash

#### Uruchom z bulk- api /

```bash
umask 077
printf '%s\n' 'jNQXAC9IVRw' 'dQw4w9WgXcQ' > video-ids.txt
curl --fail-with-body --silent --show-error \
  'https://api.flashdata.dev/v2/bulk-jobs' \
  --header "X-API-Key: ${FLASHDATA_API_KEY:?Set FLASHDATA_API_KEY}" \
  --header 'Content-Type: application/json' \
  --data '{"source":"youtube_metadata","options":{"include_formats":false}}' \
  --output bulk-created.json &&
jq '.job | {id, source, status}' bulk-created.json
```


- [CreateBulkJobRequest](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-CreateBulkJobRequest)
- [BulkJobCreated](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-BulkJobCreated)
- [Problem](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-Problem)

<a id="createBulkJob-responses"></a>

### Odpowiedzi i schematy zapytań

| Status HTTP | Znaczenie |
| --- | --- |
| 201 | Zadania Bulk utworzone z bezpośrednim wysyłaniem 15- minute URL |
| 401 | Wymagane uwierzytelnienie lub nieprawidłowe |
| 422 | Wniosek o zatwierdzenie nie powiódł się |
| 503 | Wymagane uzależnienie lub katalog jest tymczasowo niedostępny |

#### Treść żądania

```json
{
  "$ref": "#/components/schemas/CreateBulkJobRequest"
}
```

#### 201 · application/json

```json
{
  "$ref": "#/components/schemas/BulkJobCreated"
}
```


<a id="startBulkJob"></a>

## Wyślij i uruchom

Zacznij przetwarzanie przesłanego pliku UTF-8 wideo ID, aż do 2 GiB (bajty 2147483648). Po uruchomieniu pliku plik nie uległ zmianie.

Pierwszy PUT video-ids.txt do odbioru upload.href z upload.contentType, bez X-API-Key. Przykład wywołania rozpoczyna się dopiero po zakończeniu wysyłania. Następnie należy zachować niezmieniony plik.

| Parametr | Lokalizacja | Wymóg |
| --- | --- | --- |
| bulkId | path | Wymagane · {"type":"string","pattern":"^bulk_[A-Za-z0-9_-]{8,}$"} |

### Punkt końcowy

```http
POST https://api.flashdata.dev/v2/bulk-jobs/{bulkId}/start
X-API-Key: YOUR_API_KEY
```

### Python

Zapisz bulk_start.py w bulk- api / obok bulk-created.json. Skopiuj kompletny skrypt, a następnie uruchom polecenie poniżej.

#### bulk_start.py

```python
import json
import os
from pathlib import Path

import requests

receipt = json.loads(Path("bulk-created.json").read_text(encoding="utf-8"))
upload = receipt["upload"]
if upload["method"] != "PUT" or not upload["href"].startswith("https://"):
    raise ValueError("Expected an HTTPS PUT upload URL")
# Stream the file to storage without the FlashData key.
with open("video-ids.txt", "rb") as file:
    response = requests.put(
        upload["href"], data=file,
        headers={"Content-Type": upload["contentType"]},
        timeout=300, allow_redirects=False,
    )
    response.raise_for_status()
    if not 200 <= response.status_code < 300:
        raise RuntimeError("Upload did not complete; do not start the job yet")

bulk_id = receipt["job"]["id"]
response = requests.post(
    f"https://api.flashdata.dev/v2/bulk-jobs/{bulk_id}/start",
    headers={"X-API-Key": os.environ["FLASHDATA_API_KEY"]},
    timeout=30, allow_redirects=False,
)
response.raise_for_status()
print(json.dumps(response.json()["job"], indent=2))
```

#### Uruchom z bulk- api /

```bash
python bulk_start.py
```


### cURL / Bash

#### Uruchom z bulk- api /

```bash
BULK_ID=$(jq -er '.job.id' bulk-created.json)
UPLOAD_URL=$(jq -er '.upload.href' bulk-created.json)
CONTENT_TYPE=$(jq -er '.upload.contentType' bulk-created.json)
curl --fail-with-body --silent --show-error --proto '=https' \
  --header "Content-Type: $CONTENT_TYPE" \
  --upload-file video-ids.txt "$UPLOAD_URL" &&
curl --fail-with-body --silent --show-error --request POST \
  "https://api.flashdata.dev/v2/bulk-jobs/$BULK_ID/start" \
  --header "X-API-Key: ${FLASHDATA_API_KEY:?Set FLASHDATA_API_KEY}"
```


- [BulkJobResponse](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-BulkJobResponse)
- [Problem](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-Problem)

<a id="startBulkJob-responses"></a>

### Odpowiedzi

| Status HTTP | Znaczenie |
| --- | --- |
| 200 | Rozpoczęto pracę Bulk lub jego obecny stan idemstrong |
| 401 | Wymagane uwierzytelnienie lub nieprawidłowe |
| 404 | Zasoby nieznalezione lub niebędące własnością osoby dzwoniącej |
| 409 | Stan zasobów lub konflikt idempotencji |
| 422 | Wniosek o zatwierdzenie nie powiódł się |
| 503 | Wymagane uzależnienie lub katalog jest tymczasowo niedostępny |

#### 200 · application/json

```json
{
  "$ref": "#/components/schemas/BulkJobResponse"
}
```


<a id="getBulkJob"></a>

## Uzyskaj status pracy

Przeczytaj job.status, wejście, liczenie, pauseReason i błąd. Recheck ten sam ID z opóźnieniem; ukończone oznacza, że manifest jest publikowany, nie, że każdy film się powiódł.

| Parametr | Lokalizacja | Wymóg |
| --- | --- | --- |
| bulkId | path | Wymagane · {"type":"string","pattern":"^bulk_[A-Za-z0-9_-]{8,}$"} |

### Punkt końcowy

```http
GET https://api.flashdata.dev/v2/bulk-jobs/{bulkId}
X-API-Key: YOUR_API_KEY
```

### Python

Zapisz bulk_status.py w bulk- api / obok bulk-created.json. Skopiuj kompletny skrypt, a następnie uruchom polecenie poniżej.

#### bulk_status.py

```python
import json
import os
from pathlib import Path

import requests

bulk_id = json.loads(Path("bulk-created.json").read_text(encoding="utf-8"))["job"]["id"]
response = requests.get(
    f"https://api.flashdata.dev/v2/bulk-jobs/{bulk_id}",
    headers={"X-API-Key": os.environ["FLASHDATA_API_KEY"]},
    timeout=30, allow_redirects=False,
)
response.raise_for_status()
Path("bulk-job.json").write_text(json.dumps(response.json(), indent=2), encoding="utf-8")
print(json.dumps(response.json()["job"], indent=2))
```

#### Uruchom z bulk- api /

```bash
python bulk_status.py
```


### cURL / Bash

#### Uruchom z bulk- api /

```bash
BULK_ID=$(jq -er '.job.id' bulk-created.json)
curl --fail-with-body --silent --show-error \
  "https://api.flashdata.dev/v2/bulk-jobs/$BULK_ID" \
  --header "X-API-Key: ${FLASHDATA_API_KEY:?Set FLASHDATA_API_KEY}" \
  --output bulk-job.json &&
jq '.job | {id, status, counts, pauseReason, error, expiresAt}' bulk-job.json
```


- [BulkJobResponse](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-BulkJobResponse)
- [Problem](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-Problem)

<a id="getBulkJob-responses"></a>

### Odpowiedzi

| Status HTTP | Znaczenie |
| --- | --- |
| 200 | Stan pracy Bulk |
| 401 | Wymagane uwierzytelnienie lub nieprawidłowe |
| 404 | Zasoby nieznalezione lub niebędące własnością osoby dzwoniącej |

#### 200 · application/json

```json
{
  "$ref": "#/components/schemas/BulkJobResponse"
}
```


<a id="listBulkJobs"></a>

## Lista miejsc pracy

Reakcja zawiera dane i stronniczość. Podaj pagination.nextCursor jako parametr zapytania kursora następnej prośby do czasu, aż będzie to null. Użyj limitu od 1 do 50; domyślną wartością jest 20.

| Parametr | Lokalizacja | Wymóg |
| --- | --- | --- |
| cursor | query | Opcjonalne · {"type":"string","maxLength":512} |
| limit | query | Opcjonalne · {"type":"integer","minimum":1,"maximum":50,"default":20} |

### Punkt końcowy

```http
GET https://api.flashdata.dev/v2/bulk-jobs
X-API-Key: YOUR_API_KEY
```

### Python

Zapisz list_bulk_jobs.py w bulk- api / obok bulk-created.json. Skopiuj kompletny skrypt, a następnie uruchom polecenie poniżej.

#### list_bulk_jobs.py

```python
import json
import os
from pathlib import Path

import requests

response = requests.get(
    "https://api.flashdata.dev/v2/bulk-jobs?limit=20",
    headers={"X-API-Key": os.environ["FLASHDATA_API_KEY"]},
    timeout=30, allow_redirects=False,
)
response.raise_for_status()
print(json.dumps(response.json(), indent=2))
```

#### Uruchom z bulk- api /

```bash
python list_bulk_jobs.py
```


### cURL / Bash

#### Uruchom z bulk- api /

```bash
curl --fail-with-body --silent --show-error --max-time 30 \
  --request GET \
  --header "X-API-Key: ${FLASHDATA_API_KEY:?Set FLASHDATA_API_KEY}" \
  "https://api.flashdata.dev/v2/bulk-jobs?limit=20"
```


- [BulkJobPage](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-BulkJobPage)
- [Problem](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-Problem)

<a id="listBulkJobs-responses"></a>

### Odpowiedzi

| Status HTTP | Znaczenie |
| --- | --- |
| 200 | Strona zadań Bulk |
| 401 | Wymagane uwierzytelnienie lub nieprawidłowe |

#### 200 · application/json

```json
{
  "$ref": "#/components/schemas/BulkJobPage"
}
```


<a id="pauseBulkJob"></a>

## Wstrzymać pracę

Wstrzymać nowe zgłoszenia i opakowanie. Istniejące miejsca pracy nadal z ich pierwotnych ustawień i opłat. Wznowić pracę, kiedy będzie gotowa.

| Parametr | Lokalizacja | Wymóg |
| --- | --- | --- |
| bulkId | path | Wymagane · {"type":"string","pattern":"^bulk_[A-Za-z0-9_-]{8,}$"} |

### Punkt końcowy

```http
POST https://api.flashdata.dev/v2/bulk-jobs/{bulkId}/pause
X-API-Key: YOUR_API_KEY
```

### Python

Zapisz pause_bulk_job.py w bulk- api / obok bulk-created.json. Skopiuj kompletny skrypt, a następnie uruchom polecenie poniżej.

#### pause_bulk_job.py

```python
import json
import os
from pathlib import Path

import requests

bulk_id = json.loads(Path("bulk-created.json").read_text(encoding="utf-8"))["job"]["id"]
response = requests.post(
    f"https://api.flashdata.dev/v2/bulk-jobs/{bulk_id}/pause",
    headers={"X-API-Key": os.environ["FLASHDATA_API_KEY"]},
    timeout=30, allow_redirects=False,
)
response.raise_for_status()
print(json.dumps(response.json(), indent=2))
```

#### Uruchom z bulk- api /

```bash
python pause_bulk_job.py
```


### cURL / Bash

#### Uruchom z bulk- api /

```bash
BULK_ID=$(jq -er '.job.id' bulk-created.json)
curl --fail-with-body --silent --show-error --max-time 30 \
  --request POST \
  --header "X-API-Key: ${FLASHDATA_API_KEY:?Set FLASHDATA_API_KEY}" \
  "https://api.flashdata.dev/v2/bulk-jobs/$BULK_ID/pause"
```


- [BulkJobResponse](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-BulkJobResponse)
- [Problem](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-Problem)

<a id="pauseBulkJob-responses"></a>

### Odpowiedzi

| Status HTTP | Znaczenie |
| --- | --- |
| 200 | Paused mass job or its current idemstrong state |
| 401 | Wymagane uwierzytelnienie lub nieprawidłowe |
| 404 | Zasoby nieznalezione lub niebędące własnością osoby dzwoniącej |

#### 200 · application/json

```json
{
  "$ref": "#/components/schemas/BulkJobResponse"
}
```


<a id="updateBulkJob"></a>

## Aktualizacja opcji pracy

Aktualizuj opcje w oczekiwaniu na wysłanie, lub podczas pauzy zanim wszystkie dane wejściowe zostaną przeczytane. Istniejące miejsca pracy zachowują swoje ustawienia. Jeśli pauza jest w trakcie, czekaj i powtórz odpowiedź 409. Po przeczytaniu wszystkich danych wejściowych można aktualizować jedynie dane uwierzytelniające dostawy. Ustaw callback_url na null, aby go usunąć.

Ten przykład usuwa wywołanie zakończenia. Aby zmienić opcje źródłowe, wyślij obiekt opcji zamiast tego. Zatrzymać się najpierw i czekać, aż przerwa stanie się skuteczna; 409 oznacza, że aktualizacja nie może być jeszcze zastosowana. Istniejące prace dzieci zachowują swoje oryginalne opcje.

| Parametr | Lokalizacja | Wymóg |
| --- | --- | --- |
| bulkId | path | Wymagane · {"type":"string","pattern":"^bulk_[A-Za-z0-9_-]{8,}$"} |

### Punkt końcowy

```http
PATCH https://api.flashdata.dev/v2/bulk-jobs/{bulkId}
X-API-Key: YOUR_API_KEY
```

### Python

Zapisz update_bulk_job.py w bulk- api / obok bulk-created.json. Skopiuj kompletny skrypt, a następnie uruchom polecenie poniżej.

#### update_bulk_job.py

```python
import json
import os
from pathlib import Path

import requests

bulk_id = json.loads(Path("bulk-created.json").read_text(encoding="utf-8"))["job"]["id"]
response = requests.patch(
    f"https://api.flashdata.dev/v2/bulk-jobs/{bulk_id}",
    headers={"X-API-Key": os.environ["FLASHDATA_API_KEY"]},
    json={"callback_url": None},
    timeout=30, allow_redirects=False,
)
response.raise_for_status()
print(json.dumps(response.json(), indent=2))
```

#### Uruchom z bulk- api /

```bash
python update_bulk_job.py
```


### cURL / Bash

#### Uruchom z bulk- api /

```bash
BULK_ID=$(jq -er '.job.id' bulk-created.json)
curl --fail-with-body --silent --show-error --max-time 30 \
  --request PATCH \
  --header "X-API-Key: ${FLASHDATA_API_KEY:?Set FLASHDATA_API_KEY}" \
  --header 'Content-Type: application/json' --data '{"callback_url":null}' \
  "https://api.flashdata.dev/v2/bulk-jobs/$BULK_ID"
```


- [UpdateBulkJobRequest](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-UpdateBulkJobRequest)
- [BulkJobResponse](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-BulkJobResponse)
- [Problem](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-Problem)

<a id="updateBulkJob-responses"></a>

### Odpowiedzi i schematy zapytań

| Status HTTP | Znaczenie |
| --- | --- |
| 200 | Zaktualizowany stan pracy masowej |
| 401 | Wymagane uwierzytelnienie lub nieprawidłowe |
| 404 | Zasoby nieznalezione lub niebędące własnością osoby dzwoniącej |
| 409 | Stan zasobów lub konflikt idempotencji |
| 422 | Wniosek o zatwierdzenie nie powiódł się |

#### Treść żądania

```json
{
  "$ref": "#/components/schemas/UpdateBulkJobRequest"
}
```

#### 200 · application/json

```json
{
  "$ref": "#/components/schemas/BulkJobResponse"
}
```


<a id="resumeBulkJob"></a>

## Wznowienie pracy

Napraw najpierw pauseReason, np. dodając punkty lub aktualizując dane dotyczące pamięci masowej, a następnie wznawiaj ten sam Bulk ID.

| Parametr | Lokalizacja | Wymóg |
| --- | --- | --- |
| bulkId | path | Wymagane · {"type":"string","pattern":"^bulk_[A-Za-z0-9_-]{8,}$"} |

### Punkt końcowy

```http
POST https://api.flashdata.dev/v2/bulk-jobs/{bulkId}/resume
X-API-Key: YOUR_API_KEY
```

### Python

Zapisz resume_bulk_job.py w bulk- api / obok bulk-created.json. Skopiuj kompletny skrypt, a następnie uruchom polecenie poniżej.

#### resume_bulk_job.py

```python
import json
import os
from pathlib import Path

import requests

bulk_id = json.loads(Path("bulk-created.json").read_text(encoding="utf-8"))["job"]["id"]
response = requests.post(
    f"https://api.flashdata.dev/v2/bulk-jobs/{bulk_id}/resume",
    headers={"X-API-Key": os.environ["FLASHDATA_API_KEY"]},
    timeout=30, allow_redirects=False,
)
response.raise_for_status()
print(json.dumps(response.json(), indent=2))
```

#### Uruchom z bulk- api /

```bash
python resume_bulk_job.py
```


### cURL / Bash

#### Uruchom z bulk- api /

```bash
BULK_ID=$(jq -er '.job.id' bulk-created.json)
curl --fail-with-body --silent --show-error --max-time 30 \
  --request POST \
  --header "X-API-Key: ${FLASHDATA_API_KEY:?Set FLASHDATA_API_KEY}" \
  "https://api.flashdata.dev/v2/bulk-jobs/$BULK_ID/resume"
```


- [BulkJobResponse](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-BulkJobResponse)
- [Problem](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-Problem)

<a id="resumeBulkJob-responses"></a>

### Odpowiedzi

| Status HTTP | Znaczenie |
| --- | --- |
| 200 | Bieżący stan pracy masowej |
| 401 | Wymagane uwierzytelnienie lub nieprawidłowe |
| 404 | Zasoby nieznalezione lub niebędące własnością osoby dzwoniącej |

#### 200 · application/json

```json
{
  "$ref": "#/components/schemas/BulkJobResponse"
}
```


<a id="cancelBulkJob"></a>

## Anuluj pracę

Przerwać nowe oświadczenia. Istniejące miejsca pracy mogą nadal podlegać standardowym opłatom finish. Anulowana praca nie publikuje ostatecznego manifestu.

| Parametr | Lokalizacja | Wymóg |
| --- | --- | --- |
| bulkId | path | Wymagane · {"type":"string","pattern":"^bulk_[A-Za-z0-9_-]{8,}$"} |

### Punkt końcowy

```http
DELETE https://api.flashdata.dev/v2/bulk-jobs/{bulkId}
X-API-Key: YOUR_API_KEY
```

### Python

Zapisz cancel_bulk_job.py w bulk- api / obok bulk-created.json. Skopiuj kompletny skrypt, a następnie uruchom polecenie poniżej.

#### cancel_bulk_job.py

```python
import json
import os
from pathlib import Path

import requests

bulk_id = json.loads(Path("bulk-created.json").read_text(encoding="utf-8"))["job"]["id"]
response = requests.delete(
    f"https://api.flashdata.dev/v2/bulk-jobs/{bulk_id}",
    headers={"X-API-Key": os.environ["FLASHDATA_API_KEY"]},
    timeout=30, allow_redirects=False,
)
response.raise_for_status()
print(json.dumps(response.json(), indent=2))
```

#### Uruchom z bulk- api /

```bash
python cancel_bulk_job.py
```


### cURL / Bash

#### Uruchom z bulk- api /

```bash
BULK_ID=$(jq -er '.job.id' bulk-created.json)
curl --fail-with-body --silent --show-error --max-time 30 \
  --request DELETE \
  --header "X-API-Key: ${FLASHDATA_API_KEY:?Set FLASHDATA_API_KEY}" \
  "https://api.flashdata.dev/v2/bulk-jobs/$BULK_ID"
```


- [BulkJobResponse](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-BulkJobResponse)
- [Problem](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-Problem)

<a id="cancelBulkJob-responses"></a>

### Odpowiedzi

| Status HTTP | Znaczenie |
| --- | --- |
| 200 | Bieżący stan pracy masowej |
| 401 | Wymagane uwierzytelnienie lub nieprawidłowe |
| 404 | Zasoby nieznalezione lub niebędące własnością osoby dzwoniącej |

#### 200 · application/json

```json
{
  "$ref": "#/components/schemas/BulkJobResponse"
}
```


<a id="downloadBulkJobManifest"></a>

## Uzyskaj manifest wyników

Postępuj zgodnie z redirect, aby pobrać manifest JSON i użyj jego linków do pobierania plików wyników. Pobierz podpisane przechowywanie URLs bez klucza API. Wyniki pozostają dostępne dla 24 godziny po zakończeniu całego zadania Bulk.

Potwierdzone żądanie API zwraca 302 nagłówkiem Lokalizacji. Pobierz, że HTTPS pamięci URL w odrębnym wniosku bez X-API-Key. Przykład zapisuje manifest.json. 409 oznacza, że wyniki nie są gotowe; 410 oznacza, że wygasły.

| Parametr | Lokalizacja | Wymóg |
| --- | --- | --- |
| bulkId | path | Wymagane · {"type":"string","pattern":"^bulk_[A-Za-z0-9_-]{8,}$"} |

### Punkt końcowy

```http
GET https://api.flashdata.dev/v2/bulk-jobs/{bulkId}/results
X-API-Key: YOUR_API_KEY
```

### Python

Zapisz bulk_manifest.py w bulk- api / obok bulk-created.json. Skopiuj kompletny skrypt, a następnie uruchom polecenie poniżej.

#### bulk_manifest.py

```python
import json
import os
from pathlib import Path

import requests

bulk_id = json.loads(Path("bulk-created.json").read_text(encoding="utf-8"))["job"]["id"]
response = requests.get(
    f"https://api.flashdata.dev/v2/bulk-jobs/{bulk_id}/results",
    headers={"X-API-Key": os.environ["FLASHDATA_API_KEY"]},
    timeout=30, allow_redirects=False,
)
response.raise_for_status()
if response.status_code != 302:
    raise RuntimeError(f"Expected a manifest redirect, got {response.status_code}")
url = response.headers["Location"]
if not url.startswith("https://"):
    raise ValueError("Expected an HTTPS storage URL")

manifest = requests.get(url, timeout=120)  # No FlashData API key.
manifest.raise_for_status()
Path("manifest.json").write_text(json.dumps(manifest.json(), indent=2), encoding="utf-8")
print(json.dumps(manifest.json(), indent=2))
```

#### Uruchom z bulk- api /

```bash
python bulk_manifest.py
```


### cURL / Bash

#### Uruchom z bulk- api /

```bash
BULK_ID=$(jq -er '.job.id' bulk-created.json)
# Only send the API key to FlashData; fetch storage URLs separately.
fetch_bulk_result() {
  local storage_url
  storage_url=$(curl --fail-with-body --silent --show-error \
    "https://api.flashdata.dev/v2/bulk-jobs/$BULK_ID/results$1" \
    --header "X-API-Key: ${FLASHDATA_API_KEY:?Set FLASHDATA_API_KEY}" \
    --output /dev/null --write-out '%{redirect_url}') || return
  curl --fail-with-body --silent --show-error --proto '=https' \
    "${storage_url:?Expected a signed result URL}" --output "$2"
}
fetch_bulk_result '' manifest.json &&
jq '{status, counts, parts, expires_at}' manifest.json
```


- [Problem](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-Problem)

<a id="downloadBulkJobManifest-responses"></a>

### Odpowiedzi

| Status HTTP | Znaczenie |
| --- | --- |
| 200 | JSON manifest pobrany po przekierowaniu |
| 302 | Przekierowanie na krótkożyciowy prywatny R2 URL; Nie wolno przekazywać uwierzytelniania API · Location |
| 401 | Wymagane uwierzytelnienie lub nieprawidłowe |
| 404 | Zasoby nieznalezione lub niebędące własnością osoby dzwoniącej |
| 409 | Stan zasobów lub konflikt idempotencji |
| 410 | Wynik zatrzymany wygasł |

#### 200 · application/json

```json
{
  "type": "object",
  "additionalProperties": true
}
```


<a id="downloadBulkJobPart"></a>

## Pobieranie części wyników

Każdy parts[].number należy używać z manifest.json. Każdy punkt końcowy zwraca 302 do pliku gzip NDJSON; należy pobrać bez klucza API, dekompresji, a następnie przetworzyć jeden obiekt JSON na linię. Dołącz do indeksu zerowego. Przykład pobiera wszystkie części i przechowuje pliki .ndjson.gz i .ndjson.

| Parametr | Lokalizacja | Wymóg |
| --- | --- | --- |
| bulkId | path | Wymagane · {"type":"string","pattern":"^bulk_[A-Za-z0-9_-]{8,}$"} |
| partNumber | path | Wymagane · {"type":"integer","minimum":0} |

### Punkt końcowy

```http
GET https://api.flashdata.dev/v2/bulk-jobs/{bulkId}/results/{partNumber}
X-API-Key: YOUR_API_KEY
```

### Python

Zapisz bulk_parts.py w bulk- api / obok bulk-created.json. Skopiuj kompletny skrypt, a następnie uruchom polecenie poniżej.

#### bulk_parts.py

```python
import json
import os
from pathlib import Path

import requests
import gzip
import shutil

bulk_id = json.loads(Path("bulk-created.json").read_text(encoding="utf-8"))["job"]["id"]
manifest = json.loads(Path("manifest.json").read_text(encoding="utf-8"))
for part in manifest["parts"]:
    number = part["number"]
    response = requests.get(
        f"https://api.flashdata.dev/v2/bulk-jobs/{bulk_id}/results/{number}",
        headers={"X-API-Key": os.environ["FLASHDATA_API_KEY"]},
        timeout=30, allow_redirects=False,
    )
    response.raise_for_status()
    if response.status_code != 302:
        raise RuntimeError(f"Expected a part redirect, got {response.status_code}")
    url = response.headers["Location"]
    if not url.startswith("https://"):
        raise ValueError("Expected an HTTPS storage URL")

    # Save the original gzip bytes; do not decompress twice.
    with requests.get(url, stream=True, timeout=120) as download:
        download.raise_for_status()
        with open(f"part-{number}.ndjson.gz", "wb") as file:
            download.raw.decode_content = False
            shutil.copyfileobj(download.raw, file)
    with gzip.open(f"part-{number}.ndjson.gz", "rt", encoding="utf-8") as rows:
        with open(f"part-{number}.ndjson", "w", encoding="utf-8") as file:
            for line in rows:
                file.write(line)
                print(json.dumps(json.loads(line)))
```

#### Uruchom z bulk- api /

```bash
python bulk_parts.py
```


### cURL / Bash

#### Uruchom z bulk- api /

```bash
BULK_ID=$(jq -er '.job.id' bulk-created.json)
# Only send the API key to FlashData; fetch storage URLs separately.
fetch_bulk_result() {
  local storage_url
  storage_url=$(curl --fail-with-body --silent --show-error \
    "https://api.flashdata.dev/v2/bulk-jobs/$BULK_ID/results$1" \
    --header "X-API-Key: ${FLASHDATA_API_KEY:?Set FLASHDATA_API_KEY}" \
    --output /dev/null --write-out '%{redirect_url}') || return
  curl --fail-with-body --silent --show-error --proto '=https' \
    "${storage_url:?Expected a signed result URL}" --output "$2"
}
fetch_bulk_result '' manifest.json &&
jq '{status, counts, parts, expires_at}' manifest.json

# Run in the same Bash session as fetch_bulk_result.
jq -r '.parts[].number' manifest.json | while IFS= read -r PART; do
  fetch_bulk_result "/$PART" "part-$PART.ndjson.gz" || exit
  gzip -dc "part-$PART.ndjson.gz" > "part-$PART.ndjson" || exit
  jq -c '{index, video_id, status, results, error}' "part-$PART.ndjson"
done
```


- [Problem](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-Problem)

<a id="downloadBulkJobPart-responses"></a>

### Odpowiedzi

| Status HTTP | Znaczenie |
| --- | --- |
| 200 | Gzip- sprężony NDJSON pobrany po przekierowaniu |
| 302 | Przekierowanie na krótkożyciowy prywatny R2 URL; Nie wolno przekazywać uwierzytelniania API · Location |
| 401 | Wymagane uwierzytelnienie lub nieprawidłowe |
| 404 | Zasoby nieznalezione lub niebędące własnością osoby dzwoniącej |
| 409 | Stan zasobów lub konflikt idempotencji |
| 410 | Wynik zatrzymany wygasł |

#### 200 · application/x-ndjson

```json
{
  "type": "string"
}
```


<a id="states"></a>

## Państwa pracy i utrzymanie

Wyniki pozostają dostępne dla 24 godziny po zakończeniu całego zadania Bulk. Zapisz je przed expiresAt. Media w Twoim miejscu przeznaczenia przestrzegają zasad zachowania Twojego wiadra. Ukończone zadanie może obejmować nieudane filmy; counts.invalid zapisuje odrzucone linie wejściowe.

| Państwo | Następna akcja |
| --- | --- |
| awaiting_upload | Wyślij plik i wywołaj start. |
| running | ID z backoff; input.complete pokazuje, czy skanowanie zakończone. |
| paused | Przeczytaj pauseReason, napraw go, a następnie wznowij. |
| finalizing | Poczekać na wyniki pakowania i jawnej publikacji. |
| completed | Ściągnij manifest i każdą jego część. Sprawdź stan i błąd każdego wiersza. |
| failed / cancelled | Sprawdź błąd i stan zapisany. Nie opublikowano żadnego ostatecznego manifestu. |

- [Błędy i kody statusu](https://flashdata.dev/pl/docs/errors/reference.md)
- [Odzyskanie wstrzymanego zadania Bulk](https://flashdata.dev/pl/docs/guides/bulk/reference.md#controls)

<a id="storage"></a>

## Dostawa magazynowa

Użyj placu zabaw, aby skonfigurować dostawcę i podgląd dokładnych pól żądania. Dane uwierzytelniające dla klienta znajdują się w wybranym obiekcie; X-API-Key uwierzytelnia tylko żądania FlashData API.

| Źródło | Utwórz pole żądania | Dostawa |
| --- | --- | --- |
| Metadane, transkrypcja, podpisy, kontrola licencji | options.result_storage | Opcjonalnie. Kopiuje części wyników NDJSON i manifest do wiadra. |
| youtube_download | options.storage | Wymagane. Dostarczanie mediów do wiadra; result_storage i browser_delivery nie są akceptowane. |

- [Pola kredytowe dostawcy](https://flashdata.dev/pl/docs/sources/youtube_download/reference.md#storage)
- [Konfiguracja miejsca przeznaczenia składowania](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#playground)

<a id="storage-layout"></a>

### Znajdź dostarczone pliki

manifest danych jest zapisany jako ostatni i zawiera listę kluczy obiektów, rozmiarów oraz sumy kontrolne SHA- 256. Różni się od manifestu FlashData, który zawiera listę wartości href API. RRRRMMDD w ścieżkach danych używa daty tworzenia UTC Bulk; w ścieżkach mediów używa daty przesyłania każdego wideo UTC. Dostarczanie danych Bulk OSS wymaga uzyskania punktu końcowego aliyuncs.com.

Wartości file_url dla mediów prywatnych wymagają przechowywania SDK lub podpisanego URL od tego dostawcy. Klawisz FlashData nie zapewnia dostępu do wiadra. Opcjonalne pliki towarzyszące metadanych są przechowywane obok mediów. W delivery.retryCount pojawiają się powtórki dostawy.

#### Układ obiektu danych

```text
<prefix>/<source>/<bulkId>/results/part-NNNNNNNN.jsonl.gz
<prefix>/<source>/<bulkId>/manifest.json
```


<a id="webhooks"></a>

## Otrzymuj hak dopełniający

Umieść publiczne opcje HTTPS callback_url na zewnątrz. Bulk wysyła zakończony dopiero po opublikowaniu manifestu; nie wysyła żadnych zdarzeń per- wideo i nie kończy dla nieudanych lub anulowanych zadań. Utrzymuj status sondażu jako zapas.

1. Persist i odduplikować delivery_id, a następnie zwrócić 2xx natychmiast. Dostawa ponownie próbuje do ośmiu razy z wycofaniem.
2. Wydarzenia nie są podpisane. Dopasuj id i źródło do zapisanego paragonu; weryfikuj ukończone za pomocą uwierzytelnionego zarządzania API przed kolejką wyszukiwania. Ignoruj URLs z niezweryfikowanego zdarzenia.

### Utwórz żądanie za pomocą połączenia zwrotnego

```json
{
  "source": "youtube_metadata",
  "options": {
    "include_formats": false,
    "include_chapters": false
  },
  "callback_url": "https://your-app.example/webhooks/flashdata"
}
```

### Impreza integracyjna · ilustracja

```json
{
  "delivery_id": "bulk-completion:bulk_EXAMPLE123",
  "id": "bulk_EXAMPLE123",
  "source": "youtube_metadata",
  "status": "completed",
  "links": [
    {
      "rel": "self",
      "href": "https://api.flashdata.dev/v2/bulk-jobs/bulk_EXAMPLE123",
      "method": "GET"
    },
    {
      "rel": "results",
      "href": "https://api.flashdata.dev/v2/bulk-jobs/bulk_EXAMPLE123/results",
      "method": "GET"
    }
  ]
}
```

- [Generuj odbiornik węzłowy](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#playground)

<a id="schemas"></a>

## Definicje schematów

- [BulkJobCreated](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-BulkJobCreated)
- [BulkJob](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-BulkJob)
- [BulkJobPage](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-BulkJobPage)
- [BulkJobResponse](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-BulkJobResponse)
- [CreateBulkJobRequest](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-CreateBulkJobRequest)
- [JobLink](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-JobLink)
- [Pagination](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-Pagination)
- [Problem](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-Problem)
- [FieldError](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-FieldError)
- [UpdateBulkJobRequest](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-UpdateBulkJobRequest)

<a id="schema-BulkJobCreated"></a>

### BulkJobCreated

#### BulkJobCreated

```json
{
  "type": "object",
  "additionalProperties": false,
  "required": [
    "job",
    "upload"
  ],
  "properties": {
    "job": {
      "$ref": "#/components/schemas/BulkJob"
    },
    "upload": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "href",
        "method",
        "expiresAt",
        "contentType"
      ],
      "properties": {
        "href": {
          "type": "string",
          "format": "uri"
        },
        "method": {
          "type": "string",
          "const": "PUT"
        },
        "expiresAt": {
          "type": "string",
          "format": "date-time"
        },
        "contentType": {
          "type": "string",
          "const": "text/plain; charset=utf-8"
        }
      }
    }
  }
}
```

- [BulkJob](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-BulkJob)

<a id="schema-BulkJob"></a>

### BulkJob

#### BulkJob

```json
{
  "type": "object",
  "additionalProperties": false,
  "required": [
    "id",
    "source",
    "status",
    "input",
    "counts",
    "delivery",
    "pauseReason",
    "error",
    "createdAt",
    "startedAt",
    "completedAt",
    "expiresAt",
    "links"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^bulk_[A-Za-z0-9_-]{8,}$"
    },
    "source": {
      "type": "string",
      "enum": [
        "youtube_metadata",
        "youtube_transcript",
        "youtube_captions",
        "youtube_trainability",
        "youtube_download"
      ]
    },
    "status": {
      "type": "string",
      "enum": [
        "awaiting_upload",
        "running",
        "paused",
        "finalizing",
        "completed",
        "failed",
        "cancelled"
      ]
    },
    "input": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "bytes",
        "complete",
        "scannedBytes",
        "scannedLines"
      ],
      "properties": {
        "bytes": {
          "type": "integer",
          "minimum": 0
        },
        "complete": {
          "type": "boolean"
        },
        "scannedBytes": {
          "type": "integer",
          "minimum": 0
        },
        "scannedLines": {
          "type": "integer",
          "minimum": 0
        }
      }
    },
    "counts": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "accepted",
        "completed",
        "failed",
        "invalid",
        "results"
      ],
      "properties": {
        "accepted": {
          "type": "integer",
          "minimum": 0
        },
        "completed": {
          "type": "integer",
          "minimum": 0
        },
        "failed": {
          "type": "integer",
          "minimum": 0
        },
        "invalid": {
          "type": "integer",
          "minimum": 0
        },
        "results": {
          "type": "integer",
          "minimum": 0
        }
      }
    },
    "pauseReason": {
      "type": [
        "string",
        "null"
      ]
    },
    "delivery": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "customerStorage",
        "storageType",
        "uploadedParts",
        "retryCount"
      ],
      "properties": {
        "customerStorage": {
          "type": "boolean"
        },
        "storageType": {
          "type": [
            "string",
            "null"
          ],
          "enum": [
            "s3",
            "s3_compatible",
            "oss",
            "gcs",
            "azure",
            "cos",
            "bos",
            "tos",
            null
          ]
        },
        "uploadedParts": {
          "type": "integer",
          "minimum": 0
        },
        "retryCount": {
          "type": "integer",
          "minimum": 0
        }
      }
    },
    "error": {
      "oneOf": [
        {
          "type": "null"
        },
        {
          "type": "object",
          "additionalProperties": false,
          "required": [
            "code",
            "detail"
          ],
          "properties": {
            "code": {
              "type": "string"
            },
            "detail": {
              "type": [
                "string",
                "null"
              ]
            }
          }
        }
      ]
    },
    "createdAt": {
      "type": "string",
      "format": "date-time"
    },
    "startedAt": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time"
    },
    "completedAt": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time"
    },
    "expiresAt": {
      "type": [
        "string",
        "null"
      ],
      "format": "date-time"
    },
    "links": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/JobLink"
      }
    }
  }
}
```

- [JobLink](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-JobLink)

<a id="schema-BulkJobPage"></a>

### BulkJobPage

#### BulkJobPage

```json
{
  "type": "object",
  "additionalProperties": false,
  "required": [
    "data",
    "pagination"
  ],
  "properties": {
    "data": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/BulkJob"
      }
    },
    "pagination": {
      "$ref": "#/components/schemas/Pagination"
    }
  }
}
```

- [BulkJob](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-BulkJob)
- [Pagination](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-Pagination)

<a id="schema-BulkJobResponse"></a>

### BulkJobResponse

#### BulkJobResponse

```json
{
  "type": "object",
  "additionalProperties": false,
  "required": [
    "job"
  ],
  "properties": {
    "job": {
      "$ref": "#/components/schemas/BulkJob"
    }
  }
}
```

- [BulkJob](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-BulkJob)

<a id="schema-CreateBulkJobRequest"></a>

### CreateBulkJobRequest

#### CreateBulkJobRequest

```json
{
  "type": "object",
  "additionalProperties": false,
  "required": [
    "source"
  ],
  "properties": {
    "source": {
      "type": "string",
      "enum": [
        "youtube_metadata",
        "youtube_transcript",
        "youtube_captions",
        "youtube_trainability",
        "youtube_download"
      ]
    },
    "options": {
      "type": "object",
      "additionalProperties": true,
      "description": "Reused for every ID. Metadata accepts include_formats and include_chapters. Transcript and captions accept language (one code or an array of 1–10 distinct codes) and auto (applies to all requested languages). Omit language to prefer en-orig, fall back to en, and return one track. With auto=true, each requested code tries its -orig track first, then the plain code. Explicit -orig codes and auto=false stay exact. languageCode identifies the selected track; requestedLanguageCode is included when it differs from the requested code. A language array returns tracks and per-language errors for each video with at least one retrieved track. If no track is retrieved, the video job fails and its reserved credits are refunded. Bulk exports use one JSONL record per video. Trainability accepts no source options. These four data sources optionally accept result_storage. Supported storage_type values are s3, s3_compatible, oss, gcs, azure, cos, bos, and tos. storage_url is the bucket name (Azure container name); object_prefix is optional. S3, S3-compatible, OSS, COS, BOS, and TOS use access_key and secret_key. S3-compatible and OSS also require a public HTTPS endpoint_url. COS, BOS, and TOS require region and use fixed provider endpoints. COS bucket names include the APPID. BOS S3-compatible HTTPS delivery supports bj, su, and hkg. GCS requires service_account with project_id, client_email, and private_key. Azure requires account_name and a container SAS sas_token with write permission. Default object_prefix is YYYYMMDD, frozen to the UTC bulk creation date. Files are written to <prefix>/<source>/<bulkId>/results/part-NNNNNNNN.jsonl.gz; manifest.json in the same bulk directory is written last. Each JSONL row includes its input index and completed, failed, or invalid status. Internal R2 results remain available through the result links for 24 hours. Download accepts the normal YouTube download parameters, requires customer storage, and does not permit browser_delivery. Download storage supports the same eight provider types and credential shapes listed above under the storage field. Download storage may include object_prefix; YYYYMMDD tokens resolve to the UTC upload date, while literal prefixes are unchanged."
    },
    "callback_url": {
      "type": "string",
      "format": "uri",
      "maxLength": 2048,
      "description": "Optional public HTTPS endpoint notified once after manifest publication."
    }
  }
}
```


<a id="schema-JobLink"></a>

### JobLink

#### JobLink

```json
{
  "type": "object",
  "additionalProperties": false,
  "required": [
    "rel",
    "href",
    "method"
  ],
  "properties": {
    "rel": {
      "type": "string",
      "enum": [
        "self",
        "results",
        "content",
        "download"
      ]
    },
    "href": {
      "type": "string",
      "format": "uri"
    },
    "method": {
      "type": "string",
      "const": "GET"
    },
    "expires_at": {
      "type": "string",
      "format": "date-time"
    },
    "filename": {
      "type": "string"
    },
    "content_type": {
      "type": "string"
    },
    "size_bytes": {
      "type": "integer",
      "minimum": 1
    }
  }
}
```


<a id="schema-Pagination"></a>

### Pagination

#### Pagination

```json
{
  "type": "object",
  "additionalProperties": false,
  "required": [
    "hasMore",
    "limit"
  ],
  "properties": {
    "nextCursor": {
      "type": [
        "string",
        "null"
      ]
    },
    "previousCursor": {
      "type": [
        "string",
        "null"
      ]
    },
    "hasMore": {
      "type": "boolean"
    },
    "limit": {
      "type": "integer",
      "minimum": 1,
      "maximum": 100
    }
  }
}
```


<a id="schema-Problem"></a>

### Problem

#### Problem

```json
{
  "type": "object",
  "additionalProperties": false,
  "required": [
    "type",
    "title",
    "status",
    "code",
    "requestId"
  ],
  "properties": {
    "type": {
      "type": "string",
      "format": "uri-reference"
    },
    "title": {
      "type": "string"
    },
    "status": {
      "type": "integer",
      "minimum": 400,
      "maximum": 599
    },
    "code": {
      "type": "string",
      "pattern": "^[a-z0-9_]+$"
    },
    "detail": {
      "type": "string"
    },
    "requestId": {
      "type": "string",
      "pattern": "^req_"
    },
    "fieldErrors": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/FieldError"
      }
    }
  }
}
```

- [FieldError](https://flashdata.dev/pl/docs/reference/bulk-processing/reference.md#schema-FieldError)

<a id="schema-FieldError"></a>

### FieldError

#### FieldError

```json
{
  "type": "object",
  "additionalProperties": false,
  "required": [
    "field",
    "code",
    "message"
  ],
  "properties": {
    "field": {
      "type": "string"
    },
    "code": {
      "type": "string"
    },
    "message": {
      "type": "string"
    }
  }
}
```


<a id="schema-UpdateBulkJobRequest"></a>

### UpdateBulkJobRequest

#### UpdateBulkJobRequest

```json
{
  "type": "object",
  "additionalProperties": false,
  "minProperties": 1,
  "properties": {
    "options": {
      "type": "object",
      "additionalProperties": true,
      "description": "Partial option update. Nested storage fields are merged so unchanged credentials do not need to be resent. Data result_storage fields are merged the same way. After all IDs have been scanned, a paused data bulk job accepts credential updates only: access_key and secret_key, GCS service_account, or Azure sas_token, depending on the storage type. The complete merged configuration is validated before it is stored."
    },
    "callback_url": {
      "type": [
        "string",
        "null"
      ],
      "format": "uri",
      "maxLength": 2048,
      "description": "Replacement completion callback, or null to remove the callback."
    }
  }
}
```

