# SDK से खाते की जाँच और सहेजे गए परिणाम

लागत की जाँच करें, प्रत्येक प्रयास का रिकॉर्ड रखें और अन्य API कॉल के बिना सहेजे गए परिणामों को पढ़ें।

कैनोनिकल संदर्भ: https://flashdata.dev/hi/docs/guides/sdk-operations
समीक्षित: 2026-11-04 द्वारा FlashData

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

## शुरू करने से पहले

परियोजना का उपयोग करें, अपने SDK क्विकस्टार्ट से SDK और FLASHDATA_API_KEY स्थापित करें। नीचे एक भाषा चुनें। प्रत्येक नई रन निर्देशिका एक इच्छित खोज का प्रतिनिधित्व करती है; किसी भी अनुरोध करने से पहले मौजूदा डायरेक्टरी स्टॉप का पुन: उपयोग करना।

- [Go SDK सेटअप](https://flashdata.dev/hi/docs/guides/flashdata-go/reference.md)
- [Python SDK सेटअप](https://flashdata.dev/hi/docs/guides/flashdata-python/reference.md)
- [TypeScript SDK सेटअप](https://flashdata.dev/hi/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 मूल पूर्व-submission रिकॉर्ड बनी हुई है।

#### सफल प्रयास

```text
runs/research-001/
  request.json # स्रोत, क्वेरी और पैरामीटर
  intent.json # Attempt start time
  result.json # परिणाम और उपयोग सहित पूर्ण प्रतिक्रिया
```


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

## 3. सहेजे गए आउटपुट को पढ़ें

पार्सिंग, सारांश और UI के लिए result.json पढ़ें। ये कमांड केवल स्थानीय फ़ाइलें इस्तेमाल करती हैं। उसी निर्देशिका में खोज दोबारा चलाने पर नेटवर्क कॉल से पहले ही प्रक्रिया रुक जाती है; यह अलग मशीनों के बीच समन्वय नहीं करती और खोया हुआ सर्वर जवाब वापस नहीं लाती।

### Bash

#### स्थानीय रूप से पढ़ें

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


### PowerShell

#### स्थानीय रूप से पढ़ें

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


### Go: टाइप किए गए परिणाम

cmd/read बनाएं और इस डिकोडर को वहाँ से बचाएं। यह एक ग्राहक के निर्माण या एक API अनुरोध बनाने के बिना फ़ाइल और प्रिंट स्रोत शीर्षक और URLs को पढ़ता है।

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


- [Parse Google Search परिणाम](https://flashdata.dev/hi/docs/sources/google_search/reference.md)
- [साझा परिणाम स्वरूप](https://flashdata.dev/hi/docs/guides/response-formats/reference.md)

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

## क्या करना है एक विफलता के बाद

| आपके पास क्या है | अगली कार्रवाई |
| --- | --- |
| मौजूदा निर्देशिका / EEXIST | अपनी फ़ाइलों का निरीक्षण करना। इस प्रयास से कोई नया प्रश्न नहीं भेजा गया था। |
| result.json, status: done | पढ़ें और प्रक्रिया को बचाया प्रतिक्रिया। इसके उपयोग को मूल शुल्क की प्राप्ति के रूप में पुन: उपयोग करें। |
| 401 / 403 / 402 के साथ error.json | नए प्रयास की योजना बनाने से पहले पहुँच, स्रोत अनुमतियां या शेष राशि को ठीक करें। |
| 429 / retryAfter | अनुरोध दर को बनाए रखने और कम करने के रूप में प्रतीक्षा करें। एक नई रन डायरेक्टरी चुनने से पहले असफल प्रयास की समीक्षा करें। |
| अज्ञात प्रस्तुतीकरण / इरादे केवल / लिखने की विफलता | कार्य पहले से ही स्वीकार किया जा सकता है। निर्देशिका रखें और एक और क्वेरी भेजने से पहले History या ज्ञात नौकरी ID का निरीक्षण करें। |

- [अनुरोध इतिहास](https://flashdata.dev/app/jobs)
- [वसूली निर्णय](https://flashdata.dev/hi/docs/guides/agent-recovery/reference.md)

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

## Async क्लाइंट और पृष्ठभूमि नौकरियों

| आवश्यकता | उपयोग |
| --- | --- |
| एक घटना पाश उत्तरदायी रखें | SDK के ग्राहक / प्रतीक्षा कॉल। एक रियलटाइम क्वेरी अभी भी अपने HTTP प्रतिक्रिया में पूरा करती है। |
| कॉलिंग प्रक्रिया के निकास के बाद फिर से शुरू करें | एक बार पृष्ठभूमि नौकरी जमा करें, अपने दूरस्थ ID को बचाएं, फिर स्थिति और परिणाम पढ़ें। |
| एक अनुसूची पर भागो | मालिक पहुँच और टिकाऊ अनुप्रयोग रन रिकॉर्ड, या CLI के मौजूदा रन जर्नल का उपयोग करें। |

- [Async और बैच वर्कफ़्लो](https://flashdata.dev/hi/docs/guides/async-batch/reference.md)
- [नियमित काम](https://flashdata.dev/hi/docs/guides/recurring-tasks/reference.md)
