How to Integrate Google Ads with Your Headless CMS

What is Google Ads?

Google Ads is Google’s advertising platform for running search, display, shopping, video, app, and Performance Max campaigns across Google properties and partner inventory. Marketing teams, growth teams, agencies, and commerce companies use it to create campaigns, manage budgets, target audiences, and measure conversions. Its core capability is matching ads to intent, especially in Google Search, where campaign data, landing pages, keywords, assets, and bidding rules all need to stay accurate.

Why integrate Google Ads with a headless CMS?

Google Ads works best when campaign content matches the page, product, or offer a person lands on. That gets hard when your landing page copy lives in one place, your promo details live in a spreadsheet, and your ad headlines are typed directly into Google Ads. A price changes from $49 to $39, but the ad still says $49. A landing page gets unpublished, but the final URL is still active in a campaign. Those small gaps can waste budget fast.

Architecture overview

A typical flow starts when an editor publishes or updates a campaign document in Sanity Studio. A webhook listens for publish events, or a Sanity Function runs directly on the content mutation. The sync code receives the document ID, uses @sanity/client to query the Content Lake with GROQ, and returns only the fields needed by Google Ads, such as campaign name, ad group resource name, final URL, headlines, descriptions, labels, start date, end date, and status. The Function then calls the Google Ads API through an OAuth refresh token, developer token, customer ID, and optional manager account login customer ID. For example, it can create a responsive search ad inside an existing ad group, update ad assets, apply labels, or pause an ad when the Sanity document is archived. After Google serves the ad, the end user clicks from Google Search or another Google Ads surface to the landing page powered by the same structured content.

Common use cases

Step-by-step integration

1. 1

   Set up Google Ads API access

   Create or choose a Google Ads account, request a developer token in the Google Ads API Center, create a Google Cloud OAuth client, and generate a refresh token for the Google Ads user that can edit the target customer account. If you use a manager account, capture the login customer ID too.

2. 2

   Install the SDK and Sanity client

   In your sync service or Sanity Function project, install google-ads-api and @sanity/client. Store GOOGLE_ADS_DEVELOPER_TOKEN, GOOGLE_ADS_CLIENT_ID, GOOGLE_ADS_CLIENT_SECRET, GOOGLE_ADS_REFRESH_TOKEN, GOOGLE_ADS_CUSTOMER_ID, and SANITY_API_TOKEN as environment variables.

3. 3

   Model campaign content in Sanity Studio

   Create a campaign schema with fields such as title, finalUrl, adGroupResourceName, headlines, descriptions, approvalStatus, startDate, endDate, regions, product references, and googleAdsResourceName. Add validation for Google Ads limits, such as 30 characters for responsive search ad headlines and 90 characters for descriptions.

4. 4

   Create the sync trigger

   Use a Sanity webhook filtered to published campaign documents, or use a Sanity Function triggered by content mutations. Pass the document ID to the sync handler so it can fetch the latest published content from the Content Lake.

5. 5

   Call the Google Ads API

   Use GROQ to fetch the campaign document and referenced product or landing page data, then call Google Ads API mutate operations to create or update ads, assets, labels, or status. Keep the first version conservative, for example create paused ads that a marketer reviews in Google Ads before enabling.

6. 6

   Test with a safe campaign and verify the landing page

   Run the integration against a test customer account or a low-budget campaign. Confirm character limits, final URLs, tracking templates, policy review status, and click paths from the ad to the page powered by Sanity.

Code example

import {createClient} from '@sanity/client';
import {GoogleAdsApi} from 'google-ads-api';

const sanity = createClient({
  projectId: process.env.SANITY_PROJECT_ID!,
  dataset: process.env.SANITY_DATASET!,
  apiVersion: '2025-01-01',
  token: process.env.SANITY_API_TOKEN!,
  useCdn: false
});

const ads = new GoogleAdsApi({
  client_id: process.env.GOOGLE_ADS_CLIENT_ID!,
  client_secret: process.env.GOOGLE_ADS_CLIENT_SECRET!,
  developer_token: process.env.GOOGLE_ADS_DEVELOPER_TOKEN!
});

export async function POST(req: Request) {
  const {ids} = await req.json();
  const id = ids?.created?.[0] || ids?.updated?.[0];
  if (!id) return new Response('No document id', {status: 202});

  const campaign = await sanity.fetch(`*[_id == $id][0]{
    title,
    finalUrl,
    adGroupResourceName,
    headlines[]{text},
    descriptions[]{text}
  }`, {id});

  const customer = ads.Customer({
    customer_id: process.env.GOOGLE_ADS_CUSTOMER_ID!,
    login_customer_id: process.env.GOOGLE_ADS_LOGIN_CUSTOMER_ID,
    refresh_token: process.env.GOOGLE_ADS_REFRESH_TOKEN!
  });

  await customer.mutateResources([{ 
    entity: 'ad_group_ad',
    operation: 'create',
    resource: {
      ad_group: campaign.adGroupResourceName,
      status: 'PAUSED',
      ad: {
        final_urls: [campaign.finalUrl],
        responsive_search_ad: {
          headlines: campaign.headlines.slice(0, 15),
          descriptions: campaign.descriptions.slice(0, 4)
        }
      }
    }
  }]);

  return Response.json({synced: true, title: campaign.title});
}

How Sanity + Google Ads works

CMS approaches to Google Ads

Keep building

Explore related integrations to complete your content stack.