SerpApi vs Google Custom Search in 2026: Data, Cost, and Limits

TLDR: As of October 2026 this is rarely a live choice. Google's Custom Search JSON API is closed to new customers and ends on January 1, 2027, so it is a migration deadline, not an option for new builds. SerpApi is the working choice when you need Google's results page, with paid plans from $25 a month for 1,000 searches. If an agent needs sources to cite, neither fits.

The two names turn up in the same searches because both put Google-derived results behind a JSON API. They do different jobs. SerpApi fetches Google's results page and parses it. The Custom Search JSON API queries a Programmable Search Engine that you configure, and Google's own help center says that even a whole-web engine is unlikely to match Google Web Search. This guide compares them on what they return, what they cost, how they fail, and the legal and platform risk that now separates them. Prices and limits are as of October 2026 and come from vendor pages and the court docket. You.com sells a web search API, so read the agent row in the workload table with that in mind. For the underlying concept, see our SERP API guide.

Can you still choose Google Custom Search in 2026?

Not as a new customer. Google's overview page says the Custom Search JSON API is closed to new customers. It names Vertex AI Search as the alternative for searching up to 50 domains, asks full-web use cases to contact Google, and gives existing customers until January 1, 2027 to move. The pricing it lists, 100 free queries a day and then $5 per 1,000 up to 10,000 a day, applies only to existing customers until that date.

The engine side is narrowing too. Google's help center says that since January 20, 2026 every new Programmable Search Engine must use Sites to search, which covers up to 50 domains. An existing engine set to Search the entire web keeps that option until January 1, 2027, and once you switch it off you cannot switch it back on. Do not toggle it to run a test.

Which path you are on decides the rest of this comparison:

• New project: Custom Search is not available to you. The real comparison is SerpApi against other SERP APIs, or against a web search API if you do not need Google's exact page.
• Existing engine limited to your own sites: plan the move to Vertex AI Search or another site search path before the deadline. Our Google CSE alternative guide covers the inventory, pagination mapping, and test plan.
• Existing whole-web engine: your results never matched google.com, and the whole-web option ends on the same date. Decide whether you need Google's page, which points to SerpApi, or relevant pages with text, which points to a web search API.

What does each one return?

SerpApi returns a parsed copy of the results page. Its Google Search API documentation lists structured blocks for organic results, local results, ads, the knowledge graph, direct answer boxes, images, news, shopping, and video, and each organic result carries a position. SerpApi also covers engines beyond Google, including Bing, DuckDuckGo, Yahoo, Baidu, Yandex, and YouTube, according to its pricing page.

The Custom Search JSON API returns results from your configured engine. Each item in the response schema has fields such as title, link, displayLink, snippet, pagemap, and mime. There is no position field and no block for ads, local packs, or answer boxes. Google's help page on Programmable Search Engine versus Google.com says whole-web engines emphasize your own sites, search a subset of the Google corpus, and leave out Oneboxes, real-time results, universal search, and personalization.

	SerpApi Google Search API	Custom Search JSON API
Request	GET https://serpapi.com/search?engine=google with q and api_key	GET https://customsearch.googleapis.com/customsearch/v1 with key, cx, and q
Source of results	Google's results page, fetched and parsed by SerpApi	A Programmable Search Engine you configure
Result fields	position, title, link, displayed_link, snippet, sitelinks, and more	title, link, displayLink, snippet, pagemap, and more; no position field
Results page features	Ads, local results, knowledge graph, answer boxes, images, news, shopping, video	None documented
Pagination	start offset in steps of 10; no num parameter documented	start index with num from 1 to 10; start plus num must not exceed 100
Targeting	location, gl, hl, google_domain, device	gl, cr, lr, hl, dateRestrict, siteSearch
Output	JSON by default, raw HTML, or Markdown with output=md	JSON
Status	Available	Closed to new customers; ends January 1, 2027

Rank is a property of the results page, so a rank tracker needs the SerpApi column. An index API reports an order for its own engine, and Google says that order is unlikely to match google.com. The reverse also holds: SerpApi can search one site with a site: operator, which its documentation lists among the supported query syntax, but every request is a billed search of the whole results page.

How do plans, limits, and cost compare?

SerpApi sells monthly plans defined by a search count and a guaranteed hourly throughput. The table combines the cards on its pricing page with the plan data embedded in its View all plans view, as of October 10, 2026, and adds the effective price per 1,000 searches if you use the whole plan. Cloud plans continue above 1,000,000 searches in steps of 1,000,000.

Plan	USD per month	Searches per month	Guaranteed per hour	USD per 1,000 if fully used
Free	0	250	50	n/a
Starter	25	1,000	200	25.00
Developer	75	5,000	1,000	15.00
Production	150	15,000	3,000	10.00
Big Data	275	30,000	6,000	9.17
Searcher	725	100,000	20,000	7.25
Volume	1,475	250,000	50,000	5.90
Infrastructure	2,750	500,000	100,000	5.50
Cloud 1M	3,750	1,000,000	110,000	3.75

Counting rules matter as much as the table. SerpApi's pricing FAQ says only successful searches count toward the monthly total. Cached, errored, and failed searches do not, and a response with 100 results or an empty result set each count as one search. The Google Search API documentation adds that an identical query with identical parameters is served from cache for one hour, that cached searches are free, and that no_cache=true forces a fresh fetch.

The Custom Search JSON API is simpler: 100 free queries per day, then $5 per 1,000, up to 10,000 queries a day, for existing customers only. That is roughly 3,000 free queries a month and a ceiling near 300,000 a month.

Each 10-result page is one request on both APIs, so depth multiplies volume. The planner at the end of this guide produced these three workloads:

Workload	Requests per month	SerpApi plan	Custom Search (existing customers)
1,000 keywords checked daily, top 10	30,000	Big Data, $275	$135
Same keywords, top 100	300,000	Infrastructure, $2,750	$1,485, right at the 10,000 per day cap
12,000 requests a month, all fired in one hour	12,000	Searcher, $725; Production, $150, if spread over four hours	Over the 10,000 per day cap

Three things follow from the numbers:

• Price is not the reason to pick SerpApi. At list price, $5 per 1,000 on Custom Search undercuts every SerpApi plan below Cloud 1M. You choose SerpApi because Custom Search is closing and returns different data.
• Plans are steps. Going from 30,000 to 30,001 searches a month moves you from $275 to $725. Check how close your forecast sits to a boundary.
• The busiest hour can set the plan. The pricing page calls the hourly figure guaranteed throughput, and the error codes page returns 429 when requests exceed the hourly throughput limit. Plan to that number, not to the monthly one.

If you want to compare more than these two vendors on depth and the num=100 change, our Google SERP API guide prices Serper, SearchApi, and DataForSEO next to SerpApi.

What breaks in production?

SerpApi documents four behaviors worth handling before launch:

1. A 429 has two causes. The status codes page returns 429 when requests exceed the hourly throughput limit or when the account has run out of searches. The second case carries the message Your account has run out of searches, so read the error field before choosing between backing off and paging someone.
2. An empty result is a success. A query with no results returns HTTP 200, search_metadata.status of Success, an organic_results_state of Fully empty, and a top-level error reading that Google has not returned any results for the query. A client that treats any error key as a failure will alert on a normal outcome. A client that indexes organic_results without a default will raise an exception.
3. A failure is reported, and not billed. A failed search carries status Error and, in SerpApi's example, HTTP 503. Errored and failed searches do not count toward your monthly total.
4. The cache hides change. An identical request within an hour returns the cached copy. For rank tracking, set no_cache=true when you need a fresh fetch, and expect it to use a search.

On the Custom Search JSON API the limits sit in the parameters and the configuration:

• Depth stops at 100. num is capped at 10, Google states the API never returns more than 100 results for a query, and a start plus num above 100 produces an error. A pagination loop needs an explicit stop.
• The daily cap is a ceiling. A job that needs more than 10,000 queries a day cannot run on this API, and after January 1, 2027 nothing can.
• Engine settings live outside your code. The whole-web toggle, site list, and annotations are set in the control panel, so record their state in your runbook.

On either API, treat an empty result, a throttle, and a quota failure as three separate signals, and alert on error rates by type.

What are the legal and platform risks?

SerpApi's access to Google's results is contested in court. Google sued SerpApi on December 19, 2025 in the Northern District of California (Google LLC v. SerpApi, LLC, No. 4:25-cv-10826-YGR), alleging that SerpApi circumvented SearchGuard, a bot-detection measure Google launched in January 2025, in violation of the DMCA. On July 20, 2026 the court granted SerpApi's motion to dismiss. It dismissed without leave to amend the claims that rest on results with no copyrighted content, and with leave to amend the claims that rest on results with a copyrighted component, such as licensed images in a Knowledge Panel.

Google filed an amended complaint on August 10, 2026, and SerpApi moved to dismiss it on August 24. Briefing finished on September 29. On October 5 the court vacated the October 13 hearing and said it may reset the hearing or decide on the papers. As of that docket update there is no ruling. A dismissal at the pleading stage is not a finding that scraping Google is lawful, and the case is not over. The public docket has the current state, and our SERP scraping versus web search API guide covers the wider platform risk.

SerpApi's answer to customers is its U.S. Legal Shield, which its pricing page describes as up to $2 million in coverage for the scraping and parsing of search engine data, as long as your use of the data or service is not illegal. The plan data marks it on Production and above, and not on Free, Starter, or Developer.

The practical response is architectural. Put the provider behind an interface, keep a second SERP vendor tested, and have counsel read the terms against your use. The Custom Search JSON API is Google's own product, so its risk is the shutdown date, not a dispute with Google.

Which workload belongs to which API?

Workload	Better fit	Why
Rank tracking and SERP feature monitoring	SerpApi or another SERP API	It needs the results page and a position for each result. Custom Search has neither, and Google says its results are unlikely to match google.com.
Search across your own domains, new build	Neither	Custom Search is closed to new customers. Google points to Vertex AI Search for up to 50 domains.
Agent grounding and RAG	Neither	An agent needs open-web results with URLs, snippets, and optionally page text. SerpApi's output=md reformats the same results page data, and Custom Search is closed.

For rank tracking specifically, our SERP tracking API guide builds a rank tracker in Python.

For agents, a web search API fits the job. The You.com Web Search API takes a POST to https://ydc-index.io/v1/search with an X-API-Key header and a JSON body with query and count. It returns results.web items with url, title, description, and snippets, with optional highlights or full-page content. As of October 2026 the billing page lists $5 per 1,000 calls with up to 100 results per call, plus $1 per 1,000 pages crawled live for full-page extraction. It is an independent index, so it returns no Google positions, ads, or local packs. To choose among search APIs for an agent, start with our best web search APIs for AI agents guide.

How do you size the choice before you commit?

1. Count requests, not keywords. Multiply keywords by checks per month by pages per check. Depth 100 is ten pages.
2. Find your busiest hour. Compare it with the per-hour column, not just the monthly count.
3. Replay real queries. Compare top-10 URLs against what your users see, and set location, gl, hl, and device explicitly so the comparison is repeatable.
4. Test the failure paths. Send a query with no results, force a burst past the hourly limit, and confirm your client tells the 200 with an error, the two 429 causes, and a failed search apart.
5. Swap the provider. Change the provider behind your interface and confirm nothing else changes. If leaving SerpApi later is on the table, our SerpApi alternative guide covers what to test.

Save the script below as serp_planner.py and run python3 serp_planner.py. It runs its checks and prints the three workloads above with no network calls. The plan table is a snapshot from October 10, 2026, so update it before you rely on the output.

"""Size a SerpApi plan and, for existing customers, price the same load on Google CSE.

Offline only: `python3 serp_planner.py` runs the checks and prints three worked examples.
SERPAPI_PLANS is a snapshot of serpapi.com/pricing taken on 2026-10-10. Re-check it before use.
"""
import math

# (plan, USD per month, searches per month, guaranteed successful searches per hour)
SERPAPI_PLANS = [
    ("Free", 0, 250, 50),
    ("Starter", 25, 1_000, 200),
    ("Developer", 75, 5_000, 1_000),
    ("Production", 150, 15_000, 3_000),
    ("Big Data", 275, 30_000, 6_000),
    ("Searcher", 725, 100_000, 20_000),
    ("Volume", 1_475, 250_000, 50_000),
    ("Infrastructure", 2_750, 500_000, 100_000),
    ("Cloud 1M", 3_750, 1_000_000, 110_000),
]

CSE_FREE_PER_DAY = 100      # Custom Search JSON API overview, existing customers only
CSE_USD_PER_1000 = 5.0
CSE_MAX_PER_DAY = 10_000
CSE_MAX_RESULTS = 100       # cse.list: start + num may not exceed 100


def pages_needed(depth, page_size=10):
    """Results are fetched ten at a time, so depth 100 means ten requests."""
    if depth < 1:
        raise ValueError("depth must be at least 1")
    return math.ceil(depth / page_size)


def monthly_requests(keywords, checks_per_month, depth):
    return keywords * checks_per_month * pages_needed(depth)


def serpapi_plan(requests_per_month, peak_per_hour=0):
    """Cheapest listed plan that fits the monthly count AND the busiest hour."""
    for name, usd, searches, per_hour in SERPAPI_PLANS:
        if searches >= requests_per_month and per_hour >= peak_per_hour:
            return {"plan": name, "usd": usd, "searches": searches, "per_hour": per_hour}
    return None  # beyond this table: ask SerpApi for a quote


def cse_monthly_usd(requests_per_day, depth=10, days=30):
    """Existing CSE customers only. None means the load breaks a documented limit."""
    if depth > CSE_MAX_RESULTS or requests_per_day > CSE_MAX_PER_DAY:
        return None
    return max(0, requests_per_day - CSE_FREE_PER_DAY) * days * CSE_USD_PER_1000 / 1000.0


def check():
    assert pages_needed(10) == 1 and pages_needed(100) == 10 and pages_needed(11) == 2
    assert monthly_requests(1_000, 30, 10) == 30_000
    assert monthly_requests(1_000, 30, 100) == 300_000
    assert serpapi_plan(30_000)["plan"] == "Big Data"
    assert serpapi_plan(30_001)["plan"] == "Searcher"          # plans are step functions
    assert serpapi_plan(300_000)["plan"] == "Infrastructure"
    assert serpapi_plan(12_000)["plan"] == "Production"
    assert serpapi_plan(12_000, peak_per_hour=12_000)["plan"] == "Searcher"  # burst sets the plan
    assert serpapi_plan(2_000_000) is None
    assert cse_monthly_usd(100) == 0.0
    assert cse_monthly_usd(1_000) == 135.0
    assert cse_monthly_usd(10_000) == 1_485.0
    assert cse_monthly_usd(10_001) is None
    assert cse_monthly_usd(1_000, depth=101) is None
    try:
        pages_needed(0)
    except ValueError:
        pass
    else:
        raise AssertionError("depth 0 was accepted")


def show(label, keywords, checks, depth, peak_per_hour=0, cse=True):
    need = monthly_requests(keywords, checks, depth)
    plan = serpapi_plan(need, peak_per_hour)
    print(label)
    print("  requests per month:", need)
    print("  SerpApi:", plan or "ask for a quote")
    if cse:  # spread evenly over 30 days
        usd = cse_monthly_usd(need / 30.0, depth)
        print("  CSE (existing customers):", "over a documented limit" if usd is None else "$%.0f" % usd)


if __name__ == "__main__":
    check()
    print("checks passed, 0 network calls")
    show("1,000 keywords, daily, top 10", 1_000, 30, 10)
    show("1,000 keywords, daily, top 100", 1_000, 30, 100)
    show("12,000 requests a month, all in one hour", 12_000, 1, 1, peak_per_hour=12_000, cse=False)

We checked the script with py_compile and its built-in assertions. No live requests were made, so prices, relevance, and latency still need your own test.