Native LLM Web Search Is Quietly Bankrupting Your AI App — the Cheap Fix

You shipped an AI feature that answers questions with fresh information from the web. Users love it. Then the invoice arrives.

Your model bill is fine. But there is a new line item — "grounding" or "web search tool" — and it is bigger than everything else combined.

This is the quiet killer of AI apps in 2026. Native web search inside Gemini and OpenAI is fantastic for a demo, and brutal at scale. The good news: the fix is simple, and it is cheap.

What native grounding actually charges you

Native grounding charges you for the search step, not just the tokens — and that search fee is where the surprise lives.

When you turn on a "search the web" tool inside Gemini or OpenAI, the model does two jobs in one call. First it decides to run one or more web searches. Then it reads those results and writes an answer.

You pay for both. The token part is the normal model cost you already understand. The search part is a separate, per-event fee — and it stacks up fast because the model, not you, decides how many searches to fire.

Let's look at the real numbers from each provider, then do the math.

Gemini Grounding with Google Search pricing

Gemini bills you per grounded request, and the rate depends on the model generation you use.

For the current Gemini 3.x family, Google includes 5,000 grounded prompts per month for free, then charges roughly $14 per 1,000 after that. Older Gemini 2.5 models are pricier at about $35 per 1,000. These figures come straight from Google's Gemini API pricing page — always check it, because Google updates the tiers and free quotas often.

Here is the part the docs are honest about but most people miss: when grounding is on, your project is billed for the search queries the model decides to execute. A single user question can make the model fire several searches internally — a behavior Google calls query fan-out.

We break that behavior down in our guide to Google AI Mode query fan-out. The short version: one turn can quietly become many billable search events, and you do not control how many.

OpenAI web search tool pricing

OpenAI charges a per-call fee for the web search tool and bills you for the content it pulls back into your prompt.

According to OpenAI's API pricing page, the web_search built-in tool in the Responses API runs about $10 per 1,000 calls. That is just the call fee.

On top of that, the search content tokens that get retrieved and injected into your model prompt are billed at your model's normal input-token rate. So the real cost of one search is the $10/1K call fee plus however many thousand extra tokens of web text the tool stuffs into your context window.

Those injected tokens are easy to forget. With a flagship model, a few thousand extra input tokens per call, multiplied across every request, becomes a serious second bill hiding behind the first.

Why the cost is unpredictable and unbounded

The core problem is that native grounding hands the search budget to the model, and the model is not optimizing for your wallet.

Three things make this dangerous:

1. You don't control the number of searches. The model fans out as it sees fit. One simple question might cost one search; a comparison question might cost five. Your per-user cost is a moving target.

2. You don't control how much text gets injected. The grounding system decides how much retrieved content to feed back into context. Those are tokens you pay for, every single time, with no trimming on your side.

3. You can't cache it. Because search and generation are fused into one call, you can't store the search result for a popular query and reuse it. Ten thousand users asking the same trending question means ten thousand billable searches.

Bundling feels convenient. But convenience that you cannot measure, cap, or cache is how a $50 demo becomes a $5,000 month.

The fix: decouple search from generation

The fix is to split the one fused call into two cheap, controllable steps that you own.

Instead of enabling the model's web search tool, you do this:

Step 1 — Search yourself. Call a flat-rate SERP API with the user's query. You get back clean, structured results. There is no proxy pool or headless browser to manage — the API handles access for you.

Step 2 — Trim and inject. Take the top organic results, keep only title, url and snippet, and pass that compact context into your own model call.

Now look at what you have gained:

• Predictable cost. A flat per-call SERP price means a search costs the same every time, whether it returns 10 results or 100. No fan-out surprises.
• Caching. The same query from a thousand users hits your cache, not the API. Our SERP cache walkthrough shows how a thin cache layer can drop billed calls dramatically.
• Token control. You decide how many results and how much of each snippet to feed the model. Fewer tokens in means a smaller model bill.
• Structured data = fewer tokens. A SERP API returns tidy JSON, so you skip the bloated raw HTML that native tools and naive scrapers dump into context.

This is the same pattern behind cost-aware agents. We did the full breakdown for agent frameworks in the LangChain agent cost math post, and the principle is identical: own the search step.

Cost comparison at 10K, 100K and 1M queries

At every volume, running search yourself with a flat-rate API is dramatically cheaper than native grounding — usually by two or three orders of magnitude.

The table below uses public list prices. Native grounding figures assume one billable search per query (real-world fan-out makes them higher). Serpent figures use the flat per-call price at the matching deposit tier, and remember: Serpent's page depth does not multiply the price.

Even being generous to the native tools — counting only one search per turn and ignoring the extra OpenAI content tokens — the gap is enormous. Add real query fan-out and injected tokens, and the spread only widens.

And the Serpent column does not even count the 10 free Google searches on signup, with no subscription and a $10 minimum deposit. The flat-rate model is what makes the per-call numbers above possible.

The code: search yourself, then prompt

Here is the whole pattern in one short Python script — search with Serpent, trim the JSON, then prompt your model with that context.

Notice how little we feed the model. Only the title, URL and snippet of the top few results — structured, compact, and far cheaper than letting a native tool dump raw web text into context.

import requests

SERPENT_KEY = "sk_live_your_key"

def web_context(query, top_n=5):
    # Step 1: run the search yourself (flat per-call price)
    r = requests.get(
        "https://api.apiserpent.com/api/search",
        headers={"X-API-Key": SERPENT_KEY},
        params={"q": query, "engine": "google", "country": "us"},
        timeout=30,
    )
    data = r.json()

    # Step 2: keep only title + url + snippet for the top results
    lines = []
    for item in data["results"]["organic"][:top_n]:
        lines.append(
            f"- {item['title']} ({item['url']})\n  {item['snippet']}"
        )
    return "\n".join(lines)


def answer(question):
    context = web_context(question)
    prompt = (
        "Answer using ONLY these search results. Cite the URLs.\n\n"
        f"Search results:\n{context}\n\n"
        f"Question: {question}"
    )
    # Step 3: your normal model call — NO web_search tool enabled
    # resp = your_llm.generate(prompt)
    return prompt


print(answer("best lightweight running shoes 2026"))

The key line is the one that is missing: there is no tools=[web_search] and no grounding flag. The model never touches the web, so it never bills you for searching. You did that part for a flat fee.

Because /api/search returns up to 100 organic results in one call at the same price, you can also widen top_n for research-heavy questions without paying more for the search. You only pay more in model tokens if you choose to feed more — and that choice is finally yours.

Want this wired into an agent or IDE instead of a script? See SERP API for AI agents, building a SERP MCP server for Claude and Cursor, and SERP APIs for AI coding agents.

When native grounding is still fine

Native grounding is the right call when volume is low and you value zero setup over cost control.

If you serve a few hundred grounded queries a month, Gemini's free quota may cover you and the convenience is worth it. Prototypes, internal tools, and weekend projects all fit here.

The moment you cross into real traffic — thousands of grounded queries a month, a public product, or anything with viral spikes — the math flips hard. That is exactly when decoupling pays for itself in the first week.

You can also do both: native grounding for rare, complex multi-hop questions, and a flat-rate SERP API for the high-volume "just look this up" majority. Route by query type and keep the expensive path for when it truly earns its cost.

FAQ

How much does Gemini Grounding with Google Search cost?

Gemini 3.x models include 5,000 grounded prompts per month free, then bill about $14 per 1,000 after that. Gemini 2.5 models bill about $35 per 1,000. Check Google's current pricing page, as one user turn can trigger multiple billable searches.

What does the OpenAI web search tool cost in the Responses API?

OpenAI bills the web_search tool at about $10 per 1,000 calls, plus the search content tokens that get fed back into your model prompt are billed at your model's normal input-token rate. So the real cost is the call fee plus extra tokens.

Why is native LLM grounding cost unpredictable?

Native grounding bundles search and generation into one opaque call. The model decides how many searches to fire and how much retrieved text to inject, so a single user turn can quietly cost far more than you budgeted. You do not control the search step.

How do I cut LLM web search cost?

Decouple search from generation. Run the search yourself through a flat-rate SERP API, trim the JSON to title, URL and snippet, then pass that as context to your own model call. You get predictable cost, caching and full control over how many tokens you feed.

How much can decoupling search from the LLM save?

A lot. Native grounding at scale can run thousands of dollars a month. A flat-rate SERP API like Serpent costs from $0.60 per 10,000 searches down to $0.03 per 10,000, which is often 50× to over 1,000× cheaper than per-query grounding fees.

Does structured SERP JSON use fewer tokens than native grounding?

Yes. A SERP API returns clean structured JSON, so you can pass just title, URL and snippet for the top results. That is a fraction of the tokens that native grounding or raw HTML dumps inject, which directly lowers your model input bill.