# ตรวจสอบบัญชีและผลลัพธ์ที่บันทึกด้วย SDK

Check ค่าใช้จ่ายเก็บไว้บันทึกของแต่ละความพยายามและการอ่านผลลัพธ์โดยไม่ต้องอื่น API โทรสิ

อ้างอิงทางคลอง: https://flashdata.dev/th/docs/guides/sdk-operations
Recorder: 2026-11-04 โดย FlashData

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

## ก่อนจะเริ่ม

ใช้โครงการที่ถูกติดตั้งแล้ว SDK ถึง FLASHDATA_API_KEY จากเธอ SDK สตาร์ทเร็ว เลือกหนึ่งภาษาด้านล่างนี้ ไดเร็คทอรีสําหรับประมวลผลตัวใหม่แต่ละตัว จะใช้การค้นหาที่ตั้งใจไว้; ทําการหยุดไดเรกทอรีที่มีอยู่ก่อนจะทําการร้องขอ

- [Go SDK ตั้งค่า](https://flashdata.dev/th/docs/guides/flashdata-go/reference.md)
- [Python SDK ตั้งค่า](https://flashdata.dev/th/docs/guides/flashdata-python/reference.md)
- [TypeScript SDK ตั้งค่า](https://flashdata.dev/th/docs/guides/flashdata-typescript/reference.md)

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

## 1. ตรวจสอบสิทธิ์และค่าใช้จ่ายปัจจุบัน

บันทึกและเรียกตรวจสอบสําหรับ SDK ของคุณ มันอ่านสิทธิ์ที่อนุญาต ดุลยภาพ และราคาของ Google Search ทําต่อไปหลังจากผ่านการตรวจสอบการเข้าใช้แล้วเท่านั้น เช็คเหล่านี้ไม่ส่งข้อมูลที่ร้องขอมา หรือหน่วยกิตสํารอง

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

#### เรียกใช้

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


### Go

สร้าง cmd/check และบันทึกแฟ้มนี้ไว้ที่นี่

#### 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.")
}
```

#### เรียกใช้

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



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

## 2. ประมวลผลด้วยไดเรกทอรีส่งออกเสียงตัวใหม่

ประมวลผลโปรแกรมเหล่านี้ โปรแกรมหนึ่งหลังจากการตรวจสอบผ่าน มันสร้างไดเร็กทอรีก่อนที่จะส่งข้อมูล บันทึกคําขอ แล้วบันทึกการตอบสนอง เก็บไดเรกทอรีไว้เมื่อล้มเหลว: การลบหรือเลือกไดเรกทอรีใหม่ จะเป็นการอนุญาตให้สอบถามได้ง่ายขึ้น

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

บันทึกโปรแกรม ESM นี้ในทั้งสองโปรแกรม JavaScript หรือ TypeScript โครงการ มันใช้ติดตั้งเดียวกันflashdata-dev/sdk แพคเกจ

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

#### เรียกใช้

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


### Go

สร้าง cmd/archive เพื่อให้ตําแหน่งนี้แยกออกจากโปรแกรมด่วนของคุณ

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

#### เรียกใช้

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



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

### แฟ้มที่ต้องการ

พิมพ์ผลการค้นหาเส้นทางและการใช้งานของผลลัพธ์ที่บันทึกไว้ result.json ควรจะมี status: done; Google ผลที่ได้คือ results[].organic[]. อินทรีย์อาร์เรย์ว่างใช้ได้ รายงาน API จัดเก็บข้อผิดพลาดในการรับส่งข้อมูลไปยัง error.json; intent.json ยังเป็นประวัติเดิมก่อนการรับราชการ

#### การพยายามเสร็จสมบูรณ์

```text
runs/research-001/
  request.json # แหล่งที่มา, สืบค้นและพารามิเตอร์
  intent.json # พยายามเริ่มเวลา
  result.json    # ตอบสนองเต็มที่ รวมทั้งผลลัพธ์และการใช้งาน
```


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

## 3. อ่านผลลัพธ์ที่บันทึกไว้

อ่าน result.json สําหรับ partsing, ผลรวมและงาน UI คําสั่งเหล่านี้ใช้เฉพาะแฟ้มภายในระบบเท่านั้น ทําการค้นหาใหม่อีกครั้ง โดยใช้ไดเร็กทอรีเดียวกันนี้หยุดก่อนที่จะมีการเรียกจากเครือข่าย มันไม่ได้ประสานงานกับเครื่องอื่น ๆ หรือเรียกคืนการตอบกลับของแม่ข่ายหาย

### Bash

#### อ่านภายในเครื่อง

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


### PowerShell

#### อ่านภายในเครื่อง

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


### Go& พิมพ์ผล

สร้าง cmd/read และบันทึกตัวถอดรหัสไว้ที่นั่น มันอ่านเอกสารและชื่อแหล่งการพิมพ์ URLs โดยไม่ต้องสร้างลูกค้า หรือทํา API ขอล่ะ

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

#### ถอดรหัสการตอบสนองที่บันทึกไว้

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


- [สี่เหลี่ยม Google Search ผลลัพธ์](https://flashdata.dev/th/docs/sources/google_search/reference.md)
- [รูปแบบผลลัพธ์ที่ใช้ร่วมกัน](https://flashdata.dev/th/docs/guides/response-formats/reference.md)

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

## จง ตัดสิน ใจ ว่า จะ ทํา อย่าง ไร หลัง จาก ล้ม เหลว

| สิ่งที่คุณมี | การกระทําถัดไป |
| --- | --- |
| มีไดเร็กทอรีอยู่ / esEXist | จําแนกแฟ้ม ไม่มีการส่งคําร้องขอใหม่จากความพยายามนี้ |
| result.json, status: done | อ่านและประมวลผลการตอบสนองที่บันทึกไว้ ใช้การนําไปใช้เป็นใบเสร็จ ของค่าใช้จ่ายเดิม |
| error.json ด้วย 401 / 403 / 402 | ปรับแก้สิทธิ์ในการใช้งาน, สิทธิ์ที่แหล่งหรือดุลยภาพ ก่อนที่จะมีการวางแผนใหม่ |
| 429 / retryAfter | รอฟังคําสั่งและลดอัตราการขอ ทบทวนความพยายามที่ล้มเหลวก่อนที่จะเลือกไดเรกทอรีสําหรับประมวลผลตัวใหม่ |
| ไม่รู้จักการส่งข้อมูล / วัตถุประสงค์ / เขียนเท่านั้นล้มเหลว | งาน อาจ ได้ รับ การ ยอม รับ แล้ว. เก็บไดเรกทอรีและตรวจสอบ History หรืองานที่รู้จักดี ID ก่อนที่จะส่งคําถามอีก |

- [ต้องการประวัติ](https://flashdata.dev/app/jobs)
- [การตัดสินใจฟื้นฟู](https://flashdata.dev/th/docs/guides/agent-recovery/reference.md)

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

## Async โปรแกรมลูกข่ายและงานเบื้องหลัง

| ต้องการ | ใช้ |
| --- | --- |
| คงการเรียกดูเหตุการณ์ต่าง ๆ ไว้ | เดอะ SDKลูกค้าของแอสซิงค์ / รอสาย การสอบถามตามเวลาจริงยังคงเสร็จสมบูรณ์ใน HTTP ตอบสนอง |
| ทําต่อหลังจากจบโพรเซสการเรียก | ส่งข้อมูลพื้นหลังอีกครั้ง โดยบันทึกค่าระยะไกลไว้ IDจากนั้นก็อ่านสถานะและผล |
| ประมวลผลตามตาราง | ใช้สิทธิ์ของเจ้าของและใช้กับโปรแกรมที่ทนทาน เพื่อเรียกเก็บบันทึกการทํางานหรือ CLIมีบันทึกการทํางานอยู่แล้ว |

- [Async และกลุ่มงาน](https://flashdata.dev/th/docs/guides/async-batch/reference.md)
- [งานที่ทำซ้ำตามกำหนด](https://flashdata.dev/th/docs/guides/recurring-tasks/reference.md)
