# Oxylabs Alternative for Google Search

Pay for the searches you need. Subscribe when it makes sense.

Build a Google Search feature or a recurring research task without starting a monthly subscription. Compare Google-specific pricing and migrate the request your app actually uses.

Oxylabs facts reviewed 2026-11-10. FlashData rates and trial allowances use current public catalogs.

This page compares Google Search. [Oxylabs Alternative for YouTube Data](https://flashdata.dev/compare/oxylabs-youtube/reference.md) covers metadata and captions separately.

- [Features](#features)
- [Compare costs](#costs)
- [Migrate a search](#migration)
- [Production workflow](#workflow)
- [For AI agents](#agents)
- [FAQ](#faq)

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

A better fit for intermittent search workloads, small applications and agents getting through their first task.

### Start small and avoid a recurring commitment

| Feature | FlashData | Oxylabs |
| --- | --- | --- |
| Paid search without a subscription | Yes — Pay-as-you-go credits | Active subscription required — For a paid shared balance |
| Starting paid commitment | $10 credit purchase — $1.00 / 1,000 · $0 monthly fee | $15.00 / month — Starter · $1.00 / 1,000 non-JS Google |
| Starting plan with a lower Google rate | $49.00 / month — Micro · $0.80 / 1,000 | $100.00 / month — Basic · $0.90 / 1,000 non-JS Google |

### Get an app or agent to its first result

| Feature | FlashData | Oxylabs |
| --- | --- | --- |
| Agent trial before owner signup | Yes — Up to 50 Google searches · 72 hours | Account API key first — Published agent setup asks for a Web API key |
| Separate product instance to configure | None — Use a key with google_search permission | Web API instance — Create the instance and generate its key |
| Parsed JSON by default | Yes — Structured Google Search results | Select output: [json] — Dedicated Google scraper defaults to HTML |

### Search controls and result formats

| Feature | FlashData | Oxylabs |
| --- | --- | --- |
| Country and language targeting | gl and hl — Country and interface language; location for local targeting | domain, locale and location — National index, UI language and request origin are separate |
| Date filters for current research | Yes — params.tbs · Google time filters | Yes — tbs · forwarded to Google |
| Collect consecutive result pages | One page per query — page + num; Batch multiple queries | start_page + pages — Each fetched page is charged |
| Structured source records for citations | Organic result array — Titles, source URLs and snippets | Parsed JSON — Select JSON output; read the job result |
| Device-specific search results | No published device selector | Desktop or mobile — device parameter |
| Output for apps and agents | JSON, text or Markdown content | JSON, Markdown, HTML or screenshot — Screenshot requires run_js |
| Custom extraction schema or prompt | Published source schema — Transform the response in your application | Yes — Custom JSON extraction can replace the built-in parser |

### Background work and recurring agents

| Feature | FlashData | Oxylabs |
| --- | --- | --- |
| Realtime and persisted async searches | Yes — Save a job ID and retrieve the result | Yes — Sync or async delivery modes |
| Queries per batch submission | 100 on pay as you go — Up to 500 by plan · per-query settings | Up to 5,000 inputs — Query array with shared settings |
| Completion callbacks | Yes — callback_url on each async or Batch query | Yes — callback_url on an async job |
| MCP and agent skills | Yes — Hosted MCP and installable skills | Yes — Web API agent integrations |
| Owner claim and credential handoff | Yes — Claim once; reuse the saved CLI profile | Configure a Web API instance key |

The comparison uses Oxylabs’ current Web API subscription catalog and its Google-specific rates. The generic /Scrape starting price is not the Google Search price. Both services have structured output and background jobs.

### Pay as you go for uneven workloads

FlashData lets you buy credits without a monthly commitment. That suits occasional research, a new app feature or a scheduled task that only runs a few times a week.

[Calculate your search volume](https://flashdata.dev/compare/oxylabs/reference.md#costs)

### Get a search-specific price

Compare Google requests directly. Keep Oxylabs /Search, Google /Scrape and JavaScript-rendered Google pricing separate so the estimate matches your workload.

[Choose the Google mode](https://flashdata.dev/compare/oxylabs/reference.md#costs)

### Let the first task precede signup

An eligible FlashData agent can obtain limited temporary access, return a useful result and then ask the owner to claim it for continued use.

[See the agent flow](https://flashdata.dev/compare/oxylabs/reference.md#agents)

<a id="costs"></a>
## Price the Google endpoint you are using.

For full Google SERPs, compare the dedicated Google scraper’s non-JS or JS rate. Select your plans below; included requests use the whole monthly balance for that Google mode.

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

### Oxylabs · Google non-JS

| Plan | Per 1,000 requests | Monthly fee | Included requests |
| --- | --- | --- | --- |
| Starter | $1.00 | $15.00 | 15,000 |
| Basic | $0.90 | $100.00 | 111,111 |
| Flexible | $0.70 | $500.00 | 714,285 |

### Oxylabs · Google JS

| Plan | Per 1,000 requests | Monthly fee | Included requests |
| --- | --- | --- | --- |
| Starter | $1.35 | $15.00 | 11,111 |
| Basic | $1.30 | $100.00 | 76,923 |
| Flexible | $1.15 | $500.00 | 434,782 |

Oxylabs Starter is $15/month, Basic $100/month and Flexible $500/month in the current Web API catalog. Non-JS Google rates are $1.00, $0.90 and $0.70 per 1,000; JS rates are $1.35, $1.30 and $1.15. These are not the generic /Scrape starting rates or the separate /Search endpoint. Enterprise pricing and legacy Web Scraper API contracts are outside this estimate. FlashData does not expose a run_js or screenshot option.

USD, one Google result page per request. Select plans independently. FlashData uses the current catalog: plan fee plus usage beyond included credits. Pay-as-you-go credit purchases start at $10 and may leave funds for later. Bright Data Scale uses its included request allowance plus the listed additional-request rate. Its Free tier is capped; no paid price is inferred above the cap. Oxylabs uses the monthly subscription balance first, then shows the extra credit funding needed for this workload; service pauses until that funding is added, rather than automatically billing an overage. Included requests assume the full shared balance or pool goes to Google. Paid scenarios exclude free offers, taxes, promotions, other products and negotiated contracts. Effective cost divides the modeled cost by the entered volume; it is undefined at zero requests.

### Example workloads · FlashData pay as you go / Oxylabs Starter

Google non-JS; Oxylabs amounts include the funding needed above the monthly balance.

| Requests / month | FlashData | Oxylabs |
| --- | --- | --- |
| 1,000 | $1.00 | $15.00 |
| 10,000 | $10.00 | $15.00 |
| 100,000 | $100.00 | $100.00 |

### Trying before you pay

Eligible FlashData signup: up to 2,000 Google searches after email verification when the full trial balance is used for search.

Oxylabs offers a one-time $5 welcome balance shared across products. FlashData’s agent trial is a separate, limited way to try a task before the owner creates an account. Neither is an unlimited source of free requests.

<a id="migration"></a>
## Map the API generation your app uses.

Current Oxylabs Web API uses a Bearer key and dedicated scraper paths. Older Web Scraper API clients use a different host and Basic authentication. Identify yours before changing the adapter.

| Change | Oxylabs | FlashData | What to do |
| --- | --- | --- | --- |
| Current Google endpoint | POST /v1/scrape/google/search on webapi.oxylabs.io | POST /v1/queries/realtime on data.flashdata.dev | Keep the query and rebuild the JSON payload. |
| Current authentication | Authorization: Bearer · Web API instance key | X-API-Key · google_search permission | Use a new FlashData credential; an Oxylabs key cannot authenticate here. |
| Legacy client | realtime.oxylabs.io/v1/queries · Basic auth · source=google_search | Same FlashData endpoint and key as above | Do not send legacy Basic credentials to either provider’s new endpoint. |
| Google market | domain, locale, location | params.gl, params.hl, supported params.location | US English example: gl=us and hl=en. A Google TLD, request origin and UI language are separate settings, not interchangeable strings. |
| Result pages | start_page + pages | params.page + params.num | Fetch one page per query; use Batch for multiple queries. Count pages as requests, not organic result rows. |
| Output | output: [json] · structured content in results[].json | JSON by default · results[0].organic[] | Rewrite the reader for the fields your app uses; do not keep the old results[].json path. |
| Job completion | Current Web API response / async job status | status: done plus results | Check completion before treating an empty organic list as a successful search. |

### 1. Prepare access

Sign up or sign in, complete account setup, and create a key with google_search permission in [API Keys](https://flashdata.dev/app/api-keys). Check [credits](https://flashdata.dev/app/billing). Keep the key in your environment or secret store. Agents can use the trial flow below.

### 2. Save and run one example

Run only one language example. Each execution submits a search and writes flashdata-result.json to the current working folder.

Python 3, standard library only. Save the following complete script as flashdata-search.py in a new task folder. It reads FLASHDATA_API_KEY or prompts privately.

```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
with open("flashdata-result.json", "w", encoding="utf-8") as output:
    json.dump(body, output, ensure_ascii=False, indent=2)
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 from that folder:

```bash
python3 flashdata-search.py
```

Bash alternative: requires cURL 7.76+ and jq. Save the complete code as flashdata-search.sh in your task folder.

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

```bash
bash flashdata-search.sh
```

### 3. Check completion and output

The script checks status=done before reading results[0].organic. A completed empty array is valid. Save the original response for usage and additional fields. Output shape (illustrative):

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

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

### Before production

| Requirement | Action |
| --- | --- |
| /Search or /Scrape? | Keep a lightweight web-search tool separate from a full Google SERP scraper. This page compares the latter; do not reuse /Search pricing for it. |
| Parser-specific fields | Inspect a saved response. Preserve only the organic fields and SERP sections your application requires; do not assume the same result nesting. |
| Rendering and special Google tasks | Keep a separate path for screenshots, custom JSON extraction, Google Lens, Trends or AI Mode requirements that are outside the FlashData source contract. |
| Scheduled work | Store provider, job ID and output location. Recover a submitted job before deciding to submit again after a timeout. |

<a id="workflow"></a>
## Make a small search workload economical to keep running.

Separate the search budget from the schedule. Use stored credentials, explicit run IDs and saved results so a restart does not become another search submission.

### Choose a plan after measuring usage

Start with pay as you go. Use actual query counts to compare a monthly plan’s included balance and fee, rather than selecting a plan for its headline unit rate alone.

[View all search plans](https://flashdata.dev/pricing/google-search)

### Translate jobs, not job IDs

Drain existing Oxylabs jobs on Oxylabs. Submit new FlashData work with your own work-item ID, save its returned job ID and export completed results to durable storage.

[Build the async workflow](https://flashdata.dev/docs/guides/async-batch/reference.md)

### Keep access across scheduled runs

Claim the agent connection once and persist its profile. Stop on revoked access or insufficient balance; schedule the next run only after the owner resolves access.

[Reuse and revoke credentials](https://flashdata.dev/docs/guides/recurring-tasks/reference.md)

<a id="agents"></a>
## Try a task, then claim access

Eligible temporary trial: 1 credit(s), up to 50 Google searches, 72 hours. Check eligibility and reuse saved access first.

1. Reuse a credential or start one eligible trial. Keep keys outside chat and source control.
2. Complete one task, save the response and report usage. Keep the CLI profile and state directory.
3. The owner signs in or signs up, verifies email, enters the claim code and approves scopes and shared-balance access.
4. Use the saved owner credential for recurring work. Unused temporary credits do not transfer. Stop on revoked access or insufficient balance.

### Migration prompt

```text
Read https://flashdata.dev/compare/oxylabs/reference.md and https://flashdata.dev/auth.md.
Inspect my Oxylabs Google Search integration and the fields its callers consume.
Migrate only supported Google tasks. Report requirements that have no FlashData mapping.
Reuse saved access; otherwise check eligibility before creating one temporary trial.
Keep secrets in the host credential store, never in chat or source control.
Run one US English search for "openai" and return title, URL and snippet.
Save the raw response and report usage. Do not purchase credits.
For recurring work, ask the owner to claim access and approve permissions and shared-balance use.
Keep the same CLI profile and state directory. Stop on revoked access or insufficient credits.
```

### Already authenticated CLI

Install and authenticate the CLI first. Recover the same task with the same run ID; use a new run ID for fresh results.

```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 oxylabs-migration-first --json --non-interactive
```

[Authentication](https://flashdata.dev/auth.md) · [CLI](https://flashdata.dev/docs/guides/flashdata-cli/reference.md) · [MCP](https://flashdata.dev/docs/integrations/mcp-clients/reference.md) · [Skills](https://flashdata.dev/docs/guides/agent-skill/reference.md)

<a id="faq"></a>
## Before you switch

### Why not compare with Oxylabs’ generic /Scrape price?

Google has its own rates. Its non-JS and JS modes are priced separately, and /Search is a different endpoint. The selector uses Google-specific rates so the unit comparison reflects a Google SERP workload.

### Can I buy FlashData credits without subscribing?

Yes. Pay-as-you-go credit purchases start at $10 and do not require a monthly plan. Optional subscriptions include credits and lower usage rates. Oxylabs’ current paid shared balance requires an active subscription.

### What if I still use the older Oxylabs API?

Identify the host and authentication in your existing code. The legacy realtime.oxylabs.io client differs from the current Web API. Migrate both to FlashData’s X-API-Key request and response schema; check your own legacy contract separately from current public pricing.

### Can FlashData replace generic page scraping?

This migration is for supported Google Search tasks. Keep a separate page-reading or browser tool for full webpage extraction, screenshots and JavaScript interaction. Search results supply source links and snippets.
