# Kembangkan berkas dari video IDs

Aktifkan berkas YouTube ID ke dalam metadata JSON dan CSV, dengan satu hasil per video. Gunakan Python atau Bash dengan FlashData CLI.

Referensi kanonikal: https://flashdata.dev/id/docs/guides/bulk-metadata-recipe
Diulang: 2026-11-05 oleh FlashData

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

## Sebelum Anda mulai

Gunakan FlashData CLI v1.2.1 nyala PATH, plus Python 3.10+ (hanya pustaka standar), atau Bash dengan jq dan OpenSSL. Kedua versi menggunakan CLI untuk meng-upload, pemulihan pekerjaan dan resusinya. Hidup Windows, gunakan Git Bash untuk Bash versi.

Anda perlu pemilik kunci API dengan izin youtube_metadata dan kredit yang tersedia. Gunakan ulang pemilik log masuk yang disimpan, atau jalankan auth login sekali dan masukkan kunci pada prompt tersembunyi. Agen dapat memasok FLASHDATA_API_KEY dari toko rahasia mereka.

Contoh-contoh ini menggunakan profil CLI dan direktori status. Simpan rekening yang sama dan simpan negara untuk pemulihan. Jika auth status menunjukkan akses sementara, klaim itu sebelum memulai Bulk.

### Hanya jika Anda tidak memiliki pemilik disimpan login

```bash
flashdata auth login
```

### Periksa akses dan biaya dari contoh dua video ini

```bash
flashdata --version
flashdata auth status --json
flashdata account balance --json
flashdata account pricing --source youtube_metadata --request-count 2 --json
flashdata account limits --json
```

- [Pasang CLI](https://flashdata.dev/id/docs/guides/flashdata-cli/reference.md#install)
- [Dapatkan API key](https://flashdata.dev/app/api-keys)
- [Uji coba agen dan penautan akun](https://flashdata.dev/id/docs/guides/agent-onboarding/reference.md)

<a id="input"></a>

## 1. Siapkan video IDs

Buat folder pengayaan dan simpan video-ids.txt di sana. Buka terminal pada folder itu. Gunakan satu 11-character ID per baris, tanpa header, baris kosong atau penuh YouTube URLs.

Pilih satu naskah persiapan dan simpan di samping video-ids.txt. Ia menolak tidak valid dan duplikat IDs, kemudian menyimpan normal input snapshot, pilihan metadata dan jalankan ID di bawah prepared/. Urutan masukan diawetkan.

### bulk-enrichment/video-ids.txt

```text
jNQXAC9IVRw
dQw4w9WgXcQ
```

### Python

#### bulk-enrichment/prepare.py

```python
# Save as bulk-enrichment/prepare.py. Python 3.10+, standard library only.
import hashlib
import json
import os
import re
import sys
from pathlib import Path
from subprocess import run, CalledProcessError, DEVNULL

ROOT = Path(__file__).resolve().parent
try:
    os.umask(0o077)
    run_id = sys.argv[1]
    if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_.:@+-]{0,159}", run_id):
        raise ValueError("Choose a valid, stable run ID.")
    ids = (ROOT / "video-ids.txt").read_text(encoding="utf-8-sig").splitlines()
    ids = [line.strip() for line in ids]
    if not ids or any(not re.fullmatch(r"[A-Za-z0-9_-]{11}", value) for value in ids):
        raise ValueError("Use one 11-character video ID per line, with no blank rows or URLs.")
    if len(set(ids)) != len(ids):
        raise ValueError("Remove duplicate IDs before submitting; they would be processed separately.")
    data = ("\n".join(ids) + "\n").encode("utf-8")
    prepared = ROOT / "prepared"
    prepared.mkdir(mode=0o700)  # Refuse to overwrite an existing input snapshot.
    (prepared / "video-ids.txt").write_bytes(data)
    (prepared / "options.json").write_text(json.dumps({
        "include_formats": False, "include_chapters": False,
    }, indent=2), encoding="utf-8")
    if os.name == "nt":
        # The CLI requires a private options file, including on Windows.
        command = """
$ErrorActionPreference = 'Stop'
$path = [System.IO.Path]::GetFullPath("./prepared/options.json")
$user = [System.Security.Principal.WindowsIdentity]::GetCurrent().User
$acl = [System.Security.AccessControl.FileSecurity]::new()
$acl.SetAccessRuleProtection($true, $false)
$acl.AddAccessRule([System.Security.AccessControl.FileSystemAccessRule]::new($user, 'FullControl', 'Allow'))
[System.IO.File]::SetAccessControl($path, $acl)
"""
        run(["powershell.exe", "-NoProfile", "-NonInteractive", "-Command", command],
            cwd=ROOT, stdin=DEVNULL, check=True, capture_output=True)
    plan = {"run_id": run_id, "source": "youtube_metadata", "input_count": len(ids),
            "input_sha256": hashlib.sha256(data).hexdigest()}
    (prepared / "plan.json").write_text(json.dumps(plan, indent=2), encoding="utf-8")
    print("Prepared", len(ids), "unique videos for", run_id)
except (IndexError, OSError, ValueError, CalledProcessError) as error:
    print(str(error), file=sys.stderr)
    sys.exit(1)
```

#### Lari dari penyempurnaan

```bash
python prepare.py videos-001
```


### Bash

#### Periksa peralatan lokal

```bash
jq --version
openssl version
```

#### bulk-enrichment/prepare.sh

```bash
#!/usr/bin/env bash
# Save as bulk-enrichment/prepare.sh.
set -euo pipefail
trap 'exit 1' ERR
umask 077
cd -- "$(dirname -- "$0")"
case "$(uname -s)" in
  MINGW*|MSYS*|CYGWIN*) jq() { command jq --binary "$@"; } ;;
esac
run_id=${1:?Usage: bash prepare.sh videos-001}
[[ "$run_id" =~ ^[A-Za-z0-9][A-Za-z0-9_.:@+-]{0,159}$ ]] || exit 2
# Validate before creating the snapshot; normalize BOM, CRLF and surrounding spaces.
ids=$(jq -Rsc '
  sub("^\uFEFF"; "") | split("\n")
  | if .[-1] == "" then .[:-1] else . end
  | map(gsub("^\\s+|\\s+$"; ""))
  | if length == 0 or any(.[]; test("^[A-Za-z0-9_-]{11}$") | not)
    then error("Use one 11-character ID per line, with no blank rows or URLs.")
    elif length != (unique | length)
    then error("Remove duplicate IDs before submitting.")
    else . end
' video-ids.txt)
mkdir prepared
printf '%s' "$ids" | jq -r '.[]' > prepared/video-ids.txt
printf '%s\n' '{"include_formats":false,"include_chapters":false}' > prepared/options.json
case "$(uname -s)" in
  MINGW*|MSYS*|CYGWIN*)
    powershell.exe -NoProfile -NonInteractive -Command '
      $ErrorActionPreference = "Stop"
      $path = [System.IO.Path]::GetFullPath("./prepared/options.json")
      $user = [System.Security.Principal.WindowsIdentity]::GetCurrent().User
      $acl = [System.Security.AccessControl.FileSecurity]::new()
      $acl.SetAccessRuleProtection($true, $false)
      $acl.AddAccessRule([System.Security.AccessControl.FileSystemAccessRule]::new($user, "FullControl", "Allow"))
      [System.IO.File]::SetAccessControl($path, $acl)
    ' </dev/null ;;
esac
hash=$(openssl dgst -sha256 prepared/video-ids.txt | awk '{print $NF}')
printf '%s' "$ids" | jq --arg run "$run_id" --arg hash "$hash" '
  {run_id:$run, source:"youtube_metadata", input_count:length, input_sha256:$hash}
' > prepared/plan.json
jq '"Prepared \(.input_count) unique videos for \(.run_id)"' -r prepared/plan.json
```

#### Lari dari penyempurnaan

```bash
bash prepare.sh videos-001
```



<a id="plan"></a>

### Apa yang disiapkan

Diperkirakan 2 menyiapkan video unik untuk video - 001. Tetap siap / tidak berubah. Metadata menggunakan include_formats: false dan include_chapters: false. Setiap video yang diterima adalah item yang dapat ditagih terpisah; duplikasi baris akan diproses secara terpisah, sehingga resep ini berhenti sebelum mengirimkan mereka.

Gunakan berjalan ID Anda belum digunakan untuk tugas yang berbeda. Simpan video-001 untuk tugas ini untuk mengulang dan pemulihan. Sebuah run baru ID adalah untuk sebuah data baru yang disengaja atau penyegaran.

- [Pilih ruas metadata](https://flashdata.dev/id/docs/guides/video-metadata-recipe/reference.md#fields)

<a id="submit"></a>

## 2. Kirim dan kumpulkan hasilnya

Simpan process.py atau process.sh dalam pengayaan-dinding sebelum menjalankannya. CLI menciptakan satu Bulk, mengunggah IDs yang telah disiapkan, mulai memproses dan menyimpan setiap bagian hasil ke dalam bulk-results.ndjson. Penantian lokal berhenti setelah 30 menit; server yang diterima terus berjalan.

Setiap usaha mendapatkan folder sendiri di bawah percobaan /, dengan CLI penerimaan, kesalahan dan disimpan menjalankan. ready.txt poin ke hasil terakhir lengkap. Keluar 2 berarti hasil lengkap termasuk video gagal; terus untuk ekspor dan memeriksa baris-baris.

### Python

#### bulk-enrichment/process.py

```python
# Save as bulk-enrichment/process.py. Requires the FlashData CLI on PATH.
import hashlib
import json
import os
import sys
import tempfile
from pathlib import Path
from subprocess import run, DEVNULL

ROOT = Path(__file__).resolve().parent


def read_json(path):
    return json.loads(path.read_text(encoding="utf-8"))


def main(action):
    os.umask(0o077)
    plan = read_json(ROOT / "prepared/plan.json")
    ids = ROOT / "prepared/video-ids.txt"
    if hashlib.sha256(ids.read_bytes()).hexdigest() != plan["input_sha256"]:
        raise ValueError("The prepared input changed. Restore it before recovery.")
    # Use the same default profile and state directory as auth login/status.
    flags = ["--json", "--non-interactive"]
    def cli(*args):
        return run(["flashdata", *args, *flags], cwd=ROOT, stdin=DEVNULL,
                   capture_output=True, text=True, encoding="utf-8")
    if action == "status":
        result = cli("runs", "show", plan["run_id"])
        if result.returncode:
            raise ValueError(result.stderr)
        saved = json.loads(result.stdout)["data"]
        print(json.dumps({k: saved.get(k) for k in
                          ("id", "remoteId", "status", "stage", "errorCode")}, indent=2))
        if saved.get("remoteId"):
            result = cli("bulk", "get", saved["remoteId"])
            print(result.stdout or result.stderr)
            return result.returncode
        return 0
    if action not in ("submit", "recover"):
        raise ValueError("Choose submit, status or recover.")
    attempts = ROOT / "attempts"
    attempts.mkdir(exist_ok=True)
    directory = Path(tempfile.mkdtemp(prefix="run-", dir=attempts))
    output = str(directory / "bulk-results.ndjson")
    if action == "submit":
        args = ["bulk", "run", "--source", plan["source"], "--input", str(ids),
                "--options", str(ROOT / "prepared/options.json"), "--run-id", plan["run_id"]]
    else:
        args = ["runs", "recover", plan["run_id"]]
    result = cli(*args, "--output", output, "--timeout", "30m")
    (directory / "receipt.json").write_text(result.stdout, encoding="utf-8")
    (directory / "error.json").write_text(result.stderr, encoding="utf-8")
    (directory / "exit-code.txt").write_text(str(result.returncode))
    print("Attempt:", directory.relative_to(ROOT))
    # bulk_item_failures still includes a complete result file with failed rows.
    code = json.loads(result.stderr).get("error", {}).get("code") if result.stderr.strip() else None
    if result.returncode and code != "bulk_item_failures":
        raise ValueError("Collection stopped. Inspect error.json; recover the same run.")
    saved = cli("runs", "show", plan["run_id"])
    (directory / "run.json").write_text(saved.stdout, encoding="utf-8")
    if saved.returncode or not Path(output).is_file():
        raise ValueError("Could not save the run record and results together.")
    record = json.loads(saved.stdout)
    data = record.get("data", {})
    if (not record.get("ok") or data.get("status") != "succeeded"
            or data.get("id") != plan["run_id"] or data.get("source") != plan["source"]
            or data.get("inputFileHash") != plan["input_sha256"]):
        raise ValueError("Inspect the run/input binding before exporting.")
    pointer = ROOT / "ready.next"
    pointer.write_text(directory.relative_to(ROOT).as_posix(), encoding="utf-8")
    pointer.replace(ROOT / "ready.txt")
    print("Results ready for export." if code is None else "Results ready; inspect failed video rows.")
    return 2 if code == "bulk_item_failures" else 0


if __name__ == "__main__":
    try:
        sys.exit(main(sys.argv[1]))
    except (IndexError, KeyError, OSError, ValueError) as error:
        print(str(error), file=sys.stderr)
        sys.exit(1)
```

#### Proses berkas yang dipersiapkan

```bash
python process.py submit
```


### Bash

#### bulk-enrichment/process.sh

```bash
#!/usr/bin/env bash
# Save as bulk-enrichment/process.sh. Requires the FlashData CLI on PATH.
set -euo pipefail
umask 077
cd -- "$(dirname -- "$0")"
case "$(uname -s)" in
  MINGW*|MSYS*|CYGWIN*) jq() { command jq --binary "$@"; } ;;
esac
action=${1:?Usage: bash process.sh submit|status|recover}
plan=prepared/plan.json
run_id=$(jq -er '.run_id' "$plan")
hash=$(openssl dgst -sha256 prepared/video-ids.txt | awk '{print $NF}')
jq -e --arg hash "$hash" '.source == "youtube_metadata" and .input_sha256 == $hash' "$plan" >/dev/null
# Keep the same default profile and state directory as auth login/status.
cli=(flashdata --json --non-interactive)
if [[ "$action" == status ]]; then
  saved=$("${cli[@]}" runs show "$run_id")
  printf '%s' "$saved" | jq '.data | {id,remoteId,status,stage,errorCode}'
  remote=$(printf '%s' "$saved" | jq -r '.data.remoteId // empty')
  [[ -z "$remote" ]] || "${cli[@]}" bulk get "$remote"
  exit 0
fi
case "$action" in
  submit) args=(bulk run --source youtube_metadata --input prepared/video-ids.txt
    --options prepared/options.json --run-id "$run_id") ;;
  recover) args=(runs recover "$run_id") ;;
  *) echo 'Choose submit, status or recover.' >&2; exit 2 ;;
esac
mkdir -p attempts
directory=$(mktemp -d attempts/run-XXXXXX)
exit_code=0
"${cli[@]}" "${args[@]}" --output "$directory/bulk-results.ndjson" --timeout 30m \
  > "$directory/receipt.json" 2> "$directory/error.json" || exit_code=$?
printf '%s' "$exit_code" > "$directory/exit-code.txt"
echo "Attempt: $directory"
code=$(jq -r '.error.code // empty' "$directory/error.json")
if [[ "$exit_code" != 0 && "$code" != bulk_item_failures ]]; then
  echo "Collection stopped. Inspect $directory/error.json; recover the same run." >&2
  exit 1
fi
"${cli[@]}" runs show "$run_id" > "$directory/run.json"
test -f "$directory/bulk-results.ndjson"
jq -e --arg run "$run_id" --arg hash "$hash" '
  .ok and .data.status == "succeeded" and .data.id == $run
  and .data.source == "youtube_metadata" and .data.inputFileHash == $hash
' "$directory/run.json" >/dev/null
printf '%s\n' "$directory" > ready.next
mv ready.next ready.txt
echo 'Results ready for export.'
[[ "$code" != bulk_item_failures ]] || { echo 'Inspect failed video rows.'; exit 2; }
```

#### Proses berkas yang dipersiapkan

```bash
bash process.sh submit
```



<a id="status"></a>

### Periksa kemajuan dari terminal lain

Lari dari pembuktian dinding dengan akun CLI yang sama. Aksi status menunjukkan run tersimpan dan membaca remote Bulk ketika ada ID. Ini tidak membuat atau melanjutkan pekerjaan.

#### Python

##### Baca kemajuan kini

```bash
python process.py status
```


#### Bash

##### Baca kemajuan kini

```bash
bash process.sh status
```



<a id="output"></a>

## 3. Reconcile dan ekspor

Simpan export.py atau export.sh di samping skrip lain, lalu jalankan. Ini memeriksa run disimpan dan hash masukan, kemudian cocok setiap hasil oleh indeks berbasis zero- dan video_id. Hasil suku cadang mungkin akan tiba. Hilang, duplikat atau baris tidak cocok menghentikan ekspor.

Pemasok mempertahankan metadata penuh objek, kesalahan dan laporan penggunaan untuk setiap baris. Video gagal tetap terlihat dengan metadata: null. Contoh kecil ini memuat hasil ke dalam memori; gunakan audit streaming dalam pemrosesan berkas Bulk untuk sebuah data besar.

### Python

#### bulk-enrichment/export.py

```python
# Save as bulk-enrichment/export.py. Local files only; no API calls.
import csv
import hashlib
import json
import os
import re
import sys
from pathlib import Path

ROOT = Path(__file__).resolve().parent
try:
    os.umask(0o077)
    directory = (ROOT / "ready.txt").read_text(encoding="utf-8").strip()
    if not re.fullmatch(r"attempts/run-[A-Za-z0-9_-]+", directory):
        raise ValueError("Use the ready.txt written by process.py or process.sh.")
    directory = ROOT / directory
    def read_json(path):
        return json.loads(path.read_text(encoding="utf-8"))
    plan = read_json(ROOT / "prepared/plan.json")
    raw = (ROOT / "prepared/video-ids.txt").read_bytes()
    ids = raw.decode("utf-8").splitlines()
    saved = read_json(directory / "run.json")
    run = saved["data"]
    digest = hashlib.sha256(raw).hexdigest()
    if (not saved.get("ok") or run.get("status") != "succeeded" or run.get("kind") != "bulk:run"
            or run.get("id") != plan["run_id"] or run.get("source") != "youtube_metadata"
            or run.get("inputFileHash") != digest or plan["input_sha256"] != digest
            or plan["input_count"] != len(ids) or not run.get("remoteId")):
        raise ValueError("The saved run does not match this input file.")
    # This recipe loads a small file into memory to validate it before writing exports.
    records = {}
    with (directory / "bulk-results.ndjson").open(encoding="utf-8") as source:
        for line in source:
            row = json.loads(line)
            index = row.get("index")
            if (type(index) is not int or not 0 <= index < len(ids) or index in records
                    or row.get("video_id") != ids[index] or row.get("source") != "youtube_metadata"
                    or row.get("status") not in ("completed", "failed")):
                raise ValueError("Unknown, duplicate or mismatched result row.")
            metadata = None
            if row["status"] == "completed":
                results = row.get("results")
                if (not isinstance(results, list) or len(results) != 1
                        or not isinstance(results[0], dict) or results[0].get("videoId") != ids[index]):
                    raise ValueError("Completed metadata does not match its video.")
                metadata = results[0]
            records[index] = {
                "index": index, "video_id": ids[index], "status": row["status"],
                "metadata": metadata, "error": row.get("error"), "usage": row.get("usage"),
            }
    if len(records) != len(ids):
        raise ValueError("Missing result rows. Recover the same run before exporting.")
    videos = [records[index] for index in range(len(ids))]
    failed = [v["video_id"] for v in videos if v["status"] == "failed"]
    output = ROOT / "export"
    output.mkdir(mode=0o700)  # Never overwrite an earlier export.
    (output / "videos.json").write_text(json.dumps(videos, ensure_ascii=False, indent=2), encoding="utf-8")
    def cell(value):
        if value is None:
            return ""
        if not isinstance(value, str):
            value = json.dumps(value, ensure_ascii=False, separators=(",", ":"))
        # Keep remote text from being interpreted as a spreadsheet formula.
        return "'" + value if re.match(r"^[ \t\r\n]*[=+@-]|^[\t\r\n]", value) else value
    with (output / "videos.csv").open("x", encoding="utf-8", newline="") as target:
        writer = csv.writer(target)
        writer.writerow(["index", "video_id", "status", "title", "duration", "error"])
        for video in videos:
            metadata = video["metadata"] or {}
            writer.writerow([cell(v) for v in (video["index"], video["video_id"], video["status"],
                            metadata.get("title"), metadata.get("duration"), video["error"])])
    (output / "failed-video-ids.txt").write_bytes("".join(v + "\n" for v in failed).encode("utf-8"))
    summary = {"run_id": plan["run_id"], "bulk_id": run["remoteId"], "input_count": len(ids),
               "completed": len(ids) - len(failed), "failed": len(failed), "coverage_complete": True}
    (output / "summary.json").write_text(json.dumps(summary, indent=2), encoding="utf-8")
    print(json.dumps(summary, indent=2))
    print("Saved export/videos.json, videos.csv and failed-video-ids.txt")
    sys.exit(2 if failed else 0)
except (OSError, ValueError, KeyError, TypeError) as error:
    print(str(error), file=sys.stderr)
    sys.exit(1)
```

#### Ekspor secara lokal panggilan API

```bash
python export.py
```


### Bash

#### bulk-enrichment/export.sh

```bash
#!/usr/bin/env bash
# Save as bulk-enrichment/export.sh. Local files only; no API calls.
set -euo pipefail
trap 'exit 1' ERR
umask 077
cd -- "$(dirname -- "$0")"
case "$(uname -s)" in
  MINGW*|MSYS*|CYGWIN*) jq() { command jq --binary "$@"; } ;;
esac
directory=$(cat ready.txt)
[[ "$directory" =~ ^attempts/run-[A-Za-z0-9_-]+$ ]] || exit 1
hash=$(openssl dgst -sha256 prepared/video-ids.txt | awk '{print $NF}')
jq -e --slurpfile plan prepared/plan.json --arg hash "$hash" '
  .ok and .data.status == "succeeded" and .data.kind == "bulk:run"
  and .data.id == $plan[0].run_id and .data.source == "youtube_metadata"
  and .data.inputFileHash == $hash and $plan[0].input_sha256 == $hash
  and (.data.remoteId | type == "string" and length > 0)
' "$directory/run.json" >/dev/null
# Validate the complete small-sample result before creating export/.
videos=$(jq -sc --rawfile input prepared/video-ids.txt --slurpfile plan prepared/plan.json '
  ($input | split("\n") | .[:-1]) as $ids
  | if $plan[0].input_count != ($ids | length) or length != ($ids | length)
      or any(.[]; (.index | type != "number" or . != floor)
        or .source != "youtube_metadata" or (.status != "completed" and .status != "failed"))
    then error("Missing rows or unexpected source/status/index.")
    else sort_by(.index) end
  | if map(.index) != [range(0; $ids | length)]
      or any(.[]; .video_id != $ids[.index])
    then error("Unknown, duplicate or mismatched rows.")
    elif any(.[]; .status == "completed" and
      ((.results | type != "array" or length != 1) or .results[0].videoId != .video_id))
    then error("Completed metadata does not match its video.")
    else map({index, video_id, status,
      metadata:(if .status == "completed" then .results[0] else null end), error, usage}) end
' "$directory/bulk-results.ndjson")
mkdir export
printf '%s\n' "$videos" | jq . > export/videos.json
jq -r '
  def cell: if . == null then ""
    else (if type == "string" then . else tojson end)
      | if test("^[ \\t\\r\\n]*[=+@-]|^[\\t\\r\\n]") then "'"'"'" + . else . end end;
  (["index","video_id","status","title","duration","error"],
   (.[] | [.index,.video_id,.status,.metadata.title,.metadata.duration,.error] | map(cell)))
  | @csv
' export/videos.json > export/videos.csv
jq -r '.[] | select(.status == "failed") | .video_id' export/videos.json > export/failed-video-ids.txt
jq --slurpfile plan prepared/plan.json --slurpfile run "$directory/run.json" '
  {run_id:$plan[0].run_id, bulk_id:$run[0].data.remoteId, input_count:length,
   completed:([.[] | select(.status == "completed")] | length),
   failed:([.[] | select(.status == "failed")] | length), coverage_complete:true}
' export/videos.json > export/summary.json
cat export/summary.json
echo 'Saved export/videos.json, videos.csv and failed-video-ids.txt'
jq -e '.failed == 0' export/summary.json >/dev/null || exit 2
```

#### Ekspor secara lokal panggilan API

```bash
bash export.sh
```


- [Audit sebuah berkas besar dengan memori terbatas](https://flashdata.dev/id/docs/guides/bulk/reference.md#audit)

<a id="files"></a>

### Gunakan berkas yang diekspor

Cetakan sukses ringkasan dan nama berkas disimpan. Ekspor keluar 0 ketika setiap video berhasil, 2 ketika beberapa gagal, atau 1 ketika validasi atau menulis gagal. Sebuah ekspor yang ada yang diawetkan; membacanya secara lokal bukannya pengiriman lepas kembali.

| Berkas di bawah ekspor / | Gunakan untuk |
| --- | --- |
| videos.json | Impor ke app atau agen alur kerja Anda. Baris menjaga urutan masukan, metadata, kesalahan dan penggunaan. |
| videos.csv | Judul review, durasi dan kegagalan dalam lembar kerja. Formula-seperti teks prefixed dengan murtad; JSON mempertahankan teks asli. |
| summary.json | Periksa cakupan dan jumlah completed/failed, terkait dengan menjalankan ID dan Bulk ID. |
| failed-video-ids.txt | Ulasan hanya dikonfirmasi gagal video sebelum memutuskan pada permintaan dibayar lain. Kosong ketika semua berhasil. |

#### Python

##### Baca ringkasan dan metadata yang tersimpan

```bash
python -m json.tool export/summary.json
python -m json.tool export/videos.json
```


#### Bash

##### Baca ringkasan dan metadata yang tersimpan

```bash
jq . export/summary.json
jq . export/videos.json
```



<a id="expected"></a>

### Hasil yang cukup dengan video yang gagal

Illustratif videos.json excerpt. Pekerjaan Bulk yang selesai dapat berisi video gagal. Jangan perlakukan video gagal sebagai hasil sukses yang kosong atau diam-diam jatuhkan dari data Anda.

#### export/videos.json

```json
[
  {
    "index": 0,
    "video_id": "jNQXAC9IVRw",
    "status": "completed",
    "metadata": {
      "videoId": "jNQXAC9IVRw",
      "title": "Example video",
      "duration": 19
    },
    "error": null,
    "usage": null
  },
  {
    "index": 1,
    "video_id": "dQw4w9WgXcQ",
    "status": "failed",
    "metadata": null,
    "error": {
      "code": "example_video_unavailable"
    },
    "usage": null
  }
]
```


<a id="recover"></a>

## Mengembalikan pekerjaan yang sama

Jika menunggu berhenti atau bagian hasil tidak dapat dibaca, jalankan pemulihan. Ini mengumpulkan pekerjaan yang telah ada ke dalam folder percobaan dan update terbaru ready.txt hanya setelah pengambilan lengkap. Ini tidak meng-upload atau mengirimkan pekerjaan pengganti. Kemudian jalankan ekspor jika ekspor / belum dibuat.

| Hasil yang disimpan | Aksi berikutnya |
| --- | --- |
| bulk_item_failures | Ekspor dan review failed-video-ids.txt. Jangan kirimkan kembali semua video sukses. |
| partial_result | Menjaga file parsial. Recover run yang sama untuk mengambil semua bagian sebelum mengekspor. |
| running / finalizing | Reover kemudian menggunakan run yang sama ID, profil dan direktori negara. |
| paused | Baca pauseReason dalam status, perbaiki penyebabnya, kemudian secara eksplisit melanjutkan bahwa Bulk ID menggunakan panduan kontrol. |
| awaiting_upload / bulk_input_required | Inspeksi draft yang disimpan. Unggah berkas asli yang telah disiapkan dan mulai Bulk ID yang ada; pemulihan tidak memutar ulang aksi-aksi ini. |
| Diserahkan tidak tertentu atau tidak ada remote ID | Terus jalankan dan memeriksa kesalahan yang disimpan dan Bulk Jobs sebelum mencoba kembali. Sebuah run baru ID dapat membuat pekerjaan lain. |
| Sumber salah, baris hilang atau hash masukan tidak cocok | Tak ada ekspor yang diterima. Periksa snapshot yang sudah disiapkan, berkas penyimpanan dan hasil; jangan ciptakan metadata yang hilang. |

### Python

#### Inspeksi, kemudian memulihkan pekerjaan yang telah ada

```bash
python process.py status
python process.py recover
```


### Bash

#### Inspeksi, kemudian memulihkan pekerjaan yang telah ada

```bash
bash process.sh status
bash process.sh recover
```


- [Unggah, tahan, dan resume kontrol](https://flashdata.dev/id/docs/guides/bulk/reference.md#controls)
- [Bulk Jobs](https://flashdata.dev/app/bulk-jobs)
- [Referensi titik akhir Bulk](https://flashdata.dev/id/docs/reference/bulk-processing/reference.md)

<a id="next"></a>

## Simpan snapshot ini atau segarkan dengan sengaja

Simpan hasil selesai dalam jendela retensi 24-hour. Exports Anda tetap berkas lokal untuk digunakan kembali. Untuk menyegarkan metadata kemudian, gunakan folder kerja baru dan jalankan ID, dan tinjau biaya permintaan baru terlebih dahulu.

- [Gabung metadata kembali ke catatan Anda sendiri](https://flashdata.dev/id/docs/guides/enrich-youtube-videos/reference.md)
- [Ambil taktimestamp takarir](https://flashdata.dev/id/docs/guides/timestamped-captions-recipe/reference.md)
