Custom Search JSON API Alternative: Migration Guide Before the 2027 Deadline
Michael Carter · · 20 min read · Last updated

Key takeaways
- Google's Custom Search JSON API is closed to new customers, and existing customers have until January 1, 2027 to move; Google suggests Vertex AI Search for up to 50 domains and a contact form for full web search.
- Most cse.list parameters translate directly: q, gl and hl keep their names, start becomes page, dateRestrict d1, w1, m1 and y1 become tbs, and searchType=image becomes the /images endpoint; siteSearch becomes a site: operator, which misbehaved in our November 2026 tests.
- Some Custom Search features have no BestSERP equivalent: pagemap, totalResults, safe, lr, cr, image filters and results deeper than 50.
- In 12 web searches on November 17, 2026, 112 of 115 BestSERP organic links stayed Google redirects; since a fix on November 18, polling returns final URLs, usually within 30 seconds, and the domain field remains the key for matching sites.
- At 1,000 searches a day, the Custom Search JSON API costs $135 a month above its free tier; BestSERP costs $15 at $0.50 per 1,000 searches.
Google's Custom Search JSON API is closed to new customers, and existing customers have until January 1, 2027 to move. The right Custom Search JSON API alternative depends on scope: Vertex AI Search for up to 50 domains, Google's full web search offer on request, or a SERP API such as BestSERP at $0.50 per 1,000 searches.
This guide is for developers whose code calls cse.list today. You get Google's notice with its dates, a mapping of every parameter and response field (gaps included), tested Python and JavaScript code, costs and a checklist. New to the term? Read what a SERP API is; for other providers, see our comparison of the best SERP APIs.
What Google announced, and when
Google's Custom Search JSON API overview states the change in four sentences (checked November 17, 2026):
"The Custom Search JSON API is closed to new customers."
"Existing Custom Search JSON API customers have until January 1, 2027 to transition to an alternative solution."
"Vertex AI Search is a favorable alternative for searching up to 50 domains."
"Alternatively, if your use case necessitates full web search, contact us to express your interest in and get more information"
The same page says its prices apply "only to existing Custom Search JSON API customers until the service discontinuation on January 1, 2027": 100 queries a day free, then $5 per 1,000, up to 10,000 a day.
Google first announced the change on the Programmable Search Engine blog on January 20, 2026. From that day, every new engine must use "Sites to search" (at most 50 domains), and existing engines keep "Search the entire web" only until January 1, 2027.

Neither page says what the endpoint will return after the deadline, so plan as if every request fails from January 1.
Who needs a Custom Search JSON API alternative?
You need one if anything you run calls customsearch/v1: your own code, google-api-python-client, or a plugin that asks for a "Google API key" and a "search engine ID" (cx). The JSON API ends for every engine, however it is configured.
| What you use | Affected? | What happens |
|---|---|---|
| Custom Search JSON API, any engine | Yes | Move by January 1, 2027 |
| Programmable Search Element (the embedded search box), up to 50 domains | No | Stays free for site search |
| Search Element set to "Search the entire web", or over 50 domains | Yes | Move by January 1, 2027 |
| An engine created after January 20, 2026 | Already limited | "Sites to search" only, at most 50 domains |
If your users only search your own sites through the embedded box, you may not need an API at all.
Choosing a Custom Search JSON API alternative: three options
Google suggests two replacements, and SERP APIs are a third; each searches something different.
| Vertex AI Search | Google's full web search offer | SERP API (BestSERP) | |
|---|---|---|---|
| What it searches | Up to 50 domains you index | The whole web | Google's results page for any query |
| How to start | Cloud project, data store, search app | Contact form on Google's overview page | API key, first request in minutes |
| Price, checked 2026-11-17 | $4.00 per 1,000 queries, 10,000 free a month | Not published | $0.50 per 1,000 searches, 3,000 free |
| Best for | Search on your own sites | A contract with Google | Whole-web searches done through CSE |
Vertex AI Search is Google Cloud's managed search over content you index. Website search is in its Search Enterprise Edition, which the Vertex AI Search pricing page (now titled "Agent Search pricing") lists at $4.00 per 1,000 queries after 10,000 free a month, plus storage at 500 KiB per indexed page. It suits engines that used "Sites to search", not whole-web search.
Google's full web search offer has no public price or terms; the only way in is the contact form on the overview page, so ask now if you want it before January 1.
A SERP API runs your query on Google and returns the results page as JSON. BestSERP, the Google SERP API we run, is one of several providers and is not affiliated with Google. You get what a desktop Google results page shows for a country and language, not an index you configure; the Google Search API page lists what it returns, and the sections below show every difference from CSE.
Parameter mapping: cse.list to BestSERP
Each cse.list parameter keeps its name, moves into the query as a Google search operator, or has no equivalent. The table covers every parameter in Google's cse.list reference, checked against BestSERP's web search reference on November 17, 2026.

| cse.list parameter | BestSERP | Notes |
|---|---|---|
key |
X-API-KEY header |
Keys in URLs are refused |
cx |
Not needed | Sending it returns 400 unknown_parameter |
q |
q |
1 to 256 characters |
num (1-10) |
num (10, 20, 30, 40 or 50) |
num: 5 is refused: ask for 10 and slice |
start |
page (1-5) |
start=11 is page: 2; see pagination below |
gl |
gl |
CSE boosts that country's results; BestSERP searches as seen from it |
hl |
hl |
Interface language in both |
lr, cr |
None | gl and hl change the market but do not filter |
siteSearch |
site:example.com in q |
Exclude with -site:; read the note below |
dateRestrict |
tbs |
d1, w1, m1, y1 become qdr:d, qdr:w, qdr:m, qdr:y |
exactTerms |
"phrase" in q |
Tested: worked |
excludeTerms, orTerms, hq |
-word, (a OR b), extra words in q |
Google operators |
fileType |
filetype:pdf in q |
Tested: worked |
searchType=image |
The /images endpoint |
Different fields |
imgSize, imgType, imgColorType, imgDominantColor, rights |
None | Image filters are not supported yet |
safe |
None | No SafeSearch parameter |
lowRange, highRange |
Not tested | Try the range in q |
sort, filter, linkSite, c2coff |
None | Unknown parameters are refused |
googlehost, relatedSite |
None | Deprecated by Google |
Operators reach Google exactly as you write them in q; our guide to Google search operators lists which ones still work.
Pagination: replace start loops with one request
CSE returns at most 10 results per call, so code that wants 30 results loops over start=1, 11 and 21. BestSERP bills every page up to the one you ask for: page: 2 costs 2 credits and page: 3 costs 3, yet each response holds only that page. Translated literally, the loop costs 6 credits; one request with num: 30 costs 3.
Our tests showed two more differences. Page 1 of "python asyncio tutorial" held 9 organic results, so page: 2 started at position 10, not 11. And BestSERP goes at most 50 results deep (page × num/10 ≤ 5), while CSE went to 100: start values of 51 and above have no equivalent.
siteSearch: use site:, then check the domain
siteSearch=example.com becomes the site: operator in front of the query, as you would type it on google.com. The adapter below also drops any result whose domain is not on that site.
That safety net is there for a reason. While writing this guide we ran four site: searches through BestSERP, and none came back right: two returned pages from the site that ignored the keywords, and two returned results for "api" alone, ignoring the site and the word "fetch". Quoted phrases and filetype: worked in the same session. It is a known issue we are investigating as of November 17, 2026; until the changelog lists a fix, test your own site searches before you switch.
dateRestrict: four exact values
tbs accepts one window each for the past hour, day, week, month and year, so only d1, w1, m1 and y1 have exact equivalents. Values such as d7 or m6 have none, and BestSERP refuses qdr:d7 with 400 invalid_request. Use the nearest window that covers yours (qdr:w for d7, qdr:y for m6). In our test, tbs: "qdr:w" returned 10 results whose visible dates were 1 to 6 days old.
searchType=image: the /images endpoint
Image searches move to their own endpoint, described on the Google Images API page. One request in our test returned 100 images with full-size URL, size, thumbnail, page link and domain, for 1 credit; CSE returns at most 10 per call.
Response field mapping: items[] to organic[]
Most fields keep their meaning under a similar name; a few have no counterpart. The table maps the Search resource that cse.list returns to BestSERP's response.
| Custom Search field | BestSERP field | Notes |
|---|---|---|
items[] |
organic[] |
Plus videos[] and news[] when the page shows them |
items[].title |
title |
Plain text |
items[].link |
link |
A Google redirect until links are resolved, see below |
items[].displayLink |
domain |
Can be missing |
items[].snippet |
snippet |
May start with a date |
items[].formattedUrl |
displayedLink |
Google's URL line, or a date on videos |
items[].htmlTitle, htmlSnippet |
None | Bold the query terms yourself |
items[].pagemap, cacheId, mime, fileFormat, labels |
None | No structured data from the page |
| None | position, source |
Rank from 1, and the site name |
items[].link (image search) |
imageUrl |
Plus imageWidth, imageHeight, thumbnailUrl |
items[].image.contextLink |
link (in /images) |
The page that shows the image |
searchInformation.totalResults |
None | Count the results you received |
searchInformation.searchTime |
durationMs |
Milliseconds instead of seconds |
queries.request |
searchParameters |
Your request with defaults filled in |
queries.nextPage |
None | Compute the next page yourself |
spelling.correctedQuery |
None | autocorrect is accepted and has no effect |
promotions, context |
None | Features of a CSE engine |
Links and domains: the difference to plan for
CSE describes its link as the full URL the result points to. In BestSERP's first answer, link often is not: Google serves many result links as google.com/goto?... redirects, and BestSERP replaces them with final URLs after answering (how link resolution works). While linksPending is true, poll GET /requests/{requestId}; final links usually arrive within 30 seconds, at most 2 minutes, and unresolvedLinks counts any left as redirects. The redirects open the page, but they are not its address.
Across the 12 web searches we ran for this guide on November 17, 2026, 112 of 115 organic links were still redirects after resolution had finished, and 21 of 115 results had no domain: YouTube videos, Medium and LinkedIn posts and Stack Overflow threads, where Google shows a channel or date instead of a URL. All 100 image results had a final page link and a domain. The redirects were a link-resolution bug, fixed on November 18, 2026: in 61 searches through the public API that day, polling turned all 401 pending redirects into final URLs, median 34 seconds and at most 54 seconds after the request.
What to change in your code:
- Match sites on
domain, notlink. It is in the first answer, without waiting for link resolution. Stripwww.before comparing: image results keep it, web results do not. - Fall back to
sourcewhendomainis missing. It holds the site name, such as "Stack Overflow". - Poll for final URLs. If your code stores or opens each result's address, poll until
linksPendingis false, for up to 2 minutes, before readinglink. The adapter below returns the first answer, so add that wait if you need it.
Before and after code
The before code is a typical integration, based on Google's own sample. We could not run it: the API is closed to new customers, so we have no key. The after code ran against BestSERP on November 17, 2026.
Before: your Custom Search call (not run)
Based on Google's Python sample for Custom Search (Apache 2.0):
# Existing code, shown for reference only: not run (the API is closed to new customers).
from googleapiclient.discovery import build
service = build("customsearch", "v1", developerKey="YOUR_GOOGLE_API_KEY")
res = service.cse().list(q="python requests timeout", cx="YOUR_CX", num=10).execute()
for item in res.get("items", []):
print(item["displayLink"], "|", item["title"])
The same request over REST from Node.js:
// Existing code, shown for reference only: not run (the API is closed to new customers).
const params = new URLSearchParams({ key: process.env.GOOGLE_API_KEY, cx: "YOUR_CX",
q: "node fetch timeout", dateRestrict: "y1" });
const res = await fetch(`https://www.googleapis.com/customsearch/v1?${params}`);
const { items = [] } = await res.json();
items.forEach((item) => console.log(item.displayLink, "|", item.title));
After: Python
The adapter takes the same keyword arguments as cse.list and returns items[] in the Custom Search shape, so the code that reads results does not change. Tested with Python 3.12.10 and requests 2.34.2; create a key (quickstart) and set it as BESTSERP_API_KEY. The first half translates parameters and sends the request: it polls 202, waits out 429 and retries 502 and 503, which are refunded.
import os
import time
import requests
API = "https://api.bestserp.com"
HEADERS = {"X-API-KEY": os.environ["BESTSERP_API_KEY"]}
DATE_RESTRICT = {"d1": "qdr:d", "w1": "qdr:w", "m1": "qdr:m", "y1": "qdr:y"} # exact equivalents only
def to_bestserp(q, start=1, num=10, siteSearch=None, siteSearchFilter="i",
dateRestrict=None, gl="us", hl="en", searchType=None):
"""Translate cse.list parameters into a BestSERP path and JSON body."""
if siteSearch:
q = f"{'-' if siteSearchFilter == 'e' else ''}site:{siteSearch} {q}"
body = {"q": q, "gl": gl, "hl": hl}
if dateRestrict:
if dateRestrict not in DATE_RESTRICT:
raise ValueError(f"no exact BestSERP equivalent for dateRestrict={dateRestrict!r}")
body["tbs"] = DATE_RESTRICT[dateRestrict]
if searchType == "image":
return "/images", body
page = (start - 1) // 10 + 1 # start=11 -> page 2 (pages 1..2 are charged)
if page > 1:
body["page"] = page
return "/search", body
def post(path, body, tries=3):
"""POST a search; poll 202, wait and retry 429/502/503 (502 and 503 are refunded)."""
for attempt in range(tries):
r = requests.post(API + path, headers=HEADERS, json=body, timeout=130)
while r.status_code == 202: # still running: polling is free
time.sleep(2)
r = requests.get(f"{API}/requests/{r.json()['requestId']}", headers=HEADERS, timeout=130)
if r.status_code in (429, 502, 503) and attempt < tries - 1:
time.sleep(int(r.headers.get("Retry-After", 5)))
continue
r.raise_for_status()
return r.json()
The second half reshapes the response and replaces service.cse().list(...).execute():
def cse_list(**params):
"""Drop-in for service.cse().list(**params).execute(): returns items[] like Custom Search."""
params.pop("cx", None) # no search engine ID: BestSERP searches all of Google
path, body = to_bestserp(**params)
data = post(path, body)
if path == "/images":
items = [{"title": i.get("title"), "link": i.get("imageUrl"), "displayLink": i.get("domain"),
"image": {"contextLink": i.get("link"), "width": i.get("imageWidth"),
"height": i.get("imageHeight"), "thumbnailLink": i.get("thumbnailUrl")}}
for i in data.get("images", [])]
else:
items = [{"title": r.get("title"), "link": r.get("link"), "displayLink": r.get("domain"),
"snippet": r.get("snippet"), "formattedUrl": r.get("displayedLink"),
"source": r.get("source")} # not in CSE: the site name, also on video results
for r in data.get("organic", [])]
site = params.get("siteSearch")
if site and params.get("siteSearchFilter", "i") == "i": # safety net: keep on-site results only
items = [i for i in items if (i["displayLink"] or "").endswith(site.removeprefix("www."))]
return {"items": items[: params.get("num", 10)],
"searchInformation": {"totalResults": None}, # BestSERP has no result count
"bestserp": {k: data.get(k) for k in ("requestId", "credits", "cached", "unresolvedLinks")}}
if __name__ == "__main__":
res = cse_list(q="python requests timeout", cx="YOUR_CX", num=10)
for n, item in enumerate(res["items"], 1):
print(n, item["displayLink"] or f"({item['source']})", "|", item["title"][:50])
print("first link:", res["items"][0]["link"][:60])
print(res["bestserp"])
The output of our run (US, English):
1 github.com | requests.put() does not respect timeout when data
2 (Stack Overflow) | Why "requests" module timeout doesn't work in pyth
3 (Medium · Krishna Mishra) | Handling HTTP Request Timeouts in Python
4 community.openai.com | How to set a timeout on an API function call using
5 (YouTube · The Python Oracle) | Timeout for python requests.get entire response
6 (Medium · Annabelle) | How to Use Proxies in Python Requests (Auth, Timeo
7 community.openai.com | Timeout not honored in Python API?
8 github.com | add configurable HTTP request timeout · Issue #100
9 endpoint51.com | Python requests: Timeouts, Retries, and Backoff Do
first link: https://www.google.com/goto?url=CAESaAHEIkXXck3VVXYtG1Gok59b
{'requestId': '0757a8ee-11b1-49a4-96f3-dee0a2114b1e', 'credits': 1, 'cached': False, 'unresolvedLinks': 9}
Note three things: Google showed 9 results, not 10; four had no domain, so the site name from source is printed in parentheses; and every link was a Google redirect (unresolvedLinks: 9). The adapter returns the first answer, which usually still holds redirects today; poll as described above when you need final URLs.
After: JavaScript (Node 18+)
The same adapter with Node's built-in fetch, tested with Node 22.17.1. This run translates dateRestrict: "y1" to tbs: "qdr:y".
const API = "https://api.bestserp.com";
const HEADERS = { "X-API-KEY": process.env.BESTSERP_API_KEY, "Content-Type": "application/json" };
const DATE_RESTRICT = { d1: "qdr:d", w1: "qdr:w", m1: "qdr:m", y1: "qdr:y" }; // exact equivalents only
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
function toBestSerp({ q, start = 1, siteSearch, siteSearchFilter = "i", dateRestrict, gl = "us", hl = "en", searchType }) {
if (siteSearch) q = `${siteSearchFilter === "e" ? "-" : ""}site:${siteSearch} ${q}`;
const body = { q, gl, hl };
if (dateRestrict) {
if (!DATE_RESTRICT[dateRestrict]) throw new Error(`no exact BestSERP equivalent for dateRestrict=${dateRestrict}`);
body.tbs = DATE_RESTRICT[dateRestrict];
}
if (searchType === "image") return ["/images", body];
const page = Math.floor((start - 1) / 10) + 1; // start=11 -> page 2 (pages 1..2 are charged)
if (page > 1) body.page = page;
return ["/search", body];
}
async function post(path, body, tries = 3) {
for (let attempt = 0; attempt < tries; attempt++) {
let res = await fetch(API + path, { method: "POST", headers: HEADERS, body: JSON.stringify(body) });
while (res.status === 202) { // still running: polling is free
const { requestId } = await res.json();
await sleep(2000);
res = await fetch(`${API}/requests/${requestId}`, { headers: HEADERS });
}
if ([429, 502, 503].includes(res.status) && attempt < tries - 1) { // 502 and 503 are refunded
await sleep(1000 * Number(res.headers.get("retry-after") ?? 5));
continue;
}
if (!res.ok) throw new Error(`BestSERP ${res.status}: ${await res.text()}`);
return res.json();
}
}
export async function cseList({ cx, num = 10, ...params }) { // cx is not needed: BestSERP searches all of Google
const [path, body] = toBestSerp(params);
const data = await post(path, body);
const items = path === "/images"
? (data.images ?? []).map((i) => ({ title: i.title, link: i.imageUrl, displayLink: i.domain,
image: { contextLink: i.link, width: i.imageWidth, height: i.imageHeight, thumbnailLink: i.thumbnailUrl } }))
: (data.organic ?? []).map((r) => ({ title: r.title, link: r.link, displayLink: r.domain,
snippet: r.snippet, formattedUrl: r.displayedLink, source: r.source }));
const site = params.siteSearch?.replace(/^www\./, ""); // safety net: keep on-site results only
const kept = site && params.siteSearchFilter !== "e" ? items.filter((i) => (i.displayLink ?? "").endsWith(site)) : items;
const { requestId, credits, cached, unresolvedLinks } = data;
return { items: kept.slice(0, num), searchInformation: { totalResults: null },
bestserp: { requestId, credits, cached, unresolvedLinks } };
}
const res = await cseList({ q: "node fetch timeout", cx: "YOUR_CX", dateRestrict: "y1" });
res.items.forEach((item, n) => console.log(n + 1, item.displayLink ?? `(${item.source})`, "|", item.title.slice(0, 55)));
console.log(res.bestserp);
Save it as cse_to_bestserp.mjs (top-level await needs an ES module) and run node cse_to_bestserp.mjs. Our output:
1 apitraffic.io | Node.js Server Timeouts: Defaults and Safe Settings
2 linkedin.com | Node.js Fetch Request Timeout Does Not Cancel ...
3 qiita.com | Node.jsのfetchにタイムアウトを入れる:AbortSignal.timeoutと ...
4 dev-talk.com | JavaScript fetch with timeout using AbortSignal.timeout
5 instagram.com | Stop a hanging fetch in Node.js with one line fetch has
6 samuelfaj.com | Timeout en fetch de Node.js con AbortSignal
7 linkedin.com | Fixing fetch() timeout in JavaScript | Ramanpal Singh .
8 penbeam.com | JavaScript Fetch Timeout & Errors — Snippet
9 npblue.com | JavaScript Fetch and APIs: Requests, JSON, Errors, ...
10 smartinsightly.com | JavaScript Fetch Timeout: Cancel Slow Requests and Hand
{
requestId: 'e98bd0d1-4edc-429e-ae70-000ae07c6932',
credits: 1,
cached: false,
unresolvedLinks: 10
}
Every dated snippet fell inside the past year (August to November 2026). Our first attempt got three 502 answers in a row; a retry seconds later worked.
What will it cost? $5 vs $0.50 per 1,000 searches
At published prices, BestSERP costs a tenth of what existing CSE customers pay above the free tier, with no daily cap. Both bill per 10 results: one CSE query returns up to 10, and one BestSERP credit pays for one page (num: 30 costs 3).
| Searches per day | Per month (30 days) | Custom Search JSON API | BestSERP |
|---|---|---|---|
| 100 | 3,000 | $0 (inside 100 free a day) | $1.50 (the first 3,000 are free) |
| 1,000 | 30,000 | $135 | $15 |
| 10,000 | 300,000 | $1,485 | $150 |
| 50,000 | 1,500,000 | Not possible (10,000 a day cap) | $750 |
- Custom Search JSON API: (searches per day minus 100 free) × 30 days × $5 per 1,000, from Google's overview page, checked November 17, 2026.
- BestSERP: $0.50 per 1,000 searches, per the pricing page. The 3,000 free searches come once, at sign-up, and last 30 days; purchased credits never expire, and failed searches are refunded. 50,000 a day is about 35 searches a minute, inside the default limit of 60.
At 100 searches a day, CSE's free tier was cheaper, but it ends on January 1. Vertex AI Search would cost about $80 a month at 30,000 queries, plus storage, for your indexed domains only.
Migration checklist and timeline
On November 17, 2026, 45 days remained: enough for most integrations that start at once.
- Inventory every call (now). Search code and configuration for
customsearch,cse().listandcx=, plugins included. List the parameters each call sends and the fields it reads. - Choose a Custom Search JSON API alternative per use case (by November 30). Your own sites: Vertex AI Search or the free Search Element. The whole web: Google's offer (contact Google now) or a SERP API.
- Mark the gaps. Flag every "None" row from the mapping tables that you use:
pagemap,totalResults,safe,lr,cr, image filters, results deeper than 50. - Build the adapter behind a switch, keeping the CSE response shape so callers do not change.
- Run both side by side (first week of December). Compare which domains appear, not exact links or order.
- Fix matching and pagination. Match on
domainwithsourceas a fallback, and replacestartloops with onenumrequest. - Test errors and limits. Poll
202, wait out429, retry502and503, never retry400, and stay under 60 searches a minute. - Cut over by mid-December, keeping the CSE path as a fallback until December 31.
- Clean up after January 1, 2027. Delete the Google API key, the engine IDs and the fallback.
Common migration problems and fixes
The errors and surprises we hit, or that the mapping predicts:
| Problem | Cause | Fix |
|---|---|---|
400 unknown_parameter: start |
CSE names such as start, cx, lr, safe |
Translate or remove them |
400 invalid_request: num must be between 10 and 50 |
CSE allows num from 1 to 10 |
Ask for 10 and slice |
400: page x num/10 must be at most 5 |
Deeper than 50 results | Stop at 50 results |
400: tbs must be one of qdr:h, qdr:d, qdr:w, qdr:m, qdr:y |
A dateRestrict such as d7 |
Use the nearest window |
displayLink is empty |
No domain on video and social results until their final links arrive |
Fall back to source |
Links start with https://www.google.com/goto? |
Read before link resolution finished (linksPending: true) |
Poll until linksPending is false (up to 2 minutes); match sites on domain |
| The bill is higher than expected | page: 3 charges pages 1 to 3 |
One request with num: 30 |
site: results ignore the keywords |
The bug described above | Test first; keep the domain filter |
502 search_failed or 503 busy |
Blocked, timed out or busy | Retry; the credit is refunded |
429 rate_limited |
Over 60 searches in a minute | Wait for Retry-After |
More status codes and their credit rules are on the errors page.
How we tested
We read every Google page cited here on November 17, 2026. We could not call the Custom Search JSON API, so the before code is Google's documented usage, not a run.
On BestSERP we sent 13 paid searches that day (12 web, 1 image, all gl=us, hl=en) and 6 free requests that checked error messages. They covered the code runs, page: 2, tbs windows, quoted phrases with filetype:, four site: queries and the image search; 2 of the web searches were our keyword research. The link and domain counts cover all 115 organic results. On November 18, 2026 we re-ran the start=11, dateRestrict=w1 and image checks (4 credits) with a 2-minute wait for final links: all 17 organic links were final URLs, after 45 and 19 seconds. Code ran on Windows with Python 3.12.10 (requests 2.34.2) and Node.js 22.17.1.
Next steps
Pick your Custom Search JSON API alternative by what your users search, then work through the checklist while weeks remain.
- Comparing providers: the best SERP API options, and whether Google offers any official search API.
- Also replacing Microsoft's retired service: the Bing Search API alternative guide.
- Ready to code: the quickstart, the Google Search API page and current prices.