दस्तावेज़ देखें
शुरू करें
लागत की जाँच करें, प्रत्येक प्रयास का रिकॉर्ड रखें और अन्य API कॉल के बिना सहेजे गए परिणामों को पढ़ें।
इस पेज पर
शुरू करने से पहले
परियोजना का उपयोग करें, अपने SDK क्विकस्टार्ट से SDK और FLASHDATA_API_KEY स्थापित करें। नीचे एक भाषा चुनें। प्रत्येक नई रन निर्देशिका एक इच्छित खोज का प्रतिनिधित्व करती है; किसी भी अनुरोध करने से पहले मौजूदा डायरेक्टरी स्टॉप का पुन: उपयोग करना।
1. पहुँच और वर्तमान लागत की जाँच करें
सहेजें और अपने SDK के लिए चेक चलाने के लिए। यह अनुमतियों, शेष राशि और एक Google Search की कीमत को पढ़ता है। जारी रखें कि एक्सेस चेक के बाद ही; इन चेकों को भुगतान की गई क्वेरी या आरक्षित क्रेडिट जमा करने की अनुमति नहीं है।
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).venv/bin/python check_access.py.\.venv\Scripts\python.exe check_access.pyimport { 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;
}node check-access.mjscmd/check बनाएं और इस फाइल को वहाँ से बचाएं।
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.")
}go run ./cmd/check2. एक नई आउटपुट डायरेक्टरी के साथ भागो
चेक पास होने के बाद इन कार्यक्रमों में से एक चलाएं। यह प्रस्तुत करने से पहले निर्देशिका बनाता है, अनुरोध रिकॉर्ड करता है, फिर जवाब बचाता है। निर्देशिका को विफलता पर रखें: इसे हटा दें या एक नया चयन करने से किसी अन्य बिलेबल क्वेरी की अनुमति मिलती है।
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).venv/bin/python archive_search.py runs/research-001.\.venv\Scripts\python.exe archive_search.py runs/research-001इस नोड ESM प्रोग्राम को JavaScript या TypeScript प्रोजेक्ट में सेव करें। यह flashdata-dev/sdk पैकेज के समान स्थापित किया गया है।
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;
}node archive-search.mjs runs/research-001cmd/archive बनाएं ताकि यह प्रवेश बिंदु आपके क्विकस्टार्ट प्रोग्राम से अलग रहे।
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
}go run ./cmd/archive runs/research-001अपेक्षित फाइलें
सफलता सहेजे गए परिणाम पथ और उपयोग को प्रिंट करती है। result.json में status: done होना चाहिए; Google परिणाम results[].organic[] में हैं। एक खाली कार्बनिक सरणी मान्य है। एक रिपोर्ट API या परिवहन त्रुटि error.json को बचाई जाती है; intent.json मूल पूर्व-submission रिकॉर्ड बनी हुई है।
runs/research-001/
request.json # स्रोत, क्वेरी और पैरामीटर
intent.json # Attempt start time
result.json # परिणाम और उपयोग सहित पूर्ण प्रतिक्रिया3. सहेजे गए आउटपुट को पढ़ें
पार्सिंग, सारांश और UI के लिए result.json पढ़ें। ये कमांड केवल स्थानीय फ़ाइलें इस्तेमाल करती हैं। उसी निर्देशिका में खोज दोबारा चलाने पर नेटवर्क कॉल से पहले ही प्रक्रिया रुक जाती है; यह अलग मशीनों के बीच समन्वय नहीं करती और खोया हुआ सर्वर जवाब वापस नहीं लाती।
cat runs/research-001/result.jsonGet-Content -Raw -LiteralPath './runs/research-001/result.json'cmd/read बनाएं और इस डिकोडर को वहाँ से बचाएं। यह एक ग्राहक के निर्माण या एक API अनुरोध बनाने के बिना फ़ाइल और प्रिंट स्रोत शीर्षक और URLs को पढ़ता है।
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)
}go run ./cmd/read runs/research-001/result.jsonक्या करना है एक विफलता के बाद
| आपके पास क्या है | अगली कार्रवाई |
|---|---|
| मौजूदा निर्देशिका / EEXIST | अपनी फ़ाइलों का निरीक्षण करना। इस प्रयास से कोई नया प्रश्न नहीं भेजा गया था। |
| result.json, status: done | पढ़ें और प्रक्रिया को बचाया प्रतिक्रिया। इसके उपयोग को मूल शुल्क की प्राप्ति के रूप में पुन: उपयोग करें। |
| 401 / 403 / 402 के साथ error.json | नए प्रयास की योजना बनाने से पहले पहुँच, स्रोत अनुमतियां या शेष राशि को ठीक करें। |
| 429 / retryAfter | अनुरोध दर को बनाए रखने और कम करने के रूप में प्रतीक्षा करें। एक नई रन डायरेक्टरी चुनने से पहले असफल प्रयास की समीक्षा करें। |
| अज्ञात प्रस्तुतीकरण / इरादे केवल / लिखने की विफलता | कार्य पहले से ही स्वीकार किया जा सकता है। निर्देशिका रखें और एक और क्वेरी भेजने से पहले History या ज्ञात नौकरी ID का निरीक्षण करें। |
Async क्लाइंट और पृष्ठभूमि नौकरियों
| आवश्यकता | उपयोग |
|---|---|
| एक घटना पाश उत्तरदायी रखें | SDK के ग्राहक / प्रतीक्षा कॉल। एक रियलटाइम क्वेरी अभी भी अपने HTTP प्रतिक्रिया में पूरा करती है। |
| कॉलिंग प्रक्रिया के निकास के बाद फिर से शुरू करें | एक बार पृष्ठभूमि नौकरी जमा करें, अपने दूरस्थ ID को बचाएं, फिर स्थिति और परिणाम पढ़ें। |
| एक अनुसूची पर भागो | मालिक पहुँच और टिकाऊ अनुप्रयोग रन रिकॉर्ड, या CLI के मौजूदा रन जर्नल का उपयोग करें। |