How to Integrate Google Search Console with Your Headless CMS

What is Google Search Console?

Google Search Console is Google’s free tool for monitoring how your site appears in Google Search. SEO teams, developers, and content teams use it to submit sitemaps, inspect URLs, track clicks and impressions, find indexing issues, and review Core Web Vitals signals. It’s the default source of truth for Google search visibility because the data comes directly from Google.

Why integrate Google Search Console with a headless CMS?

Search problems often show up after publishing, not before. A page ships with the wrong canonical URL, a localized article misses the sitemap, or a noindex flag stays on after launch. If Google Search Console is disconnected from your content workflow, someone has to notice the issue, copy the URL, paste it into Search Console, check indexing, and update a spreadsheet or ticket. That’s slow, and it breaks down fast when you publish 50, 500, or 5,000 URLs a month.

Connecting Google Search Console to a headless CMS lets you trigger search-related checks from the same content events your team already uses. When a page is published, a webhook can fetch the final canonical URL, language alternates, sitemap path, and robots settings, then call the Search Console API to submit the sitemap and run URL Inspection. When search analytics data comes back, you can show clicks, impressions, click-through rate, and average position next to the source content, instead of sending editors to a separate tool.

With Sanity, the useful part is that content in the Content Lake is structured JSON, not a rendered HTML blob. A GROQ query can select exactly the SEO fields Google Search Console needs, including references like author, category, market, and locale. Webhooks or Functions can run as soon as content changes, without a polling job. The trade-off is important: the Search Console API can submit sitemaps and inspect URLs, but it can’t force Google to crawl or index a normal webpage instantly. You’re sending cleaner signals and building faster feedback loops, not controlling Googlebot.

Architecture overview

A typical integration starts when an editor publishes or updates a page in Sanity Studio. The publish event writes structured JSON to the Content Lake. A Sanity webhook, filtered to production documents such as pages, articles, product pages, or location pages, fires on create, update, or delete events. That webhook calls a Sanity Function or your own serverless endpoint. The handler uses GROQ to fetch only the fields needed for search operations: slug, canonical URL, last modified date, noindex flag, sitemap path, hreflang alternates, and any referenced parent sections. If the page is indexable, the handler authenticates to Google with a service account or OAuth client that has access to the verified Search Console property. It can call `sitemaps.submit` to tell Google about the current sitemap and `urlInspection.index.inspect` to read the latest index status for the published URL. For reporting, a scheduled job can call `searchanalytics.query` daily and write summary metrics back to Sanity or another analytics store. Your frontend still serves the page to visitors from the same structured content source, while editors can see whether Google has discovered the URL, whether it’s indexed, and which queries are bringing search traffic. The user sees the live site. Your team sees the search feedback where the content work happens.

Common use cases

Step-by-step integration

1. 1

   Set up Google Search Console and API access

   Verify your domain or URL-prefix property in Google Search Console. In Google Cloud, enable the Google Search Console API and the URL Inspection API, create a service account, download its JSON key, and add the service account email as a user on the Search Console property. Install the SDK with `npm install googleapis @sanity/client`.

2. 2

   Model SEO fields in Sanity Studio

   Add fields your integration can trust, such as `slug`, `seoTitle`, `seoDescription`, `canonicalUrl`, `noIndex`, `lastModified`, `language`, and `sitemapInclude`. For localized sites, model alternate language references so the integration can build correct `hreflang` data and sitemap entries.

3. 3

   Create a publish trigger

   Create a Sanity webhook or Function that runs on production mutations, for example when `_type` is `page`, `post`, or `productPage` and the document isn’t a draft. Use filters so media edits, drafts, and unrelated documents don’t call Google unnecessarily.

4. 4

   Fetch the final URL with GROQ

   In the handler, query the Content Lake for the fields Google Search Console needs. GROQ can join references, resolve locale data, and return one clean payload, such as the canonical URL, sitemap URL, robots value, and document type.

5. 5

   Call Google Search Console APIs

   Use the `googleapis` package to authenticate, call `sitemaps.submit` for the sitemap feed, and call `urlInspection.index.inspect` for the published page. Store or log the inspection result so editors can see whether Google selected the expected canonical URL.

6. 6

   Test the frontend and feedback loop

   Publish a test page, confirm the webhook ran, check the sitemap submission in Search Console, and compare the inspected URL with your live canonical tag. After data is available, test a Search Analytics query for the page and decide whether to write metrics back to Sanity Studio.

How Sanity + Google Search Console works

CMS approaches to Google Search Console

Keep building

Explore related integrations to complete your content stack.