# FlashData vs SerpApi

Compare Google Search costs, coverage and API behavior. Migrate a SerpApi search with runnable Python and cURL examples, or connect an AI agent to FlashData.

SerpApi facts reviewed: 2026-11-10. FlashData rates and agent-trial amounts come from the current public catalogs.

- [Features](#overview)
- [Compare costs](#costs)
- [Migrate a search](#migration)
- [For AI agents](#agents)
- [Choose your fit](#fit)
- [FAQ](#faq)

<a id="overview"></a>
## Feature-by-feature comparison

Compare the cost to start, the search fields your app needs, and how an agent submits and retrieves work.

### Lower cost to start

| Feature | FlashData | SerpAPI |
| --- | --- | --- |
| Google Search · entry paid price per 1,000 | $1.00 — Pay as you go | $25.00 — Starter · full monthly allowance |
| Starting paid commitment | $10 — Credit top-up · no monthly fee | $25.00/mo — 1,000 searches included |
| Initial free Google Search allowance | Up to 2,000 searches — One-time signup allowance | 250 searches / month — Recurring Free plan |

### Search coverage and usable evidence

| Feature | FlashData | SerpAPI |
| --- | --- | --- |
| Web, images, news, shopping, videos and places | Yes — Six Google sources | Yes — Google engines and search types |
| Country, language and local targeting | gl, hl and location — Settings in params | gl, hl and location — Also supports encoded uule targeting |
| Date filters for current research | Yes — tbs · past day, week or other supported filters | Yes — tbs · Google time filters |
| Retrieve the next result page | Page number — params.page · one page per query | Result offset — start · 0, 10, 20 for ten-result pages |
| Titles, source URLs and snippets | Organic result array — title, link, snippet and position | Organic result array — title, link, snippet and position |
| Related questions and rich results | Yes — People Also Ask, related searches, answer box and knowledge graph when returned | Yes — Related questions, related searches, answer box and knowledge graph when returned |
| Choose a device for rank tracking | No published device selector — Organic position in the returned search | Desktop, tablet or mobile — Select device in the request |

### Batch work and saved results

| Feature | FlashData | SerpAPI |
| --- | --- | --- |
| Realtime and persisted async searches | Yes — Receive results now, or save a job ID and retrieve later | Yes — async=true, then Search Archive retrieval |
| Queries in one JSON Batch submission | 100 on pay as you go — Up to 500 by plan | One search per request — Submit multiple requests from your client |
| Markdown for agent context | Yes — API response option and CLI output | Yes — CLI Markdown output |
| Saved search result availability | 24 hours after completion — Async result JSON; save a durable copy | 31 days — Search Archive |

### Agent access and connected workflows

| Feature | FlashData | SerpAPI |
| --- | --- | --- |
| Try your own agent task before owner signup | Yes — Up to 50 Google searches · 72 hours | Preset CLI demo queries — An account key is needed for custom searches |
| Hosted MCP authentication | OAuth or API key — Sign in and approve the connection | API key — Configure the key in your client |
| Standalone CLI · no runtime to install | Yes — Linux, macOS and Windows | Yes — Native CLI executables |
| Owner claim and credential handoff | Yes — Approve access; keep the same CLI profile | Configure an account API key |
| YouTube video / audio delivery to your storage | Yes — YouTube Download API | Not listed — In the API catalog |

The entry unit price compares FlashData pay as you go with SerpApi Starter at its full monthly allowance; other plans have different rates. FlashData signup and agent trials are separate, subject to eligibility. Signup counts use the full trial balance for search. Not listed refers to the published API catalog.

<a id="costs"></a>
## Compare costs

FlashData pay as you go: $1.00 per 1,000 billable Google searches, with no monthly fee.

### FlashData Google Search plans

| Plan | Per 1,000 requests | Monthly fee | Included credits | Google Search requests |
| --- | --- | --- | --- | --- |
| Pay As You Go | $1.00 | $0 · no monthly fee | None | Top up as needed |
| Micro | $0.80 | $49.00 | 1,000 ($50.00 of usage) | ≈ 62,500 |
| Starter | $0.65 | $199.00 | 4,000 ($200.00 of usage) | ≈ 307,692 |
| Pro | $0.60 | $499.00 | 10,000 ($500.00 of usage) | ≈ 833,333 |
| Scale | $0.50 | $999.00 | 20,000 ($1,000.00 of usage) | ≈ 2,000,000 |
| Business | $0.40 | $1,999.00 | 40,000 ($2,000.00 of usage) | ≈ 5,000,000 |

Included credits renew each billing period. Request counts assume all included credits go to Google Search; Google Search, YouTube Data and downloads share the same balance.

### Estimate your monthly bill

Choose a plan independently for each provider. FlashData’s unit price is the selected plan’s usage rate; included requests assume all shared credits go to Google Search. SerpApi’s unit price is the monthly plan price divided by its full search allowance, multiplied by 1,000. Auto-select chooses the smallest listed monthly Best Effort plan covering the volume, including Free. A manually selected SerpApi plan stays selected if its allowance is too small; the calculator shows the shortfall instead of a workload bill or effective rate. Effective cost per 1,000 searches is the monthly bill divided by your entered volume, multiplied by 1,000; it is not calculated at zero searches. FlashData: monthly fee plus usage above included credits; pay as you go has no monthly fee. Self-service credit top-ups start at $10. Purchases are prepaid and can exceed the modeled usage, leaving a balance for later. No trial credits, tax, annual discounts, speed add-ons, early renewals, custom contracts or other API usage are included. Concurrency and hourly throughput are different limits.

| Monthly billable queries | FlashData pay as you go | FlashData lowest modeled cost | SerpApi monthly plan |
| --- | --- | --- | --- |
| 250 | $0.25 | $0.25 (Pay As You Go) | $0.00 (Free) |
| 1,000 | $1.00 | $1.00 (Pay As You Go) | $25.00 (Starter) |
| 10,000 | $10.00 | $10.00 (Pay As You Go) | $150.00 (Production) |
| 100,000 | $100.00 | $79.00 (Micro) | $725.00 (Searcher) |
| 1,000,000 | $1,000.00 | $599.00 (Pro) | $3,750.00 (Cloud 1M) |

### SerpApi plan inputs

| Plan | Per 1,000 searches at full allowance | Monthly searches | Monthly price | Searches / hour |
| --- | --- | --- | --- | --- |
| Free | Free | 250 | $0.00 | 50 |
| Starter | $25.00 | 1000 | $25.00 | 200 |
| Developer | $15.00 | 5000 | $75.00 | 1000 |
| Production | $10.00 | 15000 | $150.00 | 3000 |
| Big Data | $9.17 | 30000 | $275.00 | 6000 |
| Searcher | $7.25 | 100000 | $725.00 | 20000 |
| Volume | $5.90 | 250000 | $1,475.00 | 50000 |
| Infrastructure | $5.50 | 500000 | $2,750.00 | 100000 |
| Cloud 1M | $3.75 | 1000000 | $3,750.00 | 110000 |

[FlashData pricing](https://flashdata.dev/pricing/google-search)

### Free access

Eligible new FlashData accounts can try up to 2,000 Google searches after signup and email verification, using the full shared signup trial balance for search. No card required. This is a signup allowance.
SerpApi Free includes 250 searches per month with a 50-per-hour limit. The calculator includes this recurring plan. FlashData's separate temporary agent trial appears below.

[FlashData signup trial details](https://flashdata.dev/products/google-search#trial-faq)

<a id="migration"></a>
## Migrate a search

1. Create or sign in to a FlashData account, complete the account setup, and create an API key with google_search permission. Check available credits. Keep credentials in the server environment or secret store. An eligible agent can use the access flow below.
2. Choose Python or Bash below. Run the complete example in a task folder. Each example makes one request and maps title, link, snippet and position to a common application output. Running both versions submits one query to each provider.
3. Inspect completion status and save the original response. Empty organic results can be a successful, billable search.

[Create an account](https://flashdata.dev/signup) · [API keys](https://flashdata.dev/app/api-keys) · [Billing](https://flashdata.dev/app/billing)

### Python

Python 3, standard library only. Save either complete example in your task folder using the filename shown, then run it. Each script reads its environment variable or prompts privately for a key, performs one search and prints normalized results.

#### SerpApi: serpapi-search.py

```python
import getpass, json, os
from urllib.parse import urlencode
from urllib.request import Request, urlopen
from urllib.error import HTTPError, URLError

key = os.environ.get("SERPAPI_API_KEY")
if not key:
    key = getpass.getpass("SerpApi key: ")
params = {"engine": "google", "q": "openai",
          "gl": "us", "hl": "en", "api_key": key}
request = Request("https://serpapi.com/search.json?" + urlencode(params))
try:
    with urlopen(request, timeout=120) as response:
        body = json.load(response)
except HTTPError as error:
    raise SystemExit(f"HTTP {error.code}: check input and access.") from None
except (URLError, TimeoutError):
    raise SystemExit("No response; check state before retrying.") from None
if body.get("search_metadata", {}).get("status") != "Success":
    raise SystemExit("Search is not successful; check its status.")
items = body.get("organic_results", [])
print(json.dumps([
    {"position": item.get("position"), "title": item.get("title"),
     "url": item.get("link"), "snippet": item.get("snippet")}
    for item in items
], indent=2, ensure_ascii=False))
```

Run after saving: `python3 serpapi-search.py`

#### FlashData: flashdata-search.py

```python
import getpass, json, os
from urllib.request import Request, urlopen
from urllib.error import HTTPError, URLError

key = os.environ.get("FLASHDATA_API_KEY")
if not key:
    key = getpass.getpass("FlashData key: ")
payload = {"source": "google_search", "query": "openai",
           "params": {"gl": "us", "hl": "en", "num": 10}}
request = Request("https://data.flashdata.dev/v1/queries/realtime",
    data=json.dumps(payload).encode(),
    headers={"X-API-Key": key, "Content-Type": "application/json"})
try:
    with urlopen(request, timeout=120) as response:
        body = json.load(response)
except HTTPError as error:
    raise SystemExit(f"HTTP {error.code}: check input and access.") from None
except (URLError, TimeoutError):
    raise SystemExit("No response; check state before retrying.") from None
if body.get("status") != "done":
    raise SystemExit("Search is not complete; check its status.")
items = (body.get("results") or [{}])[0].get("organic", [])
print(json.dumps([
    {"position": item.get("position"), "title": item.get("title"),
     "url": item.get("link"), "snippet": item.get("snippet")}
    for item in items
], indent=2, ensure_ascii=False))
```

Run after saving: `python3 flashdata-search.py`

### cURL / Bash

Bash, cURL 7.76+ and jq. Run either complete block in your task folder. It prompts only if that provider’s environment variable is missing, saves the original response, and prints the same four application fields. Each block submits one search.

#### SerpApi: SerpApi · Bash

```bash
if [ -z "${SERPAPI_API_KEY:-}" ]; then
  read -r -s -p "SerpApi key: " SERPAPI_API_KEY
  printf '\n'
fi
curl --fail-with-body --silent --show-error --max-time 120 \
  --get 'https://serpapi.com/search.json' \
  --data-urlencode "api_key=$SERPAPI_API_KEY" \
  --data-urlencode 'engine=google' --data-urlencode 'q=openai' \
  --data-urlencode 'gl=us' --data-urlencode 'hl=en' \
  --output serpapi-result.json &&
jq 'if .search_metadata.status == "Success" then
  [(.organic_results // [])[] | {position, title, url: .link, snippet}]
  else error("Search not successful; check status before retrying") end' serpapi-result.json
```

#### FlashData: FlashData · Bash

```bash
if [ -z "${FLASHDATA_API_KEY:-}" ]; then
  read -r -s -p "FlashData key: " FLASHDATA_API_KEY
  printf '\n'
fi
curl --fail-with-body --silent --show-error --max-time 120 \
  'https://data.flashdata.dev/v1/queries/realtime' \
  --header "X-API-Key: $FLASHDATA_API_KEY" \
  --header 'Content-Type: application/json' \
  --data '{"source":"google_search","query":"openai",
           "params":{"gl":"us","hl":"en","num":10}}' \
  --output flashdata-result.json &&
jq 'if .status == "done" then
  [(.results[0].organic // [])[] | {position, title, url: .link, snippet}]
  else error("Search not complete; check status before retrying") end' flashdata-result.json
```

### Normalized output shape

Illustrative output; titles, order and snippets vary. The examples rename link to url.

```json
[
  {
    "position": 1,
    "title": "OpenAI | Research & Deployment",
    "url": "https://openai.com/",
    "snippet": "..."
  }
]
```

### Request and response mapping

| Change | SerpApi | FlashData | Migration note |
| --- | --- | --- | --- |
| HTTP request | GET /search.json | POST /v1/queries/realtime | Send a JSON body to data.flashdata.dev. |
| Authentication | api_key | X-API-Key header | Create a FlashData key with google_search permission. |
| Search | engine=google · q | source: google_search · query | Keep your search expression, such as site:example.com. |
| Country and language | gl · hl | params.gl · params.hl | Set both explicitly for your target market. |
| Location and dates | location · tbs | params.location · params.tbs | Supported inputs; location labels and filter behavior must suit your query. |
| Pagination | start=0, 10, 20… | params.page=1, 2, 3… | Use page numbering. Request num=10 for this ten-result-page example; bill each page separately. |
| Organic results | organic_results[] | results[0].organic[] | title, link, snippet and position remain useful application fields. |
| Related results | related_questions · related_searches | results[0].peopleAlsoAsk · results[0].relatedSearches | Map fields explicitly; optional sections can be absent. |

FlashData’s Google Search schema does not accept SerpApi’s uule, device, google_domain, safe, udm or no_cache. Use a dedicated FlashData source for a different search type. Do not silently drop required parameters or forward the entire SerpApi parameter object.

[FlashData Google Search contract](https://flashdata.dev/docs/sources/google_search/reference.md)

### Async jobs, retries and saved results

| Behavior | SerpApi | FlashData | What to change |
| --- | --- | --- | --- |
| Completion | search_metadata.status: Success | status: done | Read HTTP status and the body status. An empty result list can still be a completed, billable search. |
| Async retrieval | async=true → search_metadata.id → Search Archive | POST /v1/queries → id → /v2/jobs/{id} | Save the job ID immediately. Retrieve the finished output through the job result endpoint. |
| Result retention | Archive: up to 31 days after completion | Async result JSON: 24 hours after completion | Export FlashData results to your own storage before expiry. |
| Repeated work | Exact-parameter cache: 1 hour; no_cache controls it | CLI run ID reuses completed local results | These are different mechanisms. Keep the CLI profile, input, account and state directory; use a new run ID for fresh data. |
| Quota or capacity errors | 429 can mean hourly throughput or exhausted searches | Inspect the structured error code and account balance/limits | Do not retry all 429s blindly. Back off for capacity; resolve exhausted credits or revoked access. |

FlashData job reads: https://api.flashdata.dev/v2/jobs/{id}; result retrieval: /v2/jobs/{id}/results. Follow the result redirect without forwarding X-API-Key to storage. Save result JSON within 24 hours after completion.

[Async request and recovery examples](https://flashdata.dev/docs/reference/realtime-and-async/reference.md) · [Batch and Bulk](https://flashdata.dev/docs/reference/batch-and-bulk/reference.md) · [Errors](https://flashdata.dev/docs/errors/reference.md)

<a id="agents"></a>
## For AI agents

Both providers offer MCP and CLI tools. FlashData supports an eligible temporary trial followed by owner claiming. Reuse existing access first. Request only needed sources; check trial eligibility in the permission catalog.

Current agent trial: 1 credits, up to 50 Google searches, 72 hours. This is the full starting allowance; registration and eligibility limits apply.

### Copy the migration task

```text
Read https://flashdata.dev/compare/serpapi/reference.md and https://flashdata.dev/auth.md.
Migrate only my Google organic-search task. Inspect the existing SerpApi parameters
and consumed response fields first; report unsupported requirements before changing them.
Reuse existing FlashData access. If none exists, check eligibility before starting one trial.
Keep credentials in the host secret store, outside chat and source control.
Run one search for "openai" with gl=us and hl=en. Return title, URL, snippet and position.
Save the raw result and report the actual credit usage. Do not purchase credits.
For recurring use, ask the owner to claim access and approve permissions and shared-balance use.
Keep the same profile and state directory. Stop on revoked access or insufficient credits.
```

### CLI: existing default profile

Install and authenticate the [CLI](https://flashdata.dev/docs/guides/flashdata-cli/reference.md) first. Check access, validate the request, then run one search:

```bash
flashdata auth status --json --non-interactive &&
flashdata search "openai" --gl us --hl en --num 10 \
  --dry-run --json --non-interactive &&
flashdata search "openai" --gl us --hl en --num 10 \
  --run-id serpapi-migration-first --json --non-interactive
```

For claiming, the human signs in or signs up, verifies email and approves source permissions and shared-balance use. Keep the original profile for credential handoff. Unused temporary credits do not transfer; owner usage uses the owner balance. Approval does not purchase credits or create a per-key spending cap.

For recurring tasks, reuse owner credentials and the same persistent CLI state directory. Use one run ID per scheduled occurrence and the same ID to recover that occurrence. Completed runs reuse saved output. Stop on revoked access, exhausted credits or an uncertain result. Do not create replacement trials or purchase credits automatically.

[Agent access](https://flashdata.dev/auth.md) · [Trial and claiming](https://flashdata.dev/docs/guides/agent-onboarding/reference.md) · [Codex](https://flashdata.dev/docs/integrations/codex/reference.md) · [OpenClaw](https://flashdata.dev/docs/integrations/openclaw/reference.md) · [Recurring tasks](https://flashdata.dev/docs/guides/recurring-tasks/reference.md)

<a id="fit"></a>
## Choose your fit

### Choose FlashData when

- You need structured Google results for an application, research workflow or scheduled agent task, with pay-as-you-go billing.
- Your workflow continues into YouTube metadata, captions or delivery of media to your own storage.
- You want an agent to try a task, let its owner claim access, and keep using the same saved profile for recurring work.

### Keep SerpApi when

- You need Bing, Amazon, Google Flights, Google Maps reviews or another engine outside FlashData’s source catalog.
- Your application depends on SerpApi-specific SERP sections, raw HTML, uule, device targeting or dedicated AI Overview / AI Mode endpoints.
- You want SerpApi’s recurring free allowance or its longer search archive, and those match your workload.

You can use both through provider adapters. FlashData returns search results; it does not fetch the full text of every linked page.

<a id="faq"></a>
## FAQ

### Can I just change the SerpApi base URL?

No. Change the method, authentication, request body and response reader. FlashData SDKs and MCP tools also have their own schemas. The example above keeps the application output consistent while changing the provider call.

### Does one search mean one returned result?

No. A search is a query request, not each organic item. Pagination adds requests, and every query in a FlashData Batch is metered separately. The calculator uses billable queries, not result rows or video-download bytes.

### Can I replace every SerpApi engine?

Use FlashData’s source catalog to choose the matching task. Google web search is google_search; images and news use other sources. Specialized SerpApi engines and fields do not automatically map. You can keep those calls on SerpApi and migrate only the tasks FlashData covers.

### Do failed or empty searches cost credits?

FlashData does not charge requests marked failed; deductions for failed requests are returned. SerpApi excludes failed and cached searches from its allowance. An empty search can still be successful on either service. A lost response is not proof of failure: recover the saved job or CLI run before submitting again.

### Will my agent’s free credits renew every month?

The FlashData temporary trial is an eligible agent’s starting allowance with an expiry, not a recurring grant. After claiming, requests use the owner’s normal balance. Unused temporary credits do not transfer; normal signup offers are handled independently. SerpApi’s Free plan is a monthly allowance.

### Can I use FlashData without moving the rest of my application?

Yes. Put the FlashData call behind your existing search function, normalize the result fields, and keep provider-specific features separate. Start with one Google Search workflow. Existing SerpApi requests, keys and billing stay with SerpApi.

[HTML comparison](https://flashdata.dev/compare/serpapi)
