On January 1, 2027 Google will be retiring its Custom Search JSON API, the long-standing way for developers to get Google search results as JSON. The API is already closed to new signups; after January 1, 2027 existing integrations will stop working as well. Google will point developers to one of three alternatives, including Agent Search under the Gemini Enterprise Agent Platform. But this is already a rebrand of the product (Vertex AI Search) that Google recommended only three months earlier.
If you’re confused, you’re not alone. A dev following Google’s path today will encounter three names for one product: “Agent Search” in the docs, “Vertex AI Search” in the console, and “Discovery Engine” in the API (and the URL slug is still generative-ai-app-builder, a fourth name). This highlights the instability of relying on a Big Tech company with the conflicting goals of owning both AI search and your AI development. For such critical infrastructure as AI and agent search, Google is putting many companies in a difficult and overly complex position.
Whether you’re an app developer or looking to power your agents, if you need a drop-in alternative to the Google Search API, the Brave Search API covers the same use cases (such as site search, AI grounding, and full-Web search) with self-serve JSON endpoints and even cleaner data. It also includes a dedicated LLM Context endpoint built for agents and chatbots—no Google (and no Google scraping) required.
This article will discuss the Google shutdown and Brave as an alternative, and give a practical how-to guide for workflow migration from one to the other.
JSON stands for JavaScript Object Notation, a lightweight, text-based data format that’s both human-readable and easily parsed by computers. It’s a widely used format for Web content.
For years, the Custom Search JSON API was the closest thing to an official “give me search results as JSON” service. It grew out of Google’s Custom Search Engine (2006) and arrived as a JSON API around 2010, becoming a staple for indie developers, researchers, and small companies who needed Web or image results in a simple format. In a January 2026 blog post, Google announced it would be transitioning away from the existing API product.
Here’s the timeline: The API is already closed to new customers, so you can’t sign up for it today. Existing customers have until January 1, 2027 to move to something else, and after that the endpoint will stop serving results. If your product, internal tool, or research pipeline reads search results through this API, it will break unless you migrate to an alternative.
But this is bigger than the JSON API. In the same announcement, Google began withdrawing free full-Web search across the Programmable Search Engine as a whole. As of January 20, 2026, every newly created engine must use the “Sites to search” setting, which is capped at 50 domains (existing engines can keep the “Search the entire web” option only until January 1, 2027, the same deadline as the API). In other words, free open-Web search is going away across Google’s site-search products; the JSON API is just the most visible part of a wider pullback.
Google’s announcement splits users of these products into three groups, each with a different suggested path. Knowing these paths will help you pick the right alternative to the Google Search API for your needs.
If you only search your own website or a small set of sites, Google points you to its Programmable Search Element. This can work for a search box on a marketing site, but it’s built around a fixed list of domains (up to 50) rather than the open Web. So the moment you need a result from a site you haven’t pre-registered, the Programmable Search option can’t return it.
For AI-powered conversational search and enterprise grounding, Google originally pointed users to Vertex AI Search—a product that Google has now renamed Agent Search and folded into the new Gemini Enterprise Agent Platform, only three months after recommending it. (Tellingly, as of August 2026, Google’s own Custom Search migration page still lists the old “Vertex AI Search” name.) Agent Search is a capable product, but it’s really an enterprise search and RAG retrieval service designed to run on Google Cloud with enterprise-style setup and pricing. For a small team that just wants search results as JSON, the Gemini agent platform will be overkill, and introduce more complexity than it solves.
The numbers make this concrete. By default, Agent Search enforces a low search-rate quota, and Google’s own documentation tells you not to request a quota increase—to go higher, you must switch to its Configurable subscription, which starts at a minimum of 1,000 QPM and 50 GB of storage: roughly $6,000 per month before any add-ons. It also bills for the data you index ($5.00 per GB-month on the General model), a cost that grows with your corpus.
| Google Agent Search | Brave Search API | |
|---|---|---|
| Default throughput | Low default rate quota; can’t be raised without a subscription | 50 requests/sec (Search plan) |
| Entry cost | $1.50 / 1,000 (General model, your own corpus) or a Configurable subscription from ~$6,000 per month for throughput | $5 / 1,000 queries (open Web), pay-as-you-go, with $5 free monthly credits |
| Your own data | $5 / GB-month (General); storage and embedding add-ons (Configurable) | No per-GB storage fee (since you’re querying Brave’s index) |
| Setup | Google Cloud project, enterprise onboarding | Self-serve API key |
For a team that just wants Web results or grounding as JSON, that’s a steep floor to clear.
To be fair on unit price, Google can be cheaper per query: if you only need to search your own indexed data, the General model within Agent Search costs $1.50 per 1,000 queries, below Brave’s Search plan ($5 / 1,000 queries). But that rate buys corpus search over a fixed set of sites, not the open Web—and it still carries the storage fees, the rate-quota cap, and the Cloud setup overhead. Brave has the edge for that corpus use case, serving open-Web results from an independent index (not a repackaged Google feed), far higher self-serve throughput, and no infrastructure to stand up.
You can no longer sign up for a Google API that returns open-Web results as JSON (a ranked list of links you can page through) the way the old Custom Search API did. Agent Search doesn’t fill the gap either—it searches only the sites you specify and index, not Google’s public Web index. That’s a fundamentally different product from a Web search API. Meanwhile, for a raw results feed, Google routes you to a form to register interest in a future solution, with pricing and details to come.
Google does sell self-serve, live open-Web products—but they’re grounding SKUs, not a results feed. Grounding Queries exceeding predefined limits are billed at $14 per 1,000 grounding queries on Gemini 3, and on Gemini 3 Google bills for each search the model decides to run—so one user question can trigger several charges. (On Gemini 2.5 and earlier the rate is $35 per 1,000 prompts, and Web Grounding for enterprise is $45 per 1,000 prompts.) Both return a synthesized answer with citations rather than raw results. Brave’s closest equivalent, the Answers plan, is $4 per 1,000 searches plus $5 per million input/output tokens; if you’d rather run your own model, LLM Context gives you the grounding data directly.
That last gap is the important one. The thing most people valued about the old Google Search API (that is, that you could send a query and get open-Web results as JSON) no longer has a simple, ready-to-use replacement from Google.
The Brave Search API runs on Brave’s own Web index of 40+ billion webpages, and returns results as structured JSON over a REST endpoint. It’s also self-serve: You can sign up, get your API key, and start building today. It maps cleanly onto all three of Google’s use cases, and each of Brave’s plans includes $5 in free monthly credits—and with four self-serve plans available (Search, Answers, Autosuggest, and Spellcheck), that’s up to $20 per month in total free credits. Add to that self-serve usage limits, and you can test at low or no cost.
Brave supports custom ranking through a feature called Goggles, which lets you boost or restrict specific domains at query time. That means you can confine results to just the sites you care about (much like a programmable search engine) without being locked to a fixed list baked into a separate product. You get site-focused results and the open Web from the same API.
This is where Brave really stands out, thanks to a dedicated endpoint called LLM Context, purpose-built for agents and chatbots. Instead of returning a plain list of links, the LLM Context endpoint does the hard part for you: A single call returns pre-extracted Web content ranked for relevance, with text chunks, tables, code blocks, and structured data. And each of these will have per-source provenance, so your model can reason over it directly. There’s no separate step for scraping or fetching.
LLM Context can help with the same workflows where an enterprise might otherwise turn to Google’s Agent Search and Gemini Enterprise Agent Platform. The main differences are that Brave’s solution is available through a simple REST API you can wire up in minutes, and it’s purpose-built for AI-powered conversational search or grounding (rather than being part of a larger AI development platform).
If you’d prefer to have Brave produce the finished answer (rather than run your own model), there’s a separate Answers plan: it returns a researched, grounded answer along with the Web sources that back it, priced at $4 per 1,000 Web searches plus $5 per million input/output tokens. And, as with Brave’s other plans, Answers includes $5 in free credits every single month.
Answers is the closest analog to Google’s generative, conversational answers (that is, for easy access to machine intelligence with minimal setup) while LLM Context remains the better fit when you want to keep control of the model layer and just need high-quality grounding data to feed it.
This is the biggest difference. Where Google now routes full-Web users to a form, Brave offers full-Web search from its own, completely independent index of the Web—it’s self-serve and available right now. You get open-Web results as JSON (the exact pattern that made the old Google Search API a favorite of developers) without a waitlist.
Migrating is straightforward. First, get an API key from the Brave Search API dashboard. Then send your query to the LLM Context endpoint and read the JSON payload. It’s the same “query in, JSON out” flow you already know, except it returns ready-to-use grounding content instead of just links.
Here’s a simple request with cURL:
curl "https://api.search.brave.com/res/v1/llm/context?q=who+won+the+f1+race+this+weekend"
--compressed \
-H "Accept: application/json" \
-H "X-Subscription-Token: <YOUR_API_KEY>"And the same request in Python, using import requests and parsing the response with response.json():
import requests
url = "https://api.search.brave.com/res/v1/llm/context"
params = {"q": "who won the f1 race this weekend"}
headers = {
"Accept": "application/json",
"X-Subscription-Token": "<YOUR_API_KEY>",
}
response = requests.get(url, params=params, headers=headers)
response.raise_for_status( )
print(response.status_code) # 200 on success
data = response.json()
# pre-extracted grounding content + source provenance
# Pass `data` to your model as context — no separate scrape step neededThe response is organized into grounding content (grouped by type) and metadata for its sources, with per-source provenance like title, hostname, and the age of the page, providing everything your model needs to answer with citations. You can also tune the response with the same filters as Web search, including freshness, country, and Goggles-defined domain lists, all using the same API key and subscription plan.
If your use case is simpler (for example, if you just want a ranked list of Web results as JSON, the way the old Google Custom Search JSON API worked) Brave’s Web search endpoint (/res/v1/web/search) is the direct analog, using the same key and the same “query in, JSON out” pattern.
The deprecation is a reminder of a bigger lesson: when your search depends on Google, you’re exposed to Google’s business decisions. The API is now going away on Google’s timeline, forcing thousands of projects to scramble for a replacement.
A standalone search API like Brave lowers that risk. Rather than reselling or scraping another engine’s results, Brave runs its own index, so your search doesn’t hinge on a competitor’s roadmap. It also brings privacy benefits, including options like Zero Data Retention (ZDR), a necessity when search sits inside a regulated product.
Google’s Custom Search JSON API is closed to new customers now, and existing customers must migrate by January 1, 2027. After that date, the API will stop returning results.
It depends on your use case. Google points users to its Gemini Enterprise Agent Platform, home to Agent Search, the renamed version of the Vertex AI Search tool it recommended three months earlier. But this is really an AI development platform. For the specific need of Web search as JSON, a standalone, independent option like the Brave Search API is a purpose-built, self-serve alternative to the Google Search API that you can start using today.
The Brave Search API lets you start for free—every Brave plan includes $5 in monthly credits to test with. And, unlike with Google Custom Search, there’s no 100-queries-per-day ceiling. You can scale by paying only for what you use instead of hitting a hard free-tier wall (or, as of January 1, 2027, losing the free tier entirely). A credit card is required to sign up for Brave, but you can set usage limits so you never exceed your free monthly credits or whatever is your target budget. See the Brave Search API dashboard for current plan details.
Yes. Unlike Google’s site-scoped options, the Brave Search API searches the open Web from its own index, and you can still narrow results to specific domains using Goggles.
Usually not. Brave follows the same “query in, JSON out” pattern and uses one API key, so migrating is mostly swapping the endpoint and updating how you read the response. For a plain results list, the field mapping is small; if you move to the LLM Context endpoint for AI grounding, you’ll get richer pre-extracted content to hand straight to your model.
Whether you’re building agents, copilots, or RAG pipelines, success hingest on the quality of the data you can access in real time. That’s where Web search APIs come in. In this short article, we'll discuss the best search API options for 2026
Read this article →A guide to using the Brave Search API as a news API: how the /news/search endpoint works, the structured JSON it returns, real-time and global coverage, common use cases like news aggregation and AI grounding, and how to make your first call.
Read this article →A plain-language guide to the HTTP QUERY method: a web standard (RFC 10008, 2026) that lets a program send a read-only lookup with its details in the request body instead of the web address, so the request is safe to repeat and its answer can be saved and reused. Explains why QUERY was created, how it works, where it helps (especially search APIs), and how widely it is supported.
Read this article →
