Google Search JSON API alternative: how to replace Custom Search before January 1, 2027

TL;DR

• Google's Custom Search JSON API has been closed to new customers since January 20, 2026, and stops working for existing customers on January 1, 2027.
• The old limits were tight: 100 free queries a day, $5 per 1,000 after that, a 10,000-a-day cap, 10 results per request and 100 results per query at most.
• Google's own path covers up to 50 domains through Vertex AI Search (now being renamed Agent Search), whose Enterprise edition, the one website search needs, costs $4 per 1,000 queries. Full web search goes through an interest form with no public price.
• Replacements split two ways: SERP APIs that return Google's result page as JSON, and search APIs built for AI agents that return sources and page content.
• On the independent OpenBenchmarks web search benchmark (last measured October 21, 2026), Firecrawl /search answered 95.3% of 300 factual lookup questions with a 510 ms average search time.
• On the same benchmark's hard retrieval task, Firecrawl /search was the most token-efficient search-only API, at a median 7,456 tokens per task.
• Firecrawl also runs its own curated indexes (Research, Developer and Government) and Firecrawl Alexandria, which reaches official data providers across 23 categories. The Custom Search JSON API only ever returned titles, links, snippets and page metadata from Google's index.

Google's Custom Search JSON API stops working on January 1, 2027. Teams that still call it have about ten weeks to move.

Google's suggested replacements cover narrower ground than the API did, so most teams need a third-party Google Search JSON API alternative. Below are the main options with list prices checked on October 23, 2026, and a tested migration of a cse.list call to Firecrawl /search that keeps the code around it unchanged.

Google's Custom Search JSON API, the REST endpoint behind Programmable Search Engine, is closed to new customers and will be discontinued on January 1, 2027. Existing customers can keep calling it until then at the current price. Search engines created after January 20, 2026 also can't use the "Search the entire web" setting.

Google's Programmable Search Engine team posted the announcement on January 20, 2026. The Custom Search JSON API overview (last updated February 18, 2026) now says the API "is not available for new customers" and that its pricing applies only "until the service discontinuation on January 1, 2027."

The closure already shows up as errors. Projects that try to start using the API get 403 PERMISSION_DENIED and the error text "This project does not have the access to Custom Search JSON API." In July 2026, a Google community manager confirmed in the Programmable Search help forum that any search engine created after January 20, 2026 cannot use the API. By October 23, 2026, 146 people had marked that thread "I have the same question."

The Custom Search JSON API returns at most 10 results per request and never more than 100 results for a single query, according to Google's cse.list reference. Existing customers get 100 free queries a day, then pay $5 per 1,000 queries up to 10,000 queries a day.

The limits shaped how teams used the API. A request returns a title, link, snippet and some page metadata for each result, so any app that needed the page itself had to fetch and clean every URL in a second step. Reading the top 30 results took three paged calls, and anything past result 100 was out of reach.

Google offers three paths, and none of them is a drop-in replacement for full web search over JSON. Site search on up to 50 domains moves to the free Programmable Search Element or to Vertex AI Search. Full web search goes through an interest form for a separate product whose price and terms are not public.

• Programmable Search Element, "Sites to search." The embeddable search box stays free for engines that list 50 domains or fewer. It runs as a search widget on your web pages.
• Vertex AI Search, now Agent Search. Google Cloud's migration guide says "Vertex AI Search is being renamed to Agent Search." Website search needs the Enterprise edition, which costs $4.00 per 1,000 queries on Agent Search pricing, with 10,000 free trial queries a month. Setup means a Google Cloud project, a data store of URL patterns and an app.
• Full web search. Google asks teams that need its whole index to register interest through a form. In September 2026, Search Engine Watch reported that Google documents a partner-only web search API with no published price or daily allowance. Google has not named it as the Custom Search replacement.

If your app searches a handful of your own domains, Google's path works. If it searches the open web, you need a third-party API.

A Google Search JSON API alternative should return ranked results as JSON with a title, URL and snippet, as Google's list method did. It should also keep the controls you relied on, such as date filters, site filters and country targeting. The bigger choice is whether you need Google's exact result page or the content behind the results.

Five questions sort the options quickly:

1. Whose results? SERP APIs fetch and parse Google's own result page. Other APIs return results from their own indexes.
2. How many results per call? Google's API stopped at 10. Some replacements return 20 to 100 in one request.
3. Snippets, pages or source data? AI agents and retrieval pipelines usually need the page text behind each result, and sometimes the official record behind the page.
4. How is it billed? Per request, per credit or per monthly plan, with different free allowances.
5. How much code changes? The closer the response shape is to Google's items array, the smaller the migration.

Firecrawl /search, the Brave Search API, SerpApi and Google's own Agent Search cover most Custom Search use cases in 2026. Prices below are list prices checked on each vendor's own page on October 23, 2026.

The Bing Search API is not on the list because Microsoft retired it on August 11, 2025. Our Bing Search API alternatives guide covers that migration.

SERP APIs and search APIs for AI agents differ in where results come from. A SERP API returns Google's result page for SEO work. A search API built for AI agents returns results from its own index and favors page content and source data over Google's layout.

SERP APIs. SerpApi fetches Google's result page and returns it as JSON, with blocks such as People Also Ask and AI Overviews as separate fields. Pick a SERP API when the exact Google ranking is the data, as in rank tracking.

Search APIs with their own index. Firecrawl /search returns ranked results and, in the same call, the full page as Markdown, plus results from Firecrawl's specialized indexes and data providers. Brave Search API serves results from Brave's own index and offers an LLM context endpoint for grounding.

Google Agent Search. It suits teams that search their own sites and already run on Google Cloud. It searches only the sites you add to its data store.

Firecrawl /search is a web search API for AI agents that returns ranked results as JSON and, in the same request, the full content of each result as Markdown. It covers the jobs Google's API did, such as date and site filters and country targeting. It also reaches Firecrawl's own curated indexes and official data providers, which the Custom Search JSON API never could.

Firecrawl is the context API for AI agents. The parts that matter for a Custom Search migration:

• Up to 100 results per request through limit, where cse.list capped num at 10.
• Full pages in one call through scrapeOptions, with every option from Firecrawl /scrape available, including Markdown, HTML, links, screenshots and JSON extraction.
• Filters that map to Custom Search parameters: tbs for time ranges, includeDomains and excludeDomains for site filters, country and location for geography.
• Curated indexes and data providers through categories and Firecrawl Alexandria, covered below.
• Keyless mode, so you can test calls with no account or API key, within a daily per-IP limit.

11x, an AI growth platform, uses Firecrawl /search alongside Firecrawl /crawl to research companies for outbound. Its CTO, Jeson Patel, says in the 11x customer story: "Firecrawl gathers and structures information from across the web to give us a detailed picture of any company."

On OpenBenchmarks' open-source web search benchmark, Firecrawl /search answered 95.3% of 300 factual lookup questions with a 510 ms average search time. On the hard retrieval task, it was the most token-efficient search-only API, at a median 7,456 tokens per task.

OpenBenchmarks holds the query, the reading model and the judge constant and changes only the search API, with its harness and scoring public on GitHub. The table shows its factual lookup results for the Firecrawl and Brave endpoints it tested, as published on October 21, 2026. SerpApi and Google Agent Search are not on that board.

Hard retrieval asks an AI agent to find an answer buried in one specific page and passes only with a grounded source URL from that run. On the token efficiency board, Firecrawl /search ranks first among search-only APIs at a median 7,456 task tokens with 70.3% task completion. Adding Firecrawl /scrape to fetch full pages lifts task completion to 76.0%, at a median 17,379 tokens. For an AI agent, fewer tokens per answer means lower model cost and more room in the context window.

Migrating from the Custom Search JSON API to Firecrawl /search means replacing one GET request with one POST request and renaming a few parameters. If the rest of your code reads each item's title, link and snippet, a small adapter keeps that shape so nothing downstream changes.

The table maps each cse.list parameter from Google's reference to its Firecrawl /search equivalent.

The adapter below returns the same items fields as cse.list and covers the parameters most calls use: q, start, num, dateRestrict, siteSearch and gl. Call sites switch to its snake_case argument names and drop cx; image and PDF searches map as shown in the table. Install the SDK with pip install firecrawl-py.

import os
from calendar import monthrange
from datetime import date, timedelta
from urllib.parse import urlparse
 
from firecrawl import Firecrawl
from firecrawl.v2.types import ScrapeOptions
 
firecrawl = Firecrawl(api_key=os.environ["FIRECRAWL_API_KEY"])
 
 
def date_restrict_to_tbs(date_restrict):
    unit, count = date_restrict[0], int(date_restrict[1:] or 1)
    if count == 1:
        return f"qdr:{unit}"
    today = date.today()
    if unit in "dw":
        start = today - timedelta(days=count * (7 if unit == "w" else 1))
    else:
        years, month = divmod(today.month - 1 - count * (12 if unit == "y" else 1), 12)
        year = today.year + years
        start = date(year, month + 1, min(today.day, monthrange(year, month + 1)[1]))
    return f"cdr:1,cd_min:{start:%m/%d/%Y},cd_max:{today:%m/%d/%Y}"
 
 
def cse_list(q, start=1, num=10, date_restrict=None, site_search=None,
             site_search_filter="i", gl=None, full_content=False):
    """Stands in for cse.list() and returns the same items fields."""
    options = {"limit": start - 1 + num}
    if date_restrict:
        options["tbs"] = date_restrict_to_tbs(date_restrict)
    if site_search:
        key = "include_domains" if site_search_filter == "i" else "exclude_domains"
        options[key] = [site_search]
    if gl:
        options["country"] = gl.upper()
    if full_content:
        options["scrape_options"] = ScrapeOptions(formats=["markdown"], only_main_content=True)
 
    results = firecrawl.search(q, **options)
    items = []
    for hit in (results.web or [])[start - 1:]:
        url = getattr(hit, "url", None) or hit.metadata.url
        item = {
            "title": getattr(hit, "title", None) or hit.metadata.title,
            "link": url,
            "snippet": getattr(hit, "description", None) or hit.metadata.description,
            "displayLink": urlparse(url).netloc,
        }
        if full_content:
            item["content"] = hit.markdown
        items.append(item)
    return {"items": items}

The calling code barely changes. This asks for the second page of results from the past year:

# Before: GET https://www.googleapis.com/customsearch/v1?key=...&cx=...&q=...&num=10&start=11
response = cse_list("postgres jsonb index performance", num=10, start=11, date_restrict="y1")
 
for item in response["items"][:3]:
    print(item["displayLink"], "|", item["title"])

Output from our run:

dev.to | PostgreSQL JSONB Indexing: GIN, Expression & Partial Index Strategies
now-next.nl | hstore vs jsonb performance in PostgreSQL, measured - Now-Next
richyen.com | Making JSONB More Queryable with Generated Columns - Richard Yen

The adapter also covers site search. cse_list("pathlib glob", num=3, site_search="docs.python.org") returned three pages, all from docs.python.org, and full_content=True adds each page's Markdown under content. Month and year ranges such as m6 count back by calendar months, as Google's filter does. Billing follows the request: 2 credits per 10 results, plus the scrape cost of each page you fetch (1 credit for a standard page).

If you call the REST API directly, the same request in cURL looks like this:

curl -s -X POST https://api.firecrawl.dev/v2/search \
  -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "postgres jsonb index performance",
    "limit": 10,
    "tbs": "qdr:y",
    "country": "US"
  }'

The response holds ten results under data.web, each with url, title, description and position, and reports creditsUsed: 2.

Firecrawl /search returns full page content when you pass scrape options with the formats you want. Each result then carries its Markdown alongside the title and URL, so an AI agent can read the sources in the same round trip that found them.

The Node.js SDK (npm install firecrawl) takes the same options:

import { Firecrawl } from "firecrawl";
 
const firecrawl = new Firecrawl({ apiKey: process.env.FIRECRAWL_API_KEY });
 
const results = await firecrawl.search("kubernetes horizontal pod autoscaler example", {
  limit: 3,
  scrapeOptions: { formats: ["markdown"], onlyMainContent: true },
});
 
for (const page of results.web ?? []) {
  console.log(page.metadata?.sourceURL ?? page.url, page.markdown?.length);
}

Output from our run, with the Markdown length of each page in characters:

https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale-walkthrough/ 23875
https://medium.com/@muppedaanvesh/a-hands-on-guide-to-kubernetes-horizontal-vertical-pod-autoscalers-%EF%B8%8F-58903382ef71 26588
https://spacelift.io/blog/kubernetes-hpa-horizontal-pod-autoscaler 20560

For page formats beyond Markdown, such as JSON extraction with a schema, see the Firecrawl /search guide.

Next to its general web search, Firecrawl runs its own curated indexes, including a Research Index of about 43 million paper abstracts, a Developer Index of more than 70 million code sources, and a Government Index of 30 million US government pages. Each one returns primary sources for its domain instead of pages that only mention them.

A Custom Search engine could restrict results to a list of sites, but it still returned Google's snippets of those pages. An index built for one kind of source returns the paper, the merged pull request or the statute itself, which is what an AI agent needs to cite an answer.

Firecrawl /search can return data tools from Firecrawl Alexandria next to web results when you add Alexandria as a source. Firecrawl Alexandria puts official data providers, licensed publishers and Firecrawl's own indexes behind the same API, so an AI agent gets quality data straight from the source instead of a page that describes it.

This is the biggest gap between Firecrawl and the API it replaces. The Custom Search JSON API could only point to pages in Google's index. With Firecrawl Alexandria, a question about a company's filings can go to SEC EDGAR, and a question about an economic series can go to FRED, so the answer comes from the publisher of record. Most search APIs, SERP APIs included, return web results only.

Firecrawl Alexandria groups its providers into 23 categories:

Add alexandria to sources to see web pages and provider tools in one response:

results = firecrawl.search(
    "Apple 10-K revenue by segment",
    sources=["web", "alexandria"],
    limit=3,
)
 
for hit in results.web or []:
    print("page:", hit.url)
for tool in results.tools or []:
    print("tool:", tool.provider, tool.capability)

Output from our run (trimmed):

page: https://investor.apple.com/sec-filings/default.aspx
page: https://s2.q4cdn.com/470004039/files/doc_financials/2025/ar/_10-K-2025-As-Filed.pdf
page: https://investor.apple.com/investor-relations/default.aspx
tool: fiscal-ai company/segments-and-kpis
tool: sec-gov filings/sections

Tool discovery is free. Running a tool through Firecrawl /scrape costs that tool's listed credit price.

Firecrawl /search is not tied to Python. It has official SDKs in nine languages, a REST API, a CLI, an MCP server for AI assistants and coding agents, and integrations with agent frameworks and no-code tools. Keyless mode lets you try the CLI and MCP server with no API key.

The SDKs, CLI and REST API share the same endpoints and credit pricing, so a LangChain app that used GoogleSearchAPIWrapper can move to Firecrawl in the same framework. For a walkthrough by language, see how to add web search to an AI app. If your team needs procurement terms, the enterprise page and security documentation cover them.

The right Google Search JSON API alternative depends on what your app did with Custom Search results. Site search on your own domains fits Google's own path, SEO tools that need Google's exact ranking fit a SERP API, and AI agents that read the pages they find fit Firecrawl /search.

Before the Custom Search JSON API shuts down, list every place your code or your vendors call it. Libraries and agent frameworks often wrap the API, so check dependencies as well as your own code, then replace each call behind an adapter and test it on real queries.

1. Find the calls. Grep for googleapis.com/customsearch, cse().list and wrappers such as LangChain's GoogleSearchAPIWrapper.
2. Write down what each call needs. Note the result count, filters, and whether a second step fetches the pages.
3. Pick by job. Match each call to site search, SERP data or sources for AI agents.
4. Swap behind an adapter. Keep the items shape so the rest of the code does not change, then delete the second fetch step if your replacement returns page content.
5. Run both side by side. Compare results on your real queries while the old API still answers.

Open source projects have started reporting the change. A GitHub issue opened on May 5, 2026 in the OmniRoute project reported that its Google search provider fails for users without prior API access. A Stack Overflow question from June 3, 2026 describes the same 403 on a project with billing active and the API enabled.

To try Firecrawl /search with no signup, run npx firecrawl-cli@latest or connect the keyless MCP server at https://mcp.firecrawl.dev/v2/mcp; keyless mode needs no API key and is capped per IP address per day. A free account adds 1,000 credits a month. For more on the category, see what a web search API is, the best free web search APIs, the best search API by use case and what a web index is.