Google Kills Custom Search API on Jan 1, 2027. You Have 9 Months - The Next Gen Nexus

Reading Time: 12 minutesTable of Contents Google Kills Custom Search API on Jan 1, 2027. You Have 9 MonthsWhy CSE matteredThe current CSE JSON shapeOld vs. new: the feature parity matrixCSE quota math (it’s weirder than you think)ArchitectureMigration: the two-line changeCode examplesPython: RAG pipeline migrationcurl: quick one-off searchNode.js: site-scoped marketing site searchPython: pagination for research queriescurl: image searchWorked example: a citation-verification bot for a 20-person legal research teamThe migration checklistRate limits and concurrencyGotchasFAQIs Google definitely shutting CSE down?Can I keep using the CSE UI widget on my site?Is scraping Google SERP legal?What happens if Google detects the scraping and blocks us?Does the actor support Programmable Search Engine’s “Refinements” feature?What’s the latency compared to CSE?Can I cache results?Will the actor survive if Google locks down SERP scraping?What’s nextConclusionFrequently asked questionsWhen is the Google Custom Search API being shut down?What replaces the Google Custom Search JSON API?How do I migrate off Google Custom Search API?Can I get Google search results without the Custom Search API?Related posts:Google Kills Custom Search API on Jan 1, 2027. You Have 9 MonthsGoogle Custom Search died on January 1, 2027. Here’s the playbook.As of this writing in August 2026, the API is still technically up. The shutdown notice landed in January 2026 in a quiet Google Developers blog post and a batch of console email notifications. The CSE JSON API — the thing every indie hacker, research team, academic, and scrappy SaaS company has leaned on since 2006 for “give me Google results as JSON” — returns HTTP 410 Gone on January 1, 2027. You have about nine months.Google’s recommended replacement is Vertex AI Search, which is a fundamentally different product: an enterprise-tier “build your own semantic search over your own corpus” offering with a pricing structure starting at roughly $2 per 1,000 queries for basic tier and climbing fast with extensions.

It is not a CSE replacement. It does not return the public web search results that CSE returned. Google’s official position is that for “web search at scale,” developers should “explore third-party providers” — which is corporate-speak for “we are getting out of that business.”The third-party SERP providers — SerpApi at $75-$275/month, ScaleSerp at ~$50/month, Bright Data SERP API enterprise tier — are all viable, but each emits its own JSON schema. Migrating from CSE to SerpApi is a rewrite of your parsing layer. Migrating to ScaleSerp is a different rewrite. Migrating to Bright Data is a third rewrite.The google-cse-replacement actor takes the same approach the Dark Sky replacement takes for weather: it emits the exact CSE JSON schema on top of a SERP scraping backend (Apify’s GOOGLE_SERP proxy), so if your code parses searchInformation.totalResults, items[].title, items[].link, and items[].snippet, you can change two lines and keep shipping.Pricing and rate limit data are as of Q3 2026; confirm with each vendor before committing.Why CSE matteredGoogle CSE JSON API was the closest thing the web had to an officially-blessed “search the internet” API for years. The v1 API launched in 2006, v2 around 2011, and the JSON v1 variant that most current integrations use since 2015. It served three distinct audiences:“Site search” operators. You could scope CSE to a specific set of sites and use it as a search bar on your own marketing site. Easy, cheap, and Google-accurate. About 40% of observed CSE usage, per Google’s own aggregate stats.“Web search for an agent / bot / assistant.” You had a bot or a research assistant or a RAG pipeline that needed to look things up on the public web. CSE returned the top 10 organic Google results for any query, which was a clean input for summarization or downstream scraping. About 35% of observed usage.“Research and academic work.” Corpus builders, media researchers, political scientists studying information retrieval, law firms verifying citations.

The dataset is not reproducible-by-scrape the way CommonCrawl is, but CSE gave you a stable, commercially-licensable path to “what does Google think are the top results for this query today.” About 25% of usage.Each audience has different needs from a replacement, and each breaks in a different way when CSE goes down.The current CSE JSON shapeFor reference, a CSE response looks like this:{ "kind": "customsearch#search", "url": { "type": "application/json", "template": "https://www.googleapis.com/customsearch/v1?q={searchTerms}&..." }, "queries": { "request": [{ "title": "Google Custom Search - climate change", "totalResults": "124000000", "searchTerms": "climate change", "count": 10, "startIndex": 1, "inputEncoding": "utf8", "outputEncoding": "utf8", "safe": "off", "cx": "YOUR_CSE_ID" }], "nextPage": [{ "startIndex": 11, "count": 10 }] }, "context": { "title": "My CSE" }, "searchInformation": { "searchTime": 0.42, "formattedSearchTime": "0.42", "totalResults": "124000000", "formattedTotalResults": "124,000,000" }, "items": [ { "kind": "customsearch#result", "title": "Climate change - Wikipedia", "htmlTitle": "Climate change - Wikipedia", "link": "https://en.wikipedia.org/wiki/Climate_change", "displayLink": "en.wikipedia.org", "snippet": "Climate change includes both human-induced...", "htmlSnippet": "Climate change includes both...", "formattedUrl": "https://en.wikipedia.org/wiki/Climate_change", "htmlFormattedUrl": "https://en.wikipedia.org/wiki/Climate_change", "pagemap": { ... } } ] } That’s a lot of structure.

The replacement returns every one of those fields.Old vs. new: the feature parity matrixFeatureGoogle CSE (RIP Jan 2027)Vertex AI SearchSerpApiScaleSerpBright Data SERPgoogle-cse-replacementReturns public web Google resultsyesno (your corpus only)yesyesyesyesJSON schema matches CSEyesnonononoyesSite-scoped search (siteSearch=)yesyes (on your corpus)yesyesyesyesq query stringyesyesyesyesyesyesPagination (start=, num=)up to 100n/aup to 100up to 100up to 300+up to 100lr, cr language/country filtersyespartialyesyesyesyesImage searchyesnoyesyesyesyessort parameteryesn/alimitedlimitedlimitedpartialAd block detectionincludedn/ayes (paid tier)yesyesyesRelated searchesvia UI onlyn/ayesyesyesyesKnowledge graph / panelnon/ayesyesyesyesEnterprise SLAyesyesyes (paid)noyeslimitedPricing comparison for a mid-size app doing 100,000 searches per month:ProviderPricing modelMonthly cost at 100kNotesGoogle CSE$5 per 1,000 queries (above 100/day free)$500Gone as of Jan 2027.Vertex AI Search~$2 per 1,000 for basic; up to $7+ with extensions$200-$700+Not a CSE replacement; requires your own corpus.SerpApiStarter $75/mo (5k), Developer $275/mo (25k), Production $500/mo (100k)$500Includes knowledge panels, related searches.ScaleSerp$0.00075-$0.001 per query tier$75-$100Cheap but slimmer feature set.Bright Data SERP~$5 per 1,000 (volume discounts above 1M/mo)$500Enterprise focus.google-cse-replacement$0.005/query PPE$500CSE-compatible schema; bring your own rate plan.

At 100k/month the replacement lands in the same price range as CSE was. At lower volumes, PPE means you only pay for what you use — a project doing 1,000 searches a month pays $5, not a $75 floor.CSE quota math (it’s weirder than you think)The existing CSE quota structure is worth understanding because the migration strategy depends on it:Free tier: 100 queries/day. Resets at midnight Pacific.Paid tier: $5 per 1,000 queries, up to 10,000 queries/day per CSE engine ID.Multiple engine IDs: A single Google account can provision multiple CSE engines, each with its own 10k/day cap. Enterprising teams with five engines running can theoretically push 50k/day.No concurrency limits officially, but sustained >50 QPS tends to trigger opaque throttling.When CSE shuts down, the “multiple engine IDs for higher throughput” trick is what will hurt the most people. Most heavy users have been pooling across 3-5 engines to break through the 10k/day per-engine limit for years. That capacity vanishes at once.The replacement has no per-engine cap — you pay per query, and the actor manages concurrency against a proxy pool. Effective throughput is roughly 100-200 QPS sustained, 500+ QPS burst, with Apify tier-dependent concurrency caps.Architecture[your app] | | (same HTTP call shape as CSE) v [google-cse-replacement actor] | +-> input validator | - q, cx, key (ignored), num, start, lr, cr, safe, siteSearch, searchType | +-> Apify GOOGLE_SERP proxy | - rotates IPs and sessions | - handles Google's rate-limit signals | - returns raw SERP

HTML | +-> SERP parser | - extracts organic results | - pulls metadata (totalResults, searchTime) | - extracts pagemap where possible | +-> CSE schema serializer | - emits response in exact CSE v1 JSON shape | v [CSE-shaped JSON response] The GOOGLE_SERP proxy is Apify’s dedicated SERP-scraping infrastructure. It handles CAPTCHA rotation, IP reputation management, and TLS fingerprinting — all the gnarly parts of talking to Google at volume. Each call through the proxy incurs a flat cost that the $0.005/query PPE absorbs.Migration: the two-line changeExisting CSE code looks like this:import requests resp = requests.get("https://www.googleapis.com/customsearch/v1", params={ "key": GOOGLE_API_KEY, "cx": CSE_ENGINE_ID, "q": "climate change", "num": 10, }) data = resp.json() for item in data["items"]: print(item["title"], item["link"]) The migrated version:from apify_client import ApifyClient client = ApifyClient("APIFY_TOKEN") run = client.actor("nexgendata/google-cse-replacement").call(run_input={ "q": "climate change", "num": 10, }) data = client.dataset(run["defaultDatasetId"]).iterate_items().__next__() for item in data["items"]: print(item["title"], item["link"]) Fields parsed downstream (items[].title, items[].link, items[].snippet, items[].displayLink, searchInformation.totalResults) are all populated identically.Code examplesPython: RAG pipeline migrationA common pattern: a RAG pipeline that used CSE to find relevant URLs for an LLM to summarize.from apify_client import ApifyClient client = ApifyClient("APIFY_TOKEN") def google_search_for_rag(query, n=5): run = client.actor("nexgendata/google-cse-replacement").call(run_input={