# Enriquece un archivo de identificadores de vídeo

Convierte un archivo de IDs de YouTube en metadatos JSON y CSV, con un resultado por vídeo. Usa Python o Bash con la CLI de FlashData.

Referencia canónica: https://flashdata.dev/es/docs/guides/bulk-metadata-recipe
Revisado: 2026-11-05 por FlashData

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

## Antes de empezar

Necesitas FlashData CLI v1.2.1 en PATH y Python 3.10+ (solo la biblioteca estándar), o Bash con jq y OpenSSL. Ambas versiones usan la CLI para subir archivos, recuperar trabajos y obtener las partes del resultado. En Windows, usa Git Bash para la versión Bash.

Necesitas una tecla API propietario con permiso youtube_metadata y créditos disponibles. Reutiliza tu login de propietario guardado, o ejecute el login de auth una vez e introduce la llave en su mensaje oculto. Los agentes pueden suministrar FLASHDATA_API_KEY de su tienda secreta.

Estos ejemplos utilizan el perfil predeterminado CLI y el directorio estatal. Mantenga esa misma cuenta y estado guardado para la recuperación. Si el estado de auth muestra acceso temporal, reclame antes de iniciar Bulk.

### Sólo si no tienes acceso al propietario guardado

```bash
flashdata auth login
```

### Compruebe el acceso y el costo de este ejemplo de dos vídeos

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

- [Instalar el CLI](https://flashdata.dev/es/docs/guides/flashdata-cli/reference.md#install)
- [Obtén una clave API](https://flashdata.dev/app/api-keys)
- [Prueba para agentes y vinculación](https://flashdata.dev/es/docs/guides/agent-onboarding/reference.md)

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

## 1. Preparar el vídeo IDs

Cree una carpeta de enriquecimiento a granel y guarde video-ids.txt allí. Abra una terminal en esa carpeta. Utilice un 11-character ID por línea, sin un encabezado, líneas en blanco o YouTube completo URLs.

Elija un script de preparación y guardarlo junto a video-ids.txt. Rechaza IDs inválido y duplicado, a continuación, guarda una instantánea de entrada normalizada, opciones de metadatos y la ejecución ID bajo preparo/. El orden de entrada se conserva.

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

#### Corresponde al enriquecimiento masivo/

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


### Bash

#### Verifique las herramientas locales

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

#### Corresponde al enriquecimiento masivo/

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



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

### Lo que se prepara

Se espera preparado 2 videos únicos para videos-001. Mantener preparado/sin cambios. Metadata utiliza include_formats: falso y include_chapters: falso. Cada vídeo aceptado es un artículo de facturación independiente; líneas duplicadas se procesarían por separado, por lo que esta receta se detiene antes de enviarlos.

Utilice un ID de ejecución que no ha utilizado para una tarea diferente. Retener vídeos-001 para las retries y recuperación de esta tarea. Un nuevo ID de ejecución es para un nuevo dataset o actualización intencional.

- [Elija campos de metadatos](https://flashdata.dev/es/docs/guides/video-metadata-recipe/reference.md#fields)

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

## 2. Presentar y recoger los resultados

Guardar process.py o process.sh en el enriquecimiento a granel antes de ejecutarlo. El CLI crea un trabajo Bulk, carga el IDs preparado, comienza a procesar y guarda cada parte de resultado en bulk-results.ndjson. La espera local se detiene después de los minutos 30; el trabajo de servidor aceptado continúa.

Cada intento consigue su propia carpeta bajo intentos/, con el recibo CLI, error y ejecución guardada. ready.txt señala al último resultado completo. Exit 2 significa resultados completos incluyen videos fallidos; continúan exportando e inspeccionando esas filas.

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

#### Procesar el archivo preparado

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

#### Procesar el archivo preparado

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



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

### Compruebe el progreso de otra terminal

Corre desde el enriquecimiento masivo con la misma cuenta CLI. La acción de estado muestra la ejecución guardada y lee su trabajo remoto Bulk cuando está disponible un ID. No crea ni reanuda el trabajo.

#### Python

##### Lea el progreso actual

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


#### Bash

##### Lea el progreso actual

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



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

## 3. Reconcile and export

Guardar export.py o export.sh junto a los otros scripts, luego ejecutarlo. Chequea el hash de ejecución y entrada guardados, luego coincide con cada resultado por índice cero y video_id. Las partes del resultado pueden llegar fuera de orden.

El exportador conserva el objeto de metadatos completo, el error y el uso reportado para cada fila. Los videos fallidos permanecen visibles con metadatos: null. Este pequeño ejemplo carga los resultados en la memoria; utilice la auditoría de streaming en el procesamiento de archivos Bulk para un conjunto de datos grande.

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

#### Exportar localmente · sin llamadas 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
```

#### Exportar localmente · sin llamadas API

```bash
bash export.sh
```


- [Auditoría de un archivo grande con memoria atada](https://flashdata.dev/es/docs/guides/bulk/reference.md#audit)

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

### Utilice los archivos exportados

El éxito imprime el resumen y los nombres de archivo guardados. Salidas de exportación 0 cuando cada vídeo tuvo éxito, 2 cuando algunos fallaron, o 1 cuando la validación o escritura fallaron. Se conserva una exportación/ existente; leerlo localmente en lugar de la reimpresión de la presentación.

| File under export/ | Úsalo para |
| --- | --- |
| videos.json | Importe en su aplicación o flujo de trabajo de agente. Las filas mantienen orden de entrada, metadatos, errores y uso. |
| videos.csv | Títulos de revisión, duración y fracasos en una hoja de cálculo. El texto tipo fórmula está prefijado con un apostrofe; JSON conserva el texto original. |
| summary.json | Comprobar la cobertura y los recuentos completos de /failed, vinculados a la ejecución ID y Bulk ID. |
| failed-video-ids.txt | Revisar sólo los vídeos confirmados antes de decidir sobre otra solicitud pagada. Vacío cuando todos lo lograron. |

#### Python

##### Lea el resumen guardado y los metadatos

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


#### Bash

##### Lea el resumen guardado y los metadatos

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



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

### Resultado de ejemplo con un vídeo fallido

Ilustrativo videos.json excerpt. Un trabajo Bulk completado puede contener videos fallidos. No trate un video fallido como un resultado exitoso vacío o dejarlo caer silenciosamente desde su conjunto de datos.

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

## Recuperar el mismo trabajo

Si la espera se detuvo o una parte de resultado no se podía leer, ejecutar la recuperación. Recopila el trabajo existente en una carpeta de intentos frescos y actualiza ready.txt sólo después de la recuperación completa. No se carga ni presenta trabajo de reemplazo. A continuación, ejecutar el exportador si la exportación/ aún no se ha creado.

| Resultado ahorrado | Siguiente acción |
| --- | --- |
| bulk_item_failures | Exportar y revisar failed-video-ids.txt. No vuelva a presentar todos los videos exitosos. |
| partial_result | Preserve el archivo parcial. Recuperar la misma carrera para recuperar todas las partes antes de exportar. |
| running / finalizing | Recover later using the same run ID, profile and state directory. |
| paused | Lea pauseReason en estado, corrija la causa, luego reanude explícitamente que Bulk ID usando la guía de control. |
| awaiting_upload / bulk_input_required | Inspeccione el borrador guardado. Cargue el archivo preparado original y comience el Bulk ID existente; la recuperación no vuelve a reproducir estas acciones. |
| Incierto de la presentación o no remoto ID | Mantenga la carrera e inspeccione el error guardado y Bulk Jobs antes de reintentar. Un nuevo ID puede crear otro trabajo. |
| Fuente incorrecta, filas faltantes o el desajuste de entrada | No se acepta ninguna exportación. Revise la instantánea preparada, el archivo de ejecución guardado y resultado; no invente metadatos perdidos. |

### Python

#### Inspeccionar, luego recuperar el trabajo existente

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


### Bash

#### Inspeccionar, luego recuperar el trabajo existente

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


- [Controles de carga, pausa y reanudar](https://flashdata.dev/es/docs/guides/bulk/reference.md#controls)
- [Bulk Trabajos](https://flashdata.dev/app/bulk-jobs)
- [Referencia de punto final Bulk](https://flashdata.dev/es/docs/reference/bulk-processing/reference.md)

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

## Guarda esta instantánea o refrescalo deliberadamente

Guardar los resultados completados dentro de la ventana de retención de 24. Sus exportaciones siguen siendo archivos locales para su reutilización. Para actualizar los metadatos más tarde, utilice una nueva carpeta de trabajo y ejecute ID, y revise el nuevo costo de solicitud primero.

- [Únete a los metadatos de vuelta a tus propios registros](https://flashdata.dev/es/docs/guides/enrich-youtube-videos/reference.md)
- [Obtén subtítulos con marcas de tiempo](https://flashdata.dev/es/docs/guides/timestamped-captions-recipe/reference.md)
