# Kontoprüfungen und gespeicherte Ergebnisse mit SDKs

Überprüfen Sie die Kosten, führen Sie eine Aufzeichnung jedes Versuchs und lesen Sie die gespeicherten Ergebnisse ohne einen weiteren API-Aufruf.

Kanonische Referenz: https://flashdata.dev/de/docs/guides/sdk-operations
Test: 2026-11-04 von FlashData

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

## Bevor Sie anfangen

Verwenden Sie das Projekt, das SDK und FLASHDATA_API_KEY von Ihrem SDK-Schnellstart installiert wurde. Wählen Sie unten eine Sprache aus. Jedes neue ausgeführte Verzeichnis stellt eine beabsichtigte Suche dar; die Wiederverwendung eines vorhandenen Verzeichnisses wird gestoppt, bevor eine Anfrage gestellt wird.

- [Go SDK Setup](https://flashdata.dev/de/docs/guides/flashdata-go/reference.md)
- [Python SDK](https://flashdata.dev/de/docs/guides/flashdata-python/reference.md)
- [TypeScript SDK](https://flashdata.dev/de/docs/guides/flashdata-typescript/reference.md)

<a id="check"></a>

## 1. Überprüfen Sie den Zugang und aktuelle Kosten

Speichern und führen Sie den Scheck für Ihren SDK aus. Es liest Berechtigungen, Guthaben und den Preis eines Google Search. Fahren Sie erst fort, nachdem der Access-Check bestanden wurde; diese Schecks senden keine bezahlte Abfrage oder Reserveguthaben.

### Python

#### check_access.py

```python
import os
import sys
from flashdata import FlashData, APIError

def main():
    key = os.environ.get("FLASHDATA_API_KEY", "").strip()
    if not key:
        raise RuntimeError("Set FLASHDATA_API_KEY in this terminal.")
    with FlashData(api_key=key) as client:
        access = client.account.access()
        if "google_search" not in access["sources"]:
            raise RuntimeError("This key needs google_search permission.")
        balance = client.account.balance()
        pricing = client.account.pricing(source="google_search", request_count=1)
    price = next((p for p in pricing["prices"]
                  if p["source"] == "google_search" and p["available"]), None)
    cost = price.get("estimatedCredits") if price else None
    if cost is None:
        raise RuntimeError("No current price is available; stop here.")
    available = balance["availableCredits"]
    print(f"Available credits: {available}")
    print(f"One search: {cost} credits")
    if available < cost:
        raise RuntimeError("Insufficient credits. Review Billing.")
    print("Access check passed. No paid query submitted.")

if __name__ == "__main__":
    try:
        main()
    except APIError as error:
        print(f"HTTP {error.status_code}; code={error.code}; "
              f"request_id={error.request_id}; Retry-After={error.retry_after}",
              file=sys.stderr)
        sys.exit(1)
    except Exception as error:
        print(f"{type(error).__name__}: {error}", file=sys.stderr)
        sys.exit(1)
```

#### Linux / macOS

```bash
.venv/bin/python check_access.py
```

#### Windows PowerShell

```powershell
.\.venv\Scripts\python.exe check_access.py
```


### TypeScript / JavaScript

#### check-access.mjs

```javascript
import { FlashData, APIError } from '@flashdata-dev/sdk';

try {
  const apiKey = process.env.FLASHDATA_API_KEY?.trim();
  if (!apiKey) throw new Error('Set FLASHDATA_API_KEY in this terminal.');
  const client = new FlashData({ apiKey });
  const access = await client.account.access();
  if (!access.sources.includes('google_search')) {
    throw new Error('This key needs google_search permission.');
  }
  const balance = await client.account.balance();
  const pricing = await client.account.pricing({ source: 'google_search', request_count: 1 });
  const price = pricing.prices.find(p => p.source === 'google_search' && p.available);
  const cost = price?.estimatedCredits;
  if (cost == null) throw new Error('No current price is available; stop here.');
  console.log('Available credits:', balance.availableCredits);
  console.log('One search:', cost, 'credits');
  if (balance.availableCredits < cost) throw new Error('Insufficient credits. Review Billing.');
  console.log('Access check passed. No paid query submitted.');
} catch (error) {
  if (error instanceof APIError) {
    console.error('HTTP', error.statusCode, 'code:', error.code,
      'request_id:', error.requestId, 'Retry-After:', error.retryAfter);
  } else {
    console.error(error instanceof Error ? error.message : String(error));
  }
  process.exitCode = 1;
}
```

#### Ausführen

```bash
node check-access.mjs
```


### Go

Erstellen Sie cmd/check und speichern Sie diese Datei dort.

#### cmd/check/main.go

```go
package main

import (
    "context"
    "fmt"
    "log"
    "os"
    "slices"
    "time"

    flashdata "github.com/flashdatadev/flashdata-go"
)

func main() {
    key := os.Getenv("FLASHDATA_API_KEY")
    if key == "" {
        log.Fatal("Set FLASHDATA_API_KEY in this terminal.")
    }
    client, err := flashdata.New(flashdata.Options{APIKey: key})
    if err != nil {
        log.Fatal(err)
    }
    ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
    defer cancel()

    identity, err := client.Account.Identity(ctx)
    if err != nil {
        log.Fatal(err)
    }
    if identity.Access != "ready" || !slices.Contains(identity.Scopes, flashdata.SourceGoogleSearch) {
        log.Fatal("This key is not ready for google_search. Check its status and permissions.")
    }
    balance, err := client.Account.Balance(ctx)
    if err != nil {
        log.Fatal(err)
    }
    pricing, err := client.Account.Pricing(ctx, flashdata.PricingParams{
        Source: flashdata.SourceGoogleSearch, RequestCount: 1,
    })
    if err != nil {
        log.Fatal(err)
    }
    if len(pricing.Prices) != 1 || pricing.Prices[0].Source != "google_search" ||
        !pricing.Prices[0].Available || pricing.Prices[0].EstimatedCredits == nil {
        log.Fatal("A current Google Search price is unavailable. Do not submit yet.")
    }
    cost := *pricing.Prices[0].EstimatedCredits
    fmt.Printf("Account: %s (%s)\n", identity.AccountID, identity.AccountType)
    fmt.Printf("Available credits: %g\nOne search: %g credits\n", balance.AvailableCredits, cost)
    if balance.AvailableCredits < cost {
        log.Fatal("Insufficient credits. Check Billing or claim existing trial access.")
    }
    fmt.Println("Access check passed. No paid query submitted.")
}
```

#### Ausführen

```bash
go run ./cmd/check
```



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

## 2. Führen Sie mit einem neuen Ausgabeverzeichnis

Führen Sie eines dieser Programme aus, nachdem der Scheck bestanden wurde. Es erstellt das Verzeichnis vor dem Absenden, zeichnet die Anfrage auf und speichert dann die Antwort. Behalten Sie das Verzeichnis auf Fehler: Das Löschen oder Auswählen eines neuen Verzeichnisses ermöglicht eine weitere abrechenbare Abfrage.

### Python

#### archive_search.py

```python
import json
import os
import sys
from datetime import datetime, timezone
from pathlib import Path
from flashdata import FlashData, APIError, SubmissionUnknownError

def main():
    key = os.environ.get("FLASHDATA_API_KEY", "").strip()
    if not key:
        raise RuntimeError("Set FLASHDATA_API_KEY before running.")
    directory = Path(sys.argv[1] if len(sys.argv) > 1 else "runs/research-001")
    directory.mkdir(mode=0o700, parents=True, exist_ok=False)

    def save(name, value):
        with (directory / name).open("x", encoding="utf-8") as output:
            json.dump(value, output, ensure_ascii=False, indent=2)

    request = {"source": "google_search", "query": "battery recycling research",
               "params": {"num": 5}}
    save("request.json", request)
    save("intent.json", {"state": "dispatching",
                         "startedAt": datetime.now(timezone.utc).isoformat()})
    try:
        with FlashData(api_key=key) as client:
            response = client.google.search(request["query"], **request["params"])
    except (APIError, SubmissionUnknownError) as error:
        detail = {"kind": type(error).__name__}
        if isinstance(error, APIError):
            detail.update(code=error.code, httpStatus=error.status_code,
                          requestId=error.request_id, retryAfter=error.retry_after)
        save("error.json", detail)
        raise RuntimeError("Inspect the saved attempt and History before retrying.") from None
    save("result.json", response)
    if response.get("status") != "done":
        raise RuntimeError("Response saved; inspect its status before proceeding.")
    print("Saved:", directory / "result.json")
    print("Usage:", response.get("usage"))

if __name__ == "__main__":
    try:
        main()
    except Exception as error:
        print(f"{type(error).__name__}: {error}", file=sys.stderr)
        sys.exit(1)
```

#### Linux / macOS

```bash
.venv/bin/python archive_search.py runs/research-001
```

#### Windows PowerShell

```powershell
.\.venv\Scripts\python.exe archive_search.py runs/research-001
```


### TypeScript / JavaScript

Speichern Sie dieses Node ESM-Programm entweder in einem JavaScript- oder TypeScript-Projekt. Es verwendet das gleiche installierte @flashdata-dev/sdk-Paket.

#### archive-search.mjs

```javascript
import { mkdir, writeFile } from 'node:fs/promises';
import { dirname, join } from 'node:path';
import { FlashData, APIError, SubmissionUnknownError } from '@flashdata-dev/sdk';

try {
  const apiKey = process.env.FLASHDATA_API_KEY?.trim();
  if (!apiKey) throw new Error('Set FLASHDATA_API_KEY before running.');
  const directory = process.argv[2] || 'runs/research-001';
  await mkdir(dirname(directory), { recursive: true });
  await mkdir(directory, { mode: 0o700 }); // Existing attempt: stop before any API call.
  const save = (name, value) => writeFile(join(directory, name),
    JSON.stringify(value, null, 2), { flag: 'wx', mode: 0o600 });
  const request = { source: 'google_search', query: 'battery recycling research',
    params: { num: 5 } };
  await save('request.json', request);
  await save('intent.json', { state: 'dispatching', startedAt: new Date().toISOString() });
  const client = new FlashData({ apiKey });
  let response;
  try {
    response = await client.google.search({ query: request.query, ...request.params });
  } catch (error) {
    const detail = { kind: error instanceof SubmissionUnknownError
      ? 'SubmissionUnknownError' : error instanceof APIError ? 'APIError' : 'ClientError' };
    if (error instanceof APIError) Object.assign(detail, {
      code: error.code, httpStatus: error.statusCode,
      requestId: error.requestId, retryAfter: error.retryAfter,
    });
    await save('error.json', detail);
    throw new Error('Inspect the saved attempt and History before retrying.');
  }
  await save('result.json', response);
  if (response.status !== 'done') throw new Error('Response saved; inspect its status.');
  console.log('Saved:', join(directory, 'result.json'));
  console.log('Usage:', response.usage);
} catch (error) {
  console.error(error instanceof Error ? error.message : 'Inspect this attempt.');
  process.exitCode = 1;
}
```

#### Ausführen

```bash
node archive-search.mjs runs/research-001
```


### Go

Erstellen Sie cmd/archive, damit dieser Einstiegspunkt von Ihrem Quickstart-Programm getrennt bleibt.

#### cmd/archive/main.go

```go
package main

import (
    "context"
    "encoding/json"
    "errors"
    "fmt"
    "os"
    "path/filepath"
    "time"
    flashdata "github.com/flashdatadev/flashdata-go"
)

func main() {
    if err := run(); err != nil {
        fmt.Fprintln(os.Stderr, err)
        os.Exit(1)
    }
}

func run() error {
    key := os.Getenv("FLASHDATA_API_KEY")
    if key == "" { return errors.New("set FLASHDATA_API_KEY before running") }
    directory := "runs/research-001"
    if len(os.Args) > 1 { directory = os.Args[1] }
    if err := os.MkdirAll(filepath.Dir(directory), 0700); err != nil { return err }
    if err := os.Mkdir(directory, 0700); err != nil { return err }
    save := func(name string, value any) error {
        file, err := os.OpenFile(filepath.Join(directory, name), os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600)
        if err != nil { return err }
        err = json.NewEncoder(file).Encode(value)
        closeErr := file.Close()
        if err != nil { return err }
        return closeErr
    }
    query := flashdata.GoogleSearchInput{Query: "battery recycling research",
        Params: &flashdata.GoogleSearchParams{Num: flashdata.Ptr(int64(5))}}
    if err := save("request.json", map[string]any{"source": "google_search",
        "query": query.Query, "params": query.Params}); err != nil { return err }
    if err := save("intent.json", map[string]string{"state": "dispatching",
        "startedAt": time.Now().UTC().Format(time.RFC3339)}); err != nil { return err }
    client, err := flashdata.New(flashdata.Options{APIKey: key})
    if err != nil { return err }
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
    defer cancel()
    result, err := client.Google.Search(ctx, query)
    if err != nil {
        detail := map[string]any{"kind": "ClientError"}
        var api *flashdata.APIError
        var unknown *flashdata.SubmissionUnknownError
        if errors.As(err, &api) {
            detail = map[string]any{"kind": "APIError", "code": api.Code,
                "httpStatus": api.StatusCode, "requestId": api.RequestID, "retryAfter": api.RetryAfter}
        } else if errors.As(err, &unknown) { detail["kind"] = "SubmissionUnknownError" }
        if saveErr := save("error.json", detail); saveErr != nil { return saveErr }
        return errors.New("inspect the saved attempt and History before retrying")
    }
    if err := save("result.json", result); err != nil { return err }
    if result.Status != "done" { return errors.New("response saved; inspect its status") }
    fmt.Printf("Saved: %s\nUsage: %+v\n", filepath.Join(directory, "result.json"), result.Usage)
    return nil
}
```

#### Ausführen

```bash
go run ./cmd/archive runs/research-001
```



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

### Voraussichtliche Dateien

Erfolg druckt den gespeicherten Ergebnispfad und die Nutzung. result.json sollte status: done haben; Google Ergebnisse sind in results[].organic[]. Eine leere organische Anordnung ist gültig. Ein gemeldeter API- oder Transportfehler wird in error.json gespeichert; intent.json bleibt der ursprüngliche Voreinreichungs-Datensatz.

#### Erfolgreicher Versuch

```text
runs/research-001/
  request.json # Quelle, Abfrage und Parameter
  intent.json # Startzeit versuchen
  result.json # Vollständige Antwort, einschließlich Ergebnisse und Nutzung
```


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

## 3. Gespeicherte Ausgabe lesen

Lesen Sie result.json für Parsing, Zusammenfassungen und UI-Arbeit. Diese Befehle verwenden nur lokale Dateien. Das erneute Ausführen der Suche mit demselben Verzeichnis wird vor einem Netzwerkaufruf gestoppt; es koordiniert nicht verschiedene Computer oder stellt eine verlorene Serverantwort wieder her.

### Bash

#### Vor Ort lesen

```bash
cat runs/research-001/result.json
```


### PowerShell

#### Vor Ort lesen

```powershell
Get-Content -Raw -LiteralPath './runs/research-001/result.json'
```


### Go: getippte Ergebnisse

Erstellen Sie cmd/read und speichern Sie diesen Decoder dort. Es liest die Datei und druckt Quelltitel und URLs aus, ohne einen Client zu erstellen oder eine API-Anforderung zu erstellen.

#### cmd/read/main.go

```go
package main

import (
    "encoding/json"
    "fmt"
    "log"
    "os"
    flashdata "github.com/flashdatadev/flashdata-go"
)

func main() {
    filename := "runs/research-001/result.json"
    if len(os.Args) > 1 { filename = os.Args[1] }
    data, err := os.ReadFile(filename)
    if err != nil { log.Fatal(err) }
    var result flashdata.DataQueryResponse
    if err := json.Unmarshal(data, &result); err != nil { log.Fatal(err) }
    if result.Source != "google_search" || result.Status != "done" {
        log.Fatal("Expected a completed Google Search response")
    }
    pages, err := flashdata.DecodeResults[flashdata.GoogleSearchPayload](&result)
    if err != nil { log.Fatal(err) }
    for _, page := range pages {
        for _, hit := range page.Organic {
            if hit.Title != nil && hit.Link != nil { fmt.Println(*hit.Title, *hit.Link) }
        }
    }
    fmt.Printf("Original query credits: %g\n", result.Usage.Credits)
}
```

#### Dekodieren der gespeicherten Antwort

```bash
go run ./cmd/read runs/research-001/result.json
```


- [Google Search Ergebnisse analysieren](https://flashdata.dev/de/docs/sources/google_search/reference.md)
- [Geteilte Ergebnisformate](https://flashdata.dev/de/docs/guides/response-formats/reference.md)

<a id="errors"></a>

## Entscheiden Sie, was nach einem Misserfolg zu tun ist

| Was du hast | Nächste Maßnahme |
| --- | --- |
| Bestehendes Verzeichnis / EEXIST | Inspizieren Sie seine Akten. Es wurde keine neue Abfrage durch diesen Versuch gesendet. |
| result.json, status: done | Lesen und Verarbeiten der gespeicherten Antwort. Wiederverwendung seiner Verwendung als Erhalt der ursprünglichen Gebühr. |
| error.json mit 401 / 403 / 402 | Beheben Sie Zugriff, Quellberechtigungen oder Balance, bevor Sie einen neuen Versuch planen. |
| 429 / retryAfter | Warten Sie wie angewiesen und reduzieren Sie die Anforderungsrate. Überprüfen Sie den fehlgeschlagenen Versuch, bevor Sie ein neues Run-Verzeichnis auswählen. |
| Unbekannte Einreichung / Absicht nur / Schreibfehler | Arbeiten können bereits angenommen werden. Führen Sie das Verzeichnis und prüfen Sie History oder einen bekannten Job ID, bevor Sie eine weitere Abfrage senden. |

- [Anfrageverlauf](https://flashdata.dev/app/jobs)
- [Rückforderungsentscheidungen](https://flashdata.dev/de/docs/guides/agent-recovery/reference.md)

<a id="async"></a>

## Async-Clients und Hintergrundjobs

| Bedarf | Verwendung |
| --- | --- |
| Halten Sie eine Ereignisschleife reaktionsschnell | Der async-Client / await-Aufrufe des SDK. Eine Echtzeitabfrage wird in ihrer HTTP-Antwort noch abgeschlossen. |
| Wiederaufnahme nach dem Aufrufen Prozess beendet | Senden Sie einmal einen Hintergrundjob, speichern Sie den entfernten ID, lesen Sie dann Status und Ergebnisse. |
| Laufen Sie nach einem Zeitplan | Verwenden Sie den Besitzerzugriff und dauerhafte Anwendungslaufdatensätze oder das bestehende Laufjournal des CLI. |

- [Async und Batch-Workflow](https://flashdata.dev/de/docs/guides/async-batch/reference.md)
- [Wiederkehrende Aufgaben](https://flashdata.dev/de/docs/guides/recurring-tasks/reference.md)
