# Verrijk een bestand van video IDs

Zet een YouTube ID bestand om in metadata JSON en CSV, met één uitkomst per video. Gebruik Python of Bash met de FlashData CLI.

Canonische referentie: https://flashdata.dev/nl/docs/guides/bulk-metadata-recipe
Beoordeeld: 2026-11-05 door FlashData

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

## Voordat u begint

Gebruik FlashData CLI v1.2.1 op PATH, plus Python 3.10+ (alleen standaardbibliotheek), of Bash met jq en OpenSSL. Beide versies gebruiken de CLI voor het uploaden, het herstel van taken en het ophalen van resultaten. Gebruik Git Bash op Windows voor de Bash versie.

Je hebt een eigenaar API sleutel nodig met youtube_metadata toestemming en beschikbare credits. Hergebruik uw opgeslagen eigenaar login, of voer auth login een keer uit en voer de sleutel in op de verborgen prompt. Agenten kunnen FLASHDATA_API_KEY leveren vanuit hun geheime winkel.

Deze voorbeelden gebruiken het standaard CLI profiel en de status directory. Hou datzelfde account en opgeslagen staat voor herstel. Als auth status tijdelijke toegang toont, claim het dan voordat u Bulk start.

### Alleen als u geen opgeslagen eigenaar login heeft

```bash
flashdata auth login
```

### Controleer de toegang en de kosten van dit twee-video voorbeeld

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

- [Installeer de CLI](https://flashdata.dev/nl/docs/guides/flashdata-cli/reference.md#install)
- [Een API-sleutel aanmaken](https://flashdata.dev/app/api-keys)
- [Proefgebruik en accountkoppeling](https://flashdata.dev/nl/docs/guides/agent-onboarding/reference.md)

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

## 1. Maak de video IDs klaar

Maak een map met bulkverrijking en sla video-ids.txt daar op. Open een terminal in die map. Gebruik één 11-karakter ID per regel, zonder header, lege regels of volledige YouTube URLs.

Kies één voorbereidingsscript en sla het op naast video-ids.txt. Het verwerpt ongeldige en dupliceren IDs, slaat dan een genormaliseerde invoer snapshot, metadata-opties en de run ID onder prepared/. De invoervolgorde is behouden.

### 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)
```

#### Uitvoeren van bulkverrijking/

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


### Bash

#### Lokaal gereedschap controleren

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

#### Uitvoeren van bulkverrijking/

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



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

### Wat is voorbereid?

Verwacht voorbereide 2 unieke video's voor video's-001. Voorbereiden/ongewijzigd bewaren. Metadata gebruikt include_formats: false en include_chapters: false. Elke geaccepteerde video is een apart factureerbaar item; dubbele regels zouden apart worden verwerkt, zodat dit recept stopt voordat ze worden ingediend.

Gebruik een run ID die je niet hebt gebruikt voor een andere taak. Behoud video's-001 voor de herhalingen en herstel van deze taak. Een nieuwe run ID is voor een opzettelijke nieuwe dataset of verversen.

- [Kies metadatavelden](https://flashdata.dev/nl/docs/guides/video-metadata-recipe/reference.md#fields)

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

## 2. Verzend en verzamel de resultaten

Bewaar process.py of process.sh in bulk-verrijking voordat u het uitvoert. De CLI creëert een Bulk-taak, uploadt de voorbereide IDs, start de verwerking en slaat elk resultaat op in bulk-results.ndjson. De lokale wachttijd stopt na 30 minuten; geaccepteerde serverwerk gaat door.

Elke poging krijgt zijn eigen map onder pogingen/, met de CLI ontvangst, fout en opgeslagen run. ready.txt wijst naar het laatste complete resultaat. Afsluiten 2 betekent complete resultaten omvatten mislukte video's; blijven exporteren en inspecteren van die rijen.

### 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)
```

#### Het voorbereide bestand verwerken

```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; }
```

#### Het voorbereide bestand verwerken

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



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

### Voortgang controleren vanaf een andere terminal

Uitvoeren van bulk-verrijking met dezelfde CLI account. De status actie toont de opgeslagen run en leest de externe Bulk taak wanneer een ID beschikbaar is. Het maakt of hervat geen werk.

#### Python

##### Lees de huidige voortgang

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


#### Bash

##### Lees de huidige voortgang

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



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

## 3. Reconcile en export

Bewaar export.py of export.sh naast de andere scripts, voer het dan uit. Het controleert de opgeslagen run en invoer hash, dan komt overeen met elk resultaat door nul-gebaseerde index en video_id. Resultaat delen kunnen komen buiten de orde. Ontbrekende, dubbele of niet afgestemde rijen stoppen de export.

De exporteur behoudt het volledige metadata-object, de fout en het gerapporteerde gebruik voor elke rij. Foute video's blijven zichtbaar met metadata: null. Dit kleine voorbeeld laadt de resultaten in het geheugen; gebruik de streaming audit in Bulk bestandsverwerking voor een grote dataset.

### 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)
```

#### Exporteer lokaal · geen API gesprekken

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

#### Exporteer lokaal · geen API gesprekken

```bash
bash export.sh
```


- [Een groot bestand met begrensd geheugen controleren](https://flashdata.dev/nl/docs/guides/bulk/reference.md#audit)

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

### De geëxporteerde bestanden gebruiken

Succes drukt de samenvatting af en opgeslagen bestandsnamen. Export verlaat 0 wanneer elke video geslaagd is, 2 wanneer sommige niet zijn gelukt, of 1 wanneer validatie of schrijven mislukt is. Een bestaande export/ wordt bewaard; lees het lokaal in plaats van opnieuw indienen.

| Bestand onder export/ | Gebruik het voor |
| --- | --- |
| videos.json | Importeer in uw app of agent workflow. Rijen houden invoer orde, metadata, fouten en gebruik. |
| videos.csv | Bekijk titels, duur en fouten in een spreadsheet. Formule-achtige tekst wordt vooraf bevestigd met een apostrof; JSON behoudt de oorspronkelijke tekst. |
| summary.json | Controleer dekking en de completed/failed telt, gekoppeld aan de lopende ID en Bulk ID. |
| failed-video-ids.txt | Beoordeling bevestigde alleen mislukte video's voordat een beslissing over een ander betaald verzoek. Leeg als het allemaal gelukt is. |

#### Python

##### Lees de opgeslagen samenvatting en metagegevens

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


#### Bash

##### Lees de opgeslagen samenvatting en metagegevens

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



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

### Voorbeeld resultaat met een mislukte video

Illustratief videos.json fragment. Een voltooide Bulk-taak kan mislukte video's bevatten. Behandel een mislukte video niet als een leeg succesvol resultaat of laat het in stilte uit uw dataset vallen.

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

## Dezelfde baan terughalen

Als het wachten gestopt of een resultaat deel niet kon worden gelezen, voer herstel. Het verzamelt de bestaande taak in een nieuwe poging map en update ready.txt alleen na volledige ophalen. Het uploadt of plaatst geen vervangingswerk. Voer vervolgens de uitvoerder uit als export/nog niet is aangemaakt.

| Opgeslagen resultaat | Volgende actie |
| --- | --- |
| bulk_item_failures | Exporteer en beoordeel failed-video-ids.txt. Niet alle succesvolle video's opnieuw indienen. |
| partial_result | Bewaar het gedeeltelijke dossier. Herstel dezelfde run om alle onderdelen te halen voordat u exporteert. |
| running / finalizing | Herstellen later met dezelfde run ID, profiel en state directory. |
| paused | Lees pauseReason in status, fix de oorzaak, dan expliciet hervatten dat Bulk ID met behulp van de bedieningshandleiding. |
| awaiting_upload / bulk_input_required | Controleer de opgeslagen versie. Upload het oorspronkelijke voorbereide bestand en start de bestaande Bulk ID; herstel speelt deze acties niet opnieuw af. |
| Onbepaalde indiening of geen externe ID | Houd de run en inspecteer de opgeslagen fout en Bulk Jobs voordat u opnieuw probeert. Een nieuwe run ID kan een andere job aanmaken. |
| Verkeerde bron, ontbrekende rijen of invoerhash-afwijking | Export wordt niet geaccepteerd. Controleer het voorbereide snapshot, opgeslagen run en resultaatbestand; zoek geen ontbrekende metadata uit. |

### Python

#### Inspecteren, dan herstellen bestaande werk

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


### Bash

#### Inspecteren, dan herstellen bestaande werk

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


- [Uploaden, pauzeren en hervatten](https://flashdata.dev/nl/docs/guides/bulk/reference.md#controls)
- [Bulk-taken](https://flashdata.dev/app/bulk-jobs)
- [Bulk eindpuntreferentie](https://flashdata.dev/nl/docs/reference/bulk-processing/reference.md)

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

## Sla deze snapshot op of ververs deze doelbewust

Bespaar voltooide resultaten binnen het 24-uurs opslagvenster. Uw export blijft lokale bestanden voor hergebruik. Om de metadata later te vernieuwen, gebruik je een nieuwe werkmap en voer je ID uit, en bekijk je de nieuwe aanvraagkosten eerst.

- [Metadata terugzetten naar je eigen records](https://flashdata.dev/nl/docs/guides/enrich-youtube-videos/reference.md)
- [Tijdstempel bijschriften ophalen](https://flashdata.dev/nl/docs/guides/timestamped-captions-recipe/reference.md)
