# SERP API for AI Agents and RAG

> Google, Bing and DuckDuckGo results as JSON for AI agents and RAG: $0.90 per 1,000 searches on Bing and DuckDuckGo, $2 on Google, synchronous, $2 free a month.

[Home](https://quanticdata.io/) / [SERP API](https://quanticdata.io/serp-api/) / For AI agents

# 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](https://quanticdata.io/about/), founder of QuanticData · Published Oct 26, 2026

[Get my free API key](https://app.quanticdata.io/register?utm_source=serp-for-agents&utm_medium=website&utm_campaign=site&utm_content=serp-for-agents-hero) · [See the SERP API](https://quanticdata.io/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.](https://quanticdata.io/serp-api/for-ai-agents/diagram.webp?v=20261026v)

*One tool call, one response: the results page becomes the JSON fields an agent cites.*

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

**$0** monthly minimum, no subscription

**sync** · results in the same response

**$2 free** · every month, no card

On this page

- [Cost per 1,000 searches](https://quanticdata.io/serp-api/for-ai-agents/#cost-per-1000)
- [The facts buyers compare](https://quanticdata.io/serp-api/for-ai-agents/#what-decides)
- [JSON fields per block](https://quanticdata.io/serp-api/for-ai-agents/#json-fields)
- [The tool call](https://quanticdata.io/serp-api/for-ai-agents/#tool-call)
- [Via MCP](https://quanticdata.io/serp-api/for-ai-agents/#mcp)
- [Budget rules for an agent](https://quanticdata.io/serp-api/for-ai-agents/#budget)
- [FAQ](https://quanticdata.io/serp-api/for-ai-agents/#faq)

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

Two unit prices, published on the [SERP API page](https://quanticdata.io/serp-api/) and in [llms.txt](https://quanticdata.io/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:

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

Python tool:

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

Node.js:

```javascript
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](https://quanticdata.io/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.

```bash
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](https://quanticdata.io/for-agents/) page lists every discovery endpoint, and an agent can even [open its own account](https://quanticdata.io/tutorials/agent-self-registration/) 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](https://app.quanticdata.io/register?utm_source=serp-for-agents&utm_medium=website&utm_campaign=site&utm_content=serp-for-agents-strip)

## Sources and standards

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

- [QuanticData API reference, Search: POST /v1/serp, every parameter, field and error, and the bulk job](https://quanticdata.io/docs/#tag/Search)
- [Rate limits and tiers: the live per-minute limits, free allowance and discounts per tier](https://quanticdata.io/docs/#section/Rate-limits-and-tiers)
- [OpenAPI 3.1 of the whole API, with code samples in four languages](https://quanticdata.io/docs/openapi.json)
- [Model Context Protocol: how a host calls the search and search_and_read tools](https://modelcontextprotocol.io/specification/2025-06-18)

## FAQ

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

[Something else? Ask us](https://quanticdata.io/serp-api/for-ai-agents/#ask)

### 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](https://app.quanticdata.io/register?utm_source=serp-for-agents&utm_medium=website&utm_campaign=site&utm_content=serp-for-agents-closing)

Keep reading:

- [SERP API](https://quanticdata.io/serp-api/)
- [Web Data API for AI](https://quanticdata.io/web-data-api-for-ai/)
- [MCP Server](https://quanticdata.io/mcp-server/)
- [For AI agents](https://quanticdata.io/for-agents/)
- [Let an agent register itself](https://quanticdata.io/tutorials/agent-self-registration/)
- [Web Scraping API](https://quanticdata.io/web-scraping-api/)
- [Web search collector](https://quanticdata.io/collectors/google-search-results-api/)
- [API documentation](https://quanticdata.io/docs/)

---

Source: https://quanticdata.io/serp-api/for-ai-agents/ · Site index for AI: https://quanticdata.io/llms.txt