# FlashData vs Serper.dev: Google Search API comparison

Compare Serper.dev pack utilization with FlashData pricing, preserve your agent tool’s output, and build workflows with Google Search, YouTube captions and media delivery.

Serper.dev facts reviewed: 2026-11-10. FlashData rates and trial allowances use its current public catalogs.

- [Features](#features)
- [Why switch?](#overview)
- [Packs & spend](#costs)
- [Your existing tool](#compatibility)
- [Swap the call](#migration)
- [Beyond search](#workflows)
- [Agent rollout](#agents)
- [FAQ](#faq)

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

Keep familiar search fields, start with a smaller credit purchase, and add saved jobs or YouTube evidence when your workflow needs them.

### Start with a smaller commitment

| Feature | FlashData | Serper.dev |
| --- | --- | --- |
| Minimum credit purchase | $10 — $1.00 / 1,000 · pay as you go | $50.00 — $1.00 / 1,000 · Starter |
| New-account search allowance | Up to 2,000 searches — One-time signup allowance | 2,500 free queries — Signup offer |
| Agent trial before owner signup | Yes — Up to 50 Google searches · 72 hours | Sign up and use an account API key |

### Preserve your search tool’s behavior

| Feature | FlashData | Serper.dev |
| --- | --- | --- |
| Web, images, news, shopping, videos and places | Yes — Six Google sources | Yes — Corresponding Google endpoints |
| Country, language and local targeting | gl, hl and location — Inside params | gl, hl and location — Top-level request fields |
| Date filters for news and research | Yes — params.tbs · for example qdr:w | Yes — tbs · for example qdr:w |
| Next page and requested result count | params.page and params.num — Page number starts at 1 | page and num — Page number starts at 1 |
| Titles, source URLs and snippets | Organic result array — title, link, snippet and position | Organic result array — title, link, snippet and position |
| Questions, answers and entity context | Yes — People Also Ask, answer box and knowledge graph when returned | Yes — People Also Ask, answer box and knowledge graph when returned |

### Tools for agents and background work

| Feature | FlashData | Serper.dev |
| --- | --- | --- |
| Official standalone CLI | Yes — Linux, macOS and Windows · no runtime to install | Not listed — In the public product catalog |
| Markdown search results from the API | Yes — Choose JSON or Markdown content | JSON search results |
| Persisted async jobs you can resume by ID | Yes — Submit, save the ID, retrieve later | Not listed — Published search flow returns realtime results |
| Google queries in one JSON submission | 100 on pay as you go — Persisted Batch · up to 500 by plan | Up to 100 queries — Mini-batch returns responses together |
| Completion callbacks for background jobs | Yes — callback_url on each async or Batch query | Not listed — In the published search flow |
| Owner claim and credential handoff | Yes — Claim once; reuse the saved CLI profile | Configure an account API key |

### Continue from search into YouTube

| Feature | FlashData | Serper.dev |
| --- | --- | --- |
| Look up metadata by YouTube video ID | Yes — Dedicated YouTube Metadata API | Not listed — Google video search is available |
| Timestamped YouTube captions | Yes — Caption text and timing for video evidence | Not listed — In the public product catalog |
| YouTube video / audio delivery to your storage | Yes — YouTube Download API | Not listed — In the public product catalog |

The starting purchase uses FlashData pay as you go and Serper Starter. Larger Serper packs have lower unit rates; compare them in the calculator. The agent trial is separate from signup offers and subject to eligibility. Not listed refers to Serper’s public product catalog; community integrations may exist.

<a id="overview"></a>
## What would make switching worthwhile?

Move the part of your workload that needs to change. Google organic search can move independently of specialized search types.

### Your search volume is uneven

A low pack rate helps when you use the queries. Compare the upfront purchase and six-month usage with FlashData’s pay-as-you-go option.

[Check pack utilization](#costs)

### Your agent needs evidence from video

A Google video result gets you a URL. FlashData can continue with YouTube metadata, timestamped captions and delivery to your storage.

[See the complete tasks](#workflows)

### Your search tool is part of a larger system

Keep the agent’s tool input and citation format while moving the provider call. Add persisted jobs when work must resume after a process exits.

[Check your integration](#compatibility)

<a id="costs"></a>
## Unit price and upfront purchase

Serper packs are prepaid purchases, not subscriptions or monthly query refills. All listed packs have six-month credit validity. FlashData offers prepaid shared credits and optional monthly plans.

### 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 allowances assume the full shared balance goes to Google Search.

### Serper.dev prepaid packs

| Prepaid pack | Per 1,000 queries | Pack purchase | Queries per pack | Monthly fee | Queries / second |
| --- | --- | --- | --- | --- | --- |
| Starter | $1.00 | $50.00 | 50,000 | $0 | 50 |
| Standard | $0.75 | $375.00 | 500,000 | $0 | 100 |
| Scale | $0.50 | $1,250.00 | 2,500,000 | $0 | 200 |
| Ultimate | $0.30 | $3,750.00 | 12,500,000 | $0 | 300 |

### Example workload: FlashData pay as you go and Serper Starter

Select each provider independently. FlashData’s monthly cost is its monthly fee plus search usage above the included credit value. Included requests assume all shared credits go to Google Search. Lowest modeled monthly cost selects the FlashData plan with the smallest total at your volume. Effective monthly cost per 1,000 is that total divided by the entered monthly searches, multiplied by 1,000. Serper’s unit price is the pack purchase divided by its query count, multiplied by 1,000. Usage value shows credits consumed; it is not a monthly subscription charge. Starting with no Serper credits, the purchase estimate rounds up to whole packs at the selected rate; unused queries remain in the purchased packs, which expire after six months. The first-pack forecast assumes one pack bought now and the same monthly volume for six months: queries used = min(pack size, monthly volume × 6); effective cost per 1,000 = pack price ÷ queries used × 1,000. Later pack purchases are outside that forecast. At zero searches no pack purchase is needed and effective cost is undefined. FlashData self-service top-ups start at $10 and may leave a credit balance. Trial credits, existing balances, taxes and other API usage are excluded.

| Searches / month | FlashData modeled monthly cost | Serper usage value | Serper whole-pack purchase from zero | Queries left after month |
| --- | --- | --- | --- | --- |
| 1,000 | $1.00 | $1.00 | $50.00 | 49,000 |
| 10,000 | $10.00 | $10.00 | $50.00 | 40,000 |
| 100,000 | $100.00 | $100.00 | $100.00 | 0 |
| 1,000,000 | $1,000.00 | $1,000.00 | $1,000.00 | 0 |

These scenarios use Serper Starter’s rate. A lower rate from a larger pack requires that larger pack purchase. Use the HTML calculator to select each plan independently.

### Will you use a pack before it expires?

Assume one pack bought now and the same search volume every month for six months. Cap queries used at the size of that first pack; later pack purchases are outside this forecast. Divide the first pack’s price by its used queries to find the effective cost per 1,000.

| First pack | Searches / month | Pack purchase | Used within six months | Unused at expiry | Effective cost / 1,000 used |
| --- | --- | --- | --- | --- | --- |
| Starter | 1,000 | $50.00 | 6,000 | 44,000 | $8.33 |
| Standard | 1,000 | $375.00 | 6,000 | 494,000 | $62.50 |
| Starter | 10,000 | $50.00 | 50,000 | 0 | $1.00 |
| Standard | 10,000 | $375.00 | 60,000 | 440,000 | $6.25 |

At zero searches, no pack is needed and effective cost is undefined. If the first pack is fully used, its effective cost equals the advertised rate. For a FlashData monthly plan, calculate (monthly fee + usage above included credits) ÷ monthly searches × 1,000; a low advertised rate does not remove the subscription fee at low volume.

[FlashData pricing](https://flashdata.dev/pricing/google-search) · [Interactive comparison](https://flashdata.dev/compare/serper#costs)

### Signup trials

Eligible new FlashData accounts can try up to 2,000 Google searches after signup and email verification, using the full shared trial balance for search. No card required.
Serper offers 2,500 free trial queries, with no card required. This is not a recurring monthly allowance.

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

<a id="compatibility"></a>
## Keep the contract your agent already uses

A Serper integration may return a string, a dictionary or documents with links. Keep the tool name and input schema stable, and adapt FlashData’s response inside the tool.

| Existing integration | Current output | What to preserve |
| --- | --- | --- |
| LangChain · GoogleSerperAPIWrapper | results() returns a dictionary; run() combines selected snippets into a string. | Check which method your chain calls. Returning an array where the next step expects text changes the tool contract. |
| CrewAI · SerperDevTool | Accepts search_query and returns structured results, including optional blocks. | Keep search_query as the tool input. Map the fields your agent reads; replacing SERPER_API_KEY alone cannot switch providers. |
| Haystack · SerperDevWebSearch | Returns documents and links. Documents contain search snippets. | Preserve both outputs and source URLs. Retain the separate content-fetching component when your pipeline needs full pages. |

[Build the HTTP tool adapter](https://flashdata.dev/docs/guides/search-in-an-app/reference.md#tool)

### Which search types can move?

| Your existing task | Migration decision | FlashData source or next step |
| --- | --- | --- |
| Google web results | Migrate the organic-search call and normalize its output. | google_search |
| Images, News, Shopping, Videos, Places | Map each task to its dedicated source and parser. | google_images, google_news, google_shopping, google_videos, google_places |
| Scholar, Patents, Autocomplete | Keep these calls with your existing provider; FlashData has no direct equivalent in its current catalog. | No direct equivalent |
| Full text from a linked website | Retain your page-fetching and extraction step after search. | A search snippet is not the full article |

### Exact request and response mapping

| Change | Serper.dev | FlashData | Migration note |
| --- | --- | --- | --- |
| Search request | POST /search | POST /v1/queries/realtime | Use the FlashData data host and source=google_search. |
| API key | X-API-KEY header | X-API-Key header | Header casing is not the difference. Use a FlashData key with google_search permission. |
| Query | q | query | Rename the request field. |
| Country, language, count | gl, hl, num | params.gl, params.hl, params.num | Nest options under params; keep their values. |
| Location and time filter | location, tbs | params.location, params.tbs | Preserve the targeting used by your existing task. |
| Organic results | organic[] | results[0].organic[] | Read the FlashData response wrapper after status=done. |
| Source fields | title, link, snippet, position | title, link, snippet, position | Keep your application’s citation fields; normalize link to url if needed. |
| Related queries | relatedSearches[] | results[0].relatedSearches[] | Treat this as optional; consume each query field when present. |
| Related questions | peopleAlsoAsk[] | results[0].peopleAlsoAsk[] | A question can arrive without an answer, snippet or URL. Do not assume every object contains evidence. |
| Answer and entity blocks | answerBox, knowledgeGraph | No guaranteed one-to-one mapping | If your tool requires these blocks, keep that path until its required fields have a supported mapping. |
| News, Images or Places | A different endpoint such as /news | A dedicated source such as google_news | Select the source and use its own parameters and result schema. |

Map only the options and result blocks your task uses. An optional related question is not automatically an answered question with a source.

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

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

1. Sign up or sign in to FlashData, complete account setup and create an API key with google_search permission. Check available credits. An agent can reuse its saved access or use the eligible trial flow below.
2. Choose Python or Bash. Save the complete Python script under its displayed filename in your task folder before running it. Each block submits one search; running both versions queries both providers.
3. Inspect the normalized records. FlashData requires status=done before reading results[0].organic. Empty organic results can be valid. Keep title, URL, snippet and position for citations.

[Account setup](https://flashdata.dev/signup) · [API keys](https://flashdata.dev/app/api-keys) · [Available credits](https://flashdata.dev/app/billing)

### Python

Python 3, standard library only. Save the complete script under the filename shown in your task folder, then run it. It reads the environment variable or prompts privately for a key. Each script performs one search.

#### Serper.dev: serper-search.py

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

key = os.environ.get("SERPER_API_KEY")
if not key:
    key = getpass.getpass("Serper key: ")
payload = {"q": "openai", "gl": "us", "hl": "en", "num": 10}
request = Request("https://google.serper.dev/search",
    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 access and request input.") from None
except (URLError, TimeoutError):
    raise SystemExit("No response; check state before retrying.") from None
if body.get("error"):
    raise SystemExit("Search failed; inspect its error before retrying.")
items = body.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], ensure_ascii=False, indent=2))
```

Run after saving: `python3 serper-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 when the provider’s environment variable is missing, saves the raw response and prints normalized results. Each block submits one search.

#### Serper.dev: Serper.dev · Bash

```bash
if [ -z "${SERPER_API_KEY:-}" ]; then
  read -r -s -p "Serper key: " SERPER_API_KEY
  printf '\n'
fi
curl --fail-with-body --silent --show-error --max-time 120 \
  'https://google.serper.dev/search' \
  --header "X-API-KEY: $SERPER_API_KEY" \
  --header 'Content-Type: application/json' \
  --data '{"q":"openai","gl":"us","hl":"en","num":10}' \
  --output serper-result.json &&
jq 'if .error then error("Search failed; check the response") else
  [(.organic // [])[] | {position, title, url: .link, snippet}]
  end' serper-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; the examples rename link to url.

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

### Before changing your production tool

| Case | What to check |
| --- | --- |
| Representative searches | Use your existing country, language and location. Check required fields and usable citations; do not compare live rankings byte for byte. |
| Empty or partial results | An empty organic list is valid. Missing optional blocks must not become invented answers or uncited evidence. |
| Access and credit failures | Surface authentication, permission and balance errors. An error must not look like a successful search with no matches. |
| Rate limits or a lost response | Use bounded retries for an explicit rate limit. Inspect saved job state after a timeout; avoid launching a second provider automatically for an uncertain request. |

Start with one workflow. Keep the existing provider configuration available for a deliberate rollback; sending every request to both providers adds another billable search.

### Background work and recovery

An async Python wrapper handles waiting inside that process. For work that must survive a restart, submit a persisted FlashData async job, save its ID and retrieve that job later. Batch groups known queries; Bulk processes a file.

[Realtime and async](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="workflows"></a>
## What happens after your agent finds a link?

Google Search, YouTube Data and YouTube Download share one account balance, with separate rates and permissions.

### Build a research brief with video evidence

Start with: A company, product or research question.

1. Google Search: discover sources
2. YouTube Search: find relevant videos
3. Metadata + captions: collect timestamped evidence

Get: A brief with source links and video timestamps.

Keep web-page extraction for full articles. If a video has no captions, record that gap instead of treating the title as a transcript.

[Build the research workflow](https://flashdata.dev/docs/guides/google-youtube-research/reference.md)

### Deliver a selected video to your storage

Start with: A YouTube video selected by your application.

1. Metadata: confirm the selected video
2. Download: submit a delivery job
3. Storage: keep the delivered object details

Get: Video or audio in your configured storage, ready for the next job.

Use owner access with youtube_download permission. Temporary agent trial access does not include Download. Delivery uses its own byte-based pricing.

[Build the delivery pipeline](https://flashdata.dev/docs/guides/media-delivery-pipeline/reference.md)

### Enrich a file of known video IDs

Start with: An existing list of YouTube video IDs.

1. Prepare a text file with one video ID per line
2. Bulk: submit once and save the job ID
3. Results: retrieve the output and inspect failed items

Get: A dataset your application can join back to the original IDs.

Skip Google Search when you already know the IDs. Persist the job ID so a restarted process resumes the existing work.

[Process a file with Bulk](https://flashdata.dev/docs/guides/bulk/reference.md)

<a id="agents"></a>
## Move one tool before moving the whole agent

Reuse saved credentials first. Use CLI for terminal tasks or an MCP-capable host for tool calls. With no existing access, read auth.md and the permission catalog before starting one eligible temporary identity.

Current agent trial: 1 credit(s), up to 50 Google searches, 72 hours. This is a starting allowance subject to registration limits and eligibility.

### Migration prompt

```text
Read https://flashdata.dev/compare/serper/reference.md and https://flashdata.dev/auth.md.
Inspect my Serper tool, including its input, country/language filters, output type and consumed fields.
Report unsupported search types or required answer/entity blocks before changing the integration.
Migrate one supported Google organic-search task; retain specialized calls and existing credentials.
Preserve the tool name, input schema, text-or-record output and source URLs.
Reuse existing FlashData access; otherwise check eligibility before starting one trial.
Keep keys in the host secret store, outside chat and source control.
Check normal, empty, missing-optional-field and error responses with local fixtures.
Run one search for "openai" with gl=us, hl=en and num=10; save the result and usage.
Do not automatically call both providers or retry an uncertain submission.
Do not buy credits. For recurring use, ask the owner to claim and approve access.
Reuse the same profile and state directory. Stop on revocation or insufficient credits.
```

### CLI: existing default profile

Complete [CLI installation and authentication](https://flashdata.dev/docs/guides/flashdata-cli/reference.md) first. These commands check access, validate the request and submit 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 serper-migration-first --json --non-interactive
```

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

For recurring tasks, keep the saved owner credential and persistent state directory. Use one run ID per scheduled occurrence and the same ID when recovering that occurrence. The CLI can reuse a completed result only while its saved state remains available. An HTTP tool needs its own persisted state; the CLI run ID is not an API idempotency header. Stop on revoked access or insufficient credits. Do not register replacement trials or buy credits automatically.

[Agent access](https://flashdata.dev/auth.md) · [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="faq"></a>
## FAQ

### I already bought a Serper pack. Do I have to move everything?

No. Move one supported task first and retain other calls while you use your existing pack. Serper credits do not transfer to FlashData. Keep separate provider credentials and route each task deliberately.

### Which price should I compare: the pack rate or the cost of queries I use?

Use both. The pack rate assumes you consume the whole pack; the utilization forecast shows what happens if you do not. For a FlashData subscription, compare the monthly fee and included usage at your actual volume, not just its lower unit rate.

### Will changing SERPER_API_KEY switch my existing agent tool?

No. A Serper-specific tool still calls Serper’s endpoint and parses its response. Replace the provider call, use a FlashData key, and adapt the response to the same tool output. An MCP connection is a separate integration choice, not a replacement value for that environment variable.

### Will every result and rich search block be identical?

Live results can differ in order and content. Migrate the fields your application actually consumes. Organic title, URL, snippet and position have a clear mapping; optional answers and entity blocks need their own mapping before you switch that path.

### Does an async Python method give me a resumable job?

An async client method lets your process do other work while waiting for a response. A persisted FlashData async job has a job ID you can save and retrieve later. Use the latter when work must survive a process restart, and keep that ID before scheduling another submission.

### Does one balance mean the same price for search, captions and downloads?

No. Products share credits but have separate rates, billing units and permissions. A Google search is billed as a search request; media delivery uses byte-based pricing. Approve the required owner permissions before adding a new product to a recurring workflow.

### When is keeping Serper the simpler choice?

When your existing tool already does the whole job, you use your prepaid pack within its validity, or you rely on Scholar, Patents, Autocomplete or provider-specific fields without a FlashData equivalent. You can keep those calls and use FlashData for the additional workflows you need.

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