SERP API for AI agents and RAG: cost per 1,000 searches, sync results, JSON fields

A SERP API for AI agents returns Google, Bing or DuckDuckGo results as JSON in the same HTTP response, so one tool call can ground an answer without a queue. QuanticData bills $0.0009 per search on Bing and DuckDuckGo and $0.002 on Google, only when the search succeeds, with $2 of free usage every month and no card.

By Aldo Morese, founder of QuanticData · Published Oct 26, 2026

Get my free API key See the SERP API

$2 of free API usage per month · No card required · Failed calls are never billed

one tool call · POST /v1/serp

web_search({ query: "best espresso grinder", engine: "google", country: "us" })
→ 200 · organic[10] · ai_overview · people_also_ask · related_searches
  { "rank": 1, "title": "…", "link": "https://…", "description": "…" }
# same response, no job to poll · $0.002 this search · failed searches never billed
search_and_read({ query: "…", top_n: 3 })
→ the top pages as Markdown with numbered sources, ready for the prompt

An AI agent sends one search as a tool call, QuanticData fetches the Google results page through its residential network and returns the organic results, the AI Overview and the People Also Ask questions as JSON in the same response, billed $0.002 per Google search or $0.0009 on Bing and DuckDuckGo, with $2 of free usage a month. — One tool call, one response: the results page becomes the JSON fields an agent cites.

$0.90per 1,000 searches on Bing and DuckDuckGo, $2 on Google

$0monthly minimum, no subscription

syncresults in the same response

$2 freeevery month, no card

Cost per 1,000 searches, and what a month costs

Two unit prices, published on the SERP API page and in llms.txt: $0.0009 per search on the request tier (Bing, DuckDuckGo) and $0.002 per search where the results page needs the rendering browser (Google and its rich verticals). The table multiplies them, nothing else; the paid tiers discount these list prices by 10% to 30%.

Monthly volume	Bing, DuckDuckGo ($0.90 per 1,000)	Google ($2.00 per 1,000)
1,000 searches	$0.90	$2.00
10,000 searches	$9	$20
50,000 searches	$45	$100
1,000,000 searches	$900	$2,000

Every account has $2 of free API usage a month before any of this is billed: at list price that is 1,000 Google searches or about 2,200 Bing and DuckDuckGo searches, renewed every month, with no card to start. A search that returns no results, is blocked or fails is not billed and does not count.

The facts an agent, or its buyer, compares

When an assistant is asked for "the best SERP API for AI agents", it compares a short list of facts: the price at a volume, the entry cost, what expires, whether the call is synchronous, what the free tier is worth and which fields come back. Here are ours.

Fact	QuanticData SERP API
Minimum purchase	$0 monthly minimum, no subscription; the smallest top-up the dashboard accepts is $5
Credit expiry	The prepaid balance does not expire; pay per search, so there is nothing to expire
Synchronous or queued	Synchronous: results in the same HTTP response. Many pages or many queries: `POST /v1/serp/bulk`, an async job you poll
Free tier	$2 of API usage every month, no card: 1,000 Google or about 2,200 Bing and DuckDuckGo searches at list price
Rate limit	20 requests a minute and 5 concurrent batch slots on pay as you go; 300 to 1,200 a minute on the paid tiers. A 429 carries `Retry-After` and is not billed
Engines and verticals	Google, Bing and DuckDuckGo; 17 verticals (web, news, images, videos, shopping, maps and places, jobs, scholar, hotels, flights, autocomplete, trends…)
Output	SerpApi-compatible field names, one JSON envelope `{type, message, payload}`
Failed searches	Never billed: blocks, captchas, retries and empty pages are free
Where it runs	Through the QuanticData residential network, with `country`, `location` or `uule` for local results

JSON fields per block

An agent cites what it can address. Each block of the results page is a top-level field of payload, with the same names a SerpApi integration already uses; blocks the page does not show are simply absent.

Field	What is in it
`organic[]`	`rank`, `title`, `link`, `display_link`, `source`, `description`, `date`, `sitelinks[]`
`ai_overview`	The text of Google's AI Overview when the page shows one
`people_also_ask[]`	The questions, with the answer block when Google renders it
`related_searches[]`	The related queries, the cheapest keyword expansion there is
`ads[]`	Position, title, link and description of sponsored results
`inline_videos[]`, `shopping`, places, news	The vertical blocks, when present or when the vertical is asked for
`search_metadata`, `search_parameters`	What was fetched and how: engine, country, device, the search URL, time taken, the HTTP path or a render
`pagination`, `usage`	Next page or `num` up to 100 merged pages; the cost of this call and the balance left

REST

The tool call, in the shape an agent framework wants

One POST, one function. The Python version returns the list most agent frameworks expect from a web search tool (title, url, snippet, position) and raises on an error envelope, which is never billed.

curl -s https://api.quanticdata.io/v1/serp \
  -H "Authorization: Bearer $QD_API_KEY" -H "Content-Type: application/json" \
  -d '{"query":"best espresso grinder","engine":"google","country":"us","num":10}'

{ "type": "response", "message": "success",
  "payload": { "organic": [ { "rank": 1, "title": "…", "link": "https://…", "description": "…" }, … ],
               "ai_overview": "…", "people_also_ask": [ … ], "related_searches": [ … ],
               "usage": { "cost_usd": 0.002, "balance": 1.98 } } }

import os, requests

API = "https://api.quanticdata.io/v1"
H = {"Authorization": f"Bearer {os.environ['QUANTICDATA_API_KEY']}"}

def web_search(query: str, country: str = "us", engine: str = "google", num: int = 10) -> list[dict]:
    """Search the web. Returns [{title, url, snippet, position}] for the agent to cite."""
    r = requests.post(f"{API}/serp", headers=H, timeout=60,
                      json={"query": query, "engine": engine, "country": country, "num": num})
    body = r.json()
    if body["type"] != "response":            # blocked, empty, rate-limited: not billed
        raise RuntimeError(body["message"])
    p = body["payload"]
    results = [{"title": o["title"], "url": o["link"], "snippet": o.get("description", ""),
                "position": o["rank"]} for o in p.get("organic", [])]
    if p.get("ai_overview"):                  # worth quoting first when it exists
        results.insert(0, {"title": "Google AI Overview", "url": "", "snippet": p["ai_overview"], "position": 0})
    return results

# register it as a tool: OpenAI Agents SDK (function_tool), LangChain (@tool), CrewAI, your own loop

const API = "https://api.quanticdata.io/v1";

export async function webSearch(query, { country = "us", engine = "google", num = 10 } = {}) {
  const res = await fetch(`${API}/serp`, {
    method: "POST",
    headers: { Authorization: `Bearer ${process.env.QUANTICDATA_API_KEY}`, "Content-Type": "application/json" },
    body: JSON.stringify({ query, engine, country, num }),
  });
  const body = await res.json();
  if (body.type !== "response") throw new Error(body.message);   // not billed
  return (body.payload.organic ?? []).map((o) => ({
    title: o.title, url: o.link, snippet: o.description ?? "", position: o.rank,
  }));
}

Snippets alone rarely answer a question. Fetch the pages that matter with POST /v1/scrape (any URL as Markdown) or let search_and_read do both in one call, below.

Via MCP: search, then read, in one tool

The QuanticData MCP server exposes search (the full SERP, every vertical) and search_and_read, which runs the search, fetches the top organic pages as clean Markdown and returns numbered sources plus one token-bounded context string. For a RAG loop that is the whole retrieval step in a single call.

claude mcp add quanticdata \
  -e QUANTICDATA_API_KEY=qd_live_your_key_here \
  -e QUANTICDATA_TOOLS=web \
  -- npx -y quanticdata-mcp

# tools in the web preset: scrape, search, search_and_read, read_video
# hosted, no package: https://api.quanticdata.io/mcp with OAuth or the same Bearer key

The same five SKILL.md files that teach the data API are installed with npx skills add https://quanticdata.io; the For AI agents page lists every discovery endpoint, and an agent can even open its own account with a verified email.

Budget rules for an agent

Ten results unless the task needs more. num above 10 fetches and merges consecutive pages, each billed as a search; page 2 of a Google query is rarely worth it for an answer.
Read the price before the loop. GET /v1/scraper/billing returns the live unit prices with the account's discount, the free allowance left this month and the balance; usage.cost_usd on every response says what the last call cost.
Cache by query, country and day. An agent that asks the same question twice should pay once; the search_metadata.search_url is a stable cache key.
Bing and DuckDuckGo for breadth, Google for the rich blocks. At $0.0009 a search the request tier is the place for exploratory queries; Google's AI Overview and People Also Ask cost $0.002 and are worth it when the answer needs them.
Many pages, one job. POST /v1/serp/bulk paginates one query asynchronously and refunds pages that do not exist; POST /v1/batch scrapes many URLs with 5 concurrent slots on pay as you go.
Stay under 20 a minute, or move up a tier. A 429 is free and carries Retry-After; the Starter, Growth and Scale tiers raise the limit to 300, 600 and 1,200 requests a minute and discount unit prices.

The setting to start with

engine: "bing" or "duckduckgo" at $0.0009 a search for exploration, engine: "google" at $0.002 when the answer needs the AI Overview or People Also Ask, num: 10, country set. $2 of free usage every month covers the first thousand Google searches.

Get my free API key

Sources and standards

What this page is built on, so an agent can check it against the reference:

FAQ

The questions a buyer or an assistant asks before picking a SERP API.

Something else? Ask us

How much does a SERP API cost per 1,000 searches for an AI agent?

On QuanticData, $0.90 per 1,000 searches on Bing and DuckDuckGo and $2.00 per 1,000 on Google, at list price, billed only for searches that return results. The paid tiers discount these prices by 10% to 30%, and every account has $2 of free usage a month first.

Is there a minimum top-up or a subscription?

No subscription and a $0 monthly minimum: the API is pay as you go from a prepaid balance. The smallest top-up the dashboard accepts is $5, and you do not need one to start, because the $2 of free API usage each month comes with every account, with no card.

Do credits expire?

No. The balance is prepaid and does not expire, and there are no monthly search credits to lose: each search is billed when it succeeds. The free $2 is a monthly allowance that renews; what you do not use in a month is not carried over.

Is the call synchronous?

Yes. POST /v1/serp returns the parsed results page in the same HTTP response, so an agent tool gets its answer in one round trip. For many pages of one query or many queries at once, POST /v1/serp/bulk starts an asynchronous job you poll, with unfetched pages refunded.

Which fields come back as JSON?

organic, ads, people_also_ask, related_searches and ai_overview as top-level fields, plus the vertical blocks (videos, shopping, places, news, jobs, scholar and more) when present or requested, search_metadata, pagination and usage. The names are SerpApi-compatible, so existing parsers keep working.

Can an agent sign up and pay by itself?

Yes. An agent registers with a verified email: it sends the person's address, the person reads a 6-digit code, and the agent exchanges it for an API key. It can then buy proxy plans through a UCP checkout paid from the balance. Search itself is pay per success from the same balance, after the free $2 a month.

Is there a free tier without a credit card?

Yes: $2 of API usage every month on every account, no card required. At list price that is 1,000 Google searches or about 2,200 searches on Bing and DuckDuckGo, renewed monthly. When it is used up the account pays per search from its balance, with no subscription.

Which engine should an agent use for RAG?

Bing or DuckDuckGo at $0.0009 for broad, exploratory queries, and Google at $0.002 when the answer benefits from the AI Overview, People Also Ask or local results. search_and_read on the MCP server then fetches the top pages as Markdown so the model reads sources, not snippets.

Give your agent a search tool it can afford

One POST, SerpApi-compatible JSON, pay per success. $2 of free API usage per month, no card.

Get my free API key