# Resultaten opslaan en hergebruiken

Houd een resultaat met zijn oorspronkelijke invoer, bron links en gebruik, dan overhandig het aan een ander proces zonder een andere query.

Canonische referentie: https://flashdata.dev/nl/docs/guides/save-results
Beoordeeld: 2026-11-05 door FlashData

<a id="realtime"></a>

## Eenmaal opvragen, het resultaat gebruiken in verschillende taken

Maak een rapport, heronderzoek je parser of geef een latere agent hetzelfde bewijs. Deze workflow slaat één zoekopdracht op als een draagbaar archief; het lezen van dat archief heeft noch een FlashData-sleutel, noch de oorspronkelijke CLI-status nodig.

### Wat je zult houden

```text
archive/saved-search/
  request.json originele query en parameters
  response.json onveranderd API-respons
  citations.ndjson titels, bron URLs en knipsels
  manifest.json draait ID, gebruik, bestandsgroottes en SHA-256
```

- [Heb je al een async resultaat?](https://flashdata.dev/nl/docs/guides/save-results/reference.md#jobs)
- [Een Bulk-dataset opslaan](https://flashdata.dev/nl/docs/guides/save-results/reference.md#bulk)
- [Gedownloade media behouden](https://flashdata.dev/nl/docs/guides/save-results/reference.md#media)

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

## Voordat u begint

Gebruik een nieuwe werkmap, de FlashData CLI met google_search toestemming en beschikbare credits. Hergebruik een geauthentiseerd profiel of FLASHDATA_API_KEY. Bash-inspectie gebruikt jq; Windows gebruikt PowerShell 7. De lokale archiefscripts gebruiken Python 3.10+ en de standaardbibliotheek.

Ga verder wanneer data.accessVerified true is. Voor CLI retries, houd hetzelfde profiel, OS gebruiker en state directory. Een agent moet zijn bestaande geloofwaardigheid uit zijn geheime winkel laden.

### Controleer uw opgeslagen toegang

```bash
flashdata auth status --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)
- [Gebruik HTTP in plaats daarvan](https://flashdata.dev/nl/docs/guides/save-results/reference.md#http)

<a id="save"></a>

## 1. Houd de invoer en sla één antwoord op

Spaar request.json hieronder op en voer dan één commando uit. --input gebruikt dit exacte verzoek; houd het bestand daarna ongewijzigd. --output slaat de API body op in search.json; --json print CLI metadata. saved-search is de lokale run ID van deze taak.

### request.json

```json
{
  "source": "google_search",
  "query": "battery recycling research",
  "params": {
    "num": 5
  }
}
```

### Bash

#### Een zoekopdracht uitvoeren

```bash
flashdata query --input request.json \
  --run-id saved-search --output search.json --json
```


### PowerShell

#### Een zoekopdracht uitvoeren

```powershell
flashdata query --input request.json `
  --run-id saved-search --output search.json --json
```



<a id="inspect"></a>

## 2. Het opgeslagen antwoord valideren

Verwacht bron: google_search, status: done en een resultatenreeks. Print de titel, link en knipsel van elk biologisch resultaat. De werkelijke resultaten variëren; een lege succesvolle collectie is anders dan een mislukt verzoek of een ontbrekend veld.

### Bash / jq

#### Valideren en lezen van search.json

```bash
jq -e '.source == "google_search" and .status == "done"
  and (.results | type == "array")
  and all(.results[]; (.organic | type == "array"))' search.json > /dev/null &&
jq -c '.results[] | .organic[] | {title, link, snippet}' search.json
```


### PowerShell

#### Valideren en lezen van search.json

```powershell
$result = Get-Content -Raw -LiteralPath search.json | ConvertFrom-Json
if ($result.source -ne 'google_search' -or $result.status -ne 'done' -or
    -not ($result.results -is [array])) {
  throw 'Inspect search.json before treating the task as complete.'
}
foreach ($page in $result.results) {
  if (-not ($page.organic -is [array])) { throw 'Missing organic results array.' }
  $page.organic | Select-Object title, link, snippet
}
```



<a id="record"></a>

## 3. Archiveer de invoer, reactie en citaten

Sla archive.py hieronder op en voer het uit met de ID van stap 1. Het bewaart de ruwe bestanden, haalt bron links en schrijft manifest.json laatste met bestand controlesums en gebruik. Verwacht complete: true; het aantal citaties hangt af van de zoekresultaten. Er worden geen netwerkverzoeken gedaan.


<a id="archive-script"></a>

### archive.py opslaan

Maak archive.py naast request.json en search.json in uw werkmap. Kopieer de volledige code hieronder in het en sla het op.

Het voorbeeld archiveert Google Search resultaten. Bestaande archiefmappen worden intact gehouden. Houd request.json, search.json en de bijbehorende run samen totdat archivering voltooid is.

#### archive.py

```python
# archive.py — Python 3.10+, standard library only; no network requests.
import argparse
import hashlib
import json
import re
from datetime import datetime, timezone
from pathlib import Path
from urllib.parse import urlsplit

parser = argparse.ArgumentParser()
parser.add_argument('--run-id', required=True)
args = parser.parse_args()
if not re.fullmatch(r'[A-Za-z0-9_-]+', args.run_id):
    raise ValueError('Use the CLI run ID from this task.')
request_bytes = Path('request.json').read_bytes()
result_bytes = Path('search.json').read_bytes()
request = json.loads(request_bytes.decode('utf-8-sig'))
result = json.loads(result_bytes.decode('utf-8-sig'))
if (request.get('source') != 'google_search' or result.get('source') != request['source']
        or result.get('status') not in ['done', 'completed']
        or not isinstance(result.get('results'), list)):
    raise ValueError('Inspect the request and result before archiving.')
citations = []
for page in result['results']:
    if not isinstance(page, dict) or not isinstance(page.get('organic'), list):
        raise ValueError('Expected an organic results array, including when it is empty.')
    for item in page['organic']:
        if not isinstance(item, dict) or not isinstance(item.get('link'), str):
            raise ValueError('A result is missing its source URL.')
        url = urlsplit(item['link'])
        if url.scheme not in ['http', 'https'] or not url.netloc:
            raise ValueError('Inspect an unexpected source URL.')
        citations.append({key: item.get(key, '') for key in ['title', 'link', 'snippet']})
files = {'request.json': request_bytes, 'response.json': result_bytes,
         'citations.ndjson': ''.join(json.dumps(row, ensure_ascii=False) + '\n'
                                    for row in citations).encode('utf-8')}
manifest = {'version': 1, 'run_id': args.run_id, 'source': request['source'],
            'archived_at': datetime.now(timezone.utc).isoformat(),
            'usage': result.get('usage'), 'citation_count': len(citations),
            'files': {name: {'bytes': len(data), 'sha256': hashlib.sha256(data).hexdigest()}
                      for name, data in files.items()}}
folder = Path('archive') / args.run_id
folder.mkdir(parents=True)  # Existing archives are preserved. Choose a new run ID for new work.
for name, data in files.items():
    with (folder / name).open('xb') as output:
        output.write(data)
# Write the manifest last. Without it, the archive is incomplete.
with (folder / 'manifest.json').open('x', encoding='utf-8') as output:
    json.dump(manifest, output, ensure_ascii=False, indent=2)
print(json.dumps({'archive': str(folder), 'citations': len(citations), 'complete': True}))
```


<a id="run-archive"></a>

### Archief aanmaken

Uitvoeren vanuit de map met archive.py, request.json en search.json.

#### Bash

##### Bouw een nieuw archief

```bash
python3 archive.py --run-id saved-search
```


#### PowerShell 7

##### Bouw een nieuw archief

```powershell
python archive.py --run-id saved-search
```



<a id="reuse"></a>

## 4. Het archief opnieuw gebruiken zonder referenties

Bewaar reuse.py hieronder. Kopieer de volledige archive/saved-search map naar het proces dat het nodig heeft, en voer vervolgens deze reader uit. Het controleert elk bestand voordat u de oorspronkelijke query, gebruik en citaten afdrukt. Het werkt na API-sleutel intrekking of gehost-resultaat verlopen omdat het alleen leest uw opgeslagen exemplaar.


<a id="reuse-script"></a>

### reuse.py opslaan

reuse.py aanmaken in de werkmap met archive/. Op een andere machine, kopieer zowel reuse.py als de complete archive/saved-search directory, met behoud van deze lay-out.

#### reuse.py

```python
# reuse.py — run without a FlashData key or CLI.
import hashlib
import json
import sys
from pathlib import Path

folder = Path(sys.argv[1])
manifest = json.loads((folder / 'manifest.json').read_text(encoding='utf-8'))
expected = {'request.json', 'response.json', 'citations.ndjson'}
if manifest.get('version') != 1 or set(manifest.get('files', {})) != expected:
    raise ValueError('Unknown or incomplete archive manifest.')
files = {}
for name in sorted(expected):
    data = (folder / name).read_bytes()
    record = manifest['files'][name]
    if len(data) != record['bytes'] or hashlib.sha256(data).hexdigest() != record['sha256']:
        raise ValueError('Archive changed or was not fully copied: ' + name)
    files[name] = data
request = json.loads(files['request.json'].decode('utf-8-sig'))
citations = [json.loads(line) for line in files['citations.ndjson'].decode('utf-8').splitlines()]
if len(citations) != manifest['citation_count']:
    raise ValueError('Citation count does not match the manifest.')
print(json.dumps({'run_id': manifest['run_id'], 'query': request['query'],
                  'archived_at': manifest['archived_at'], 'usage': manifest['usage'],
                  'citations': citations}, indent=2))
```


<a id="read-archive"></a>

### Het opgeslagen archief lezen

Sla reuse.py op en voer vervolgens uit de map. Het laatste argument is het pad naar het gekopieerde archief.

#### Bash

##### Het gekopieerde archief lezen

```bash
python3 reuse.py archive/saved-search
```


#### PowerShell 7

##### Het gekopieerde archief lezen

```powershell
python reuse.py archive/saved-search
```



<a id="cli-cache"></a>

### Exporteren uit het CLI journal in plaats daarvan

Als je nog steeds het originele CLI-profiel en de statusmap hebt, exporteer dan de opgeslagen run naar een nieuwe bestandsnaam. Dit maakt geen nieuwe vraag, maar het controleert live toegang eerst. Een bestaand resultaatbestand of archief kan lokaal gelezen worden zonder die controle.

#### Uitvoeren van voltooid programma

```bash
flashdata runs show saved-search --result --output search-copy.json --json
```


<a id="freshness"></a>

## Beslis wanneer hergebruik of opfris

archived_at registreert wanneer u de bestanden hebt opgeslagen, niet wanneer een bronpagina is veranderd. Uw aanvraag bepaalt hoe recent het bewijs moet zijn; het kopiëren van een bestand ververst de inhoud niet.

| Taak | Actie |
| --- | --- |
| Herstart een parser, regenereer een rapport of zet een agent stap | Hergebruik het opgeslagen antwoord. Houd bron URLs, zoekparameters en gebruik mee. |
| Maak een nieuwe dagelijkse briefing of beantwoord een gewijzigde vraag | Maak een nieuwe task/run ID, werkmap en archief. Houd oudere snapshots als geschiedenis. |
| Tel het gebruik in afgeleide bestanden | Tel de oorspronkelijke vraag één keer. Het kopiëren van een antwoord of het maken van een ander rapport creëert geen andere lading. |

- [Terugkerende taken en IDs uitvoeren](https://flashdata.dev/nl/docs/guides/recurring-tasks/reference.md)
- [Bestaande resultaten formatteren](https://flashdata.dev/nl/docs/guides/response-formats/reference.md#completed-results)

<a id="retention"></a>

## Weten wat afloopt

| Resultaat | Wat te houden | Bewaring |
| --- | --- | --- |
| Realtime query | Het antwoordbestand en de oorspronkelijke invoer | Uw opgeslagen kopie volgt uw opslagbeleid |
| Async / Batch-taak | Job ID, ontvangst en resultaat JSON | 24 uren na voltooiing |
| Bulk | Manifest en alle NDJSON delen | 24 uren nadat de hele job is voltooid; controleer expiresAt |
| YouTube Download | Levering JSON en media op uw bestemming | Levering JSON: vacaturebehoud. Media: uw emmerlevenscyclus |
| MCP chunk cache | Het volledig geassembleerde resultaat | 10 minuten; alleen de vier nieuwste grote resultaten per API sleutel worden bewaard |


<a id="sidecar"></a>

## Houd een klein zijspan in plaats daarvan

Hou de oorspronkelijke reactie onveranderd. Sla een klein zijspan op met de invoer, bron, bespaar tijd en gebruik, zodat een later proces kan begrijpen wat het bestand heeft geproduceerd. Houd bron URLs en video tijdstempels bij het transformeren van resultaten.

### Bash / jq · search-record.json

```bash
(
set -euC
jq --arg run_id 'saved-search' --slurpfile request request.json \
  '{run_id: $run_id, source, input: $request[0],
    saved_at: (now | todateiso8601), result_file: "search.json", usage}' \
  search.json > search-record.json
cat search-record.json
)
```


<a id="http"></a>

## Direct opslaan met HTTP

Gebruik dit in plaats van de CLI query in stap 1. Sla eerst dezelfde request.json op; dit draait een nieuwe query met Bash, cURL 7.76+ en jq. Hergebruik FLASHDATA_API_KEY en kies een map zonder search.json. Na validatie werken dezelfde archiefscripts met dit resultaat; kies je eigen taak ID voor --run-id.

Een nonzero cURL uitgang betekent dat het resultaat niet klaar is voor gebruik. Controleer het opgeslagen antwoord voordat u het opnieuw probeert; een timeout van de verbinding kan gebeuren nadat een query is geaccepteerd. Gebruik het validatie commando in stap 2.

### Stel uw sleutel in indien nodig

```bash
# Bash: paste the key into a hidden prompt, not into this command.
read -r -s -p "FlashData API key: " FLASHDATA_API_KEY
printf '\n'
export FLASHDATA_API_KEY
```

### Het antwoord API opslaan

```bash
(
set -euC
: "${FLASHDATA_API_KEY:?Set FLASHDATA_API_KEY first}"
test -f request.json
curl --fail-with-body --silent --show-error --max-time 120 \
  --request POST 'https://data.flashdata.dev/v1/queries/realtime' \
  --header "X-API-Key: $FLASHDATA_API_KEY" \
  --header 'Content-Type: application/json' --header 'Accept: application/json' \
  --data-binary @request.json > search.json
jq . search.json
)
```


<a id="jobs"></a>

## Een bestaande achtergrondtaak opslaan

Gebruik submission.json uit de async-gids en dezelfde account credential. Deze commando's halen bestaand werk op; ze sturen geen andere zoekopdracht. De CLI wacht op voltooiing en behandelt de resultaatredirect. Bewaar het resultaat binnen 24 uren na voltooiing.

### CLI + jq

#### Wacht, ophalen en opslaan

```bash
(
set -euC
JOB_ID=$(jq -er '.remoteId // .id // .submission.id' submission.json)
flashdata jobs wait "$JOB_ID" --json
flashdata jobs result "$JOB_ID" --output job-result.json --json
jq '{source, status, results, usage}' job-result.json
)
```


### HTTP / cURL

De statuscontrole stopt als de opdracht niet is voltooid. Als het nog steeds in de wachtrij staat of draait, wacht en voer dit alleen-lezen knipsel opnieuw uit; inspecteer een mislukte taak in plaats daarvan. Een 302 wordt gedownload zonder uw API sleutel door te sturen. De tijdelijke respons wordt gevalideerd voordat job-result.json wordt aangemaakt.

#### Bash · cURL + jq

```bash
(
set -euC
: "${FLASHDATA_API_KEY:?Set FLASHDATA_API_KEY first}"
test ! -e job-result.json || { echo 'Choose a new output filename.' >&2; exit 1; }
JOB_ID=$(jq -er '.remoteId // .id // .submission.id' submission.json)
printf '%s' "$JOB_ID" | grep -Eq '^[A-Za-z0-9_-]+$'
SOURCE=$(jq -er '(.submission // .).source' submission.json)
API="https://api.flashdata.dev/v2/jobs/$JOB_ID"
curl --fail-with-body --silent --show-error \
  --max-time 30 --header "X-API-Key: $FLASHDATA_API_KEY" "$API" >| job-status.json
jq -e --arg id "$JOB_ID" --arg source "$SOURCE" \
  '.job.id == $id and .job.source == $source and .job.status == "completed"' job-status.json >/dev/null
STATUS=$(curl --silent --show-error \
  --header "X-API-Key: $FLASHDATA_API_KEY" \
  --max-time 120 --dump-header result-headers.txt --output job-result.pending \
  --write-out '%{http_code}' "$API/results")
case "$STATUS" in
  200) ;;
  302)
    LOCATION=$(awk 'tolower($1) == "location:" { sub(/\r$/, "", $2); print $2 }' result-headers.txt)
    # No FlashData API key on the signed storage request.
    curl --fail-with-body --silent --show-error --compressed --max-time 120 \
      --proto '=https' --output job-result.pending "$LOCATION" ;;
  *) echo "HTTP $STATUS: inspect job-result.pending and result-headers.txt." >&2; exit 1 ;;
esac
jq -e --arg source "$SOURCE" '.source == $source and (.status == "done" or .status == "completed")
  and (.results | type == "array")' job-result.pending >/dev/null
cat job-result.pending > job-result.json
jq '{source, status, results, usage}' job-result.json
)
```


- [Een bestaande async-taak hervatten](https://flashdata.dev/nl/docs/guides/async-batch/reference.md#resume)
- [Resultaatresponscontract](https://flashdata.dev/nl/docs/reference/realtime-and-async/reference.md#results)
- [Ophalen als Markdown](https://flashdata.dev/nl/docs/guides/response-formats/reference.md#completed-results)

<a id="bulk"></a>

## Sla elk Bulk resultaatdeel op

Vervang BULK_ID door de ID in uw inzendingsbon. Nadat de taak is voltooid, volgt de CLI het manifest en slaat elk onderdeel op als één NDJSON-bestand. Hou het manifest ook wanneer u tellingen nodig hebt en deelmetadata.

Het bestand kan zowel succesvolle als mislukte rijen bevatten. Reconcile input indexen en tellingen voordat de hele taak is voltooid. Niet opnieuw uitvoeren van het gehele invoerbestand om een mislukte rij te herstellen.

### Verzamelen van de voltooide taak

```bash
flashdata bulk results BULK_ID --output bulk-results.ndjson --timeout 30m --json
```

- [Controleer elke invoer voordat u importeert](https://flashdata.dev/nl/docs/guides/bulk/reference.md#audit)
- [Manifest, counts en NDJSON](https://flashdata.dev/nl/docs/reference/bulk-processing/reference.md#downloadBulkJobManifest)

<a id="media"></a>

## Bewaar het leveringsrecord en de media

delivery.json bevat een leveringsrecord, niet de video of audio bytes. Sla zijn URL, grootte en controlesom naast de taak. De media leven in uw bestemmingsopslag en volgt de levenscyclus van die opslag.

Voor een privé-bestemming, gebruik de referenties van die provider of ondertekend URL om het object te inspecteren. Een ontbrekend tijdelijk resultaat JSON betekent niet dat uw opgeslagen media zijn verwijderd.

### Controleer een opgeslagen download resultaat · jq

```bash
jq '.results[] | {file_url, file_size, md5, downloaded_bytes, output_format}' delivery.json
```

- [Grootte, controlesom en media verifiëren](https://flashdata.dev/nl/docs/guides/youtube-download-guide/reference.md#verify-media)

<a id="mcp"></a>

## MCP brokken samenvoegen voordat u opslaat

Als een hulpmiddel result_id, chunk en next_offset teruggeeft, lees dan de resterende brokken met get_result met dezelfde API sleutel. Gebruik de exacte next_offset die door de tool wordt teruggegeven; de onderstaande waarden zijn plaatshouders.

1. Voeg elke brok toe in offset volgorde. Volg next_offset tot het null is.
2. Ontleed de samengevoegde tekst eenmaal als JSON, schrijf dan het volledige resultaat naar uw eigen bestand of opslag.
3. Opslaan voor expires_at. Nieuwe grote reacties kunnen oudere resultaten verwijderen voordat de 10-minutenlimiet; de cache houdt vier per API-sleutel.

### MCP tools/call argumenten

```json
{
  "name": "get_result",
  "arguments": {
    "result_id": "RESULT_ID_FROM_TOOL",
    "offset": 16000
  }
}
```

- [Runnable MCP client met chunk collectie](https://flashdata.dev/nl/docs/guides/mcp-custom-client/reference.md)

<a id="recovery"></a>

## Opslaan en ophalen van problemen oplossen

| Probleem | Repareren |
| --- | --- |
| Uitvoerbestand bestaat al | Inspecteer het eerst. Voor een voltooide CLI-run, gebruik runs show met een nieuwe uitvoer bestandsnaam in plaats van het indienen van een andere query. |
| CLI kan de run niet vinden | Gebruik de originele OS-gebruiker, profiel en statusmap. Als je een externe taak ID hebt behouden, haal die taak dan direct op. |
| 401 / 403 bij hergebruik | Start flashdata auth status --json en herstel de geldige toegang. Een lokaal bestand dat al is opgeslagen kan nog steeds worden gelezen zonder toegang tot API. |
| 409 / 410 | 409: wacht op de bestaande taak. 410: gebruik uw opgeslagen kopie; het tijdelijke resultaat is verlopen. |
| Schijffout na een query | Houd de lopende ID of taak ID. Repareer opslag en herstel bestaande werkzaamheden voordat u een nieuwe indiening overweegt. |
| Archief heeft geen manifest of een controlesom mislukt | Herstel of kopieer de originele bestanden opnieuw. Houd een onvolledig archief voor inspectie; herbouwen van het archief vereist geen nieuwe zoekopdracht. |
| MCP · result_unavailable | Controleer resultaat ID, offset, API sleutel en verlopen. Gebruik een opgeslagen kopie als de cache is verlopen; loop niet door een betaalde query te herhalen. |

- [CLI herstel commando's](https://flashdata.dev/nl/docs/guides/cli-automation/reference.md#recover)
- [Verzoek om het oplossen van problemen](https://flashdata.dev/nl/docs/guides/troubleshooting/reference.md)
