How to Integrate Make (Integromat) with Your Headless CMS

What is Make (Integromat)?

Make, formerly Integromat, is a visual automation platform for building workflows across apps, APIs, databases, and webhooks. Teams use its scenario builder to connect tools like Google Sheets, Airtable, Slack, Salesforce, Notion, and custom HTTP endpoints without writing a full integration service. It sits in the automation and integration platform category, alongside tools like Zapier, n8n, Workato, Tray.io, and Pipedream.

Why integrate Make (Integromat) with a headless CMS?

Content work rarely stops at publishing. A product launch page might need to notify sales, create a row in a planning spreadsheet, start a localization task, update an internal changelog, and tell a support team what changed. If those steps happen manually, someone copies fields between browser tabs, misses one market, or sends a Slack message with stale copy.

Connecting Make (Integromat) to a headless CMS gives you event-based automation around content changes. When an editor publishes a document, Make can receive the event through a custom webhook, route it through filters, format the payload, and send it to 1,000+ connected apps. With Sanity, the content starts as structured JSON in the Content Lake, so Make receives fields like title, slug, locale, campaignId, and product references instead of scraped HTML or a page blob.

The trade-off is that Make is best for orchestration, not heavy content shaping. If you need joins, reference expansion, validation, or secret handling before data reaches a scenario, do that in Sanity with GROQ and Functions. Then send Make the smallest payload it needs, such as one published campaign with its owner, target markets, and approved assets.

Architecture overview

A typical Sanity and Make (Integromat) integration starts with a publish event in the Content Lake. A Sanity webhook can fire when a document changes, filtered by dataset, document type, or mutation. For example, only trigger when `_type == "campaign"` and the document is published. From there, you have two common paths. The direct path sends the webhook payload to a Make custom webhook URL, which starts a Make scenario. The more controlled path sends the event to a Sanity Function. The Function reads the document ID from the webhook payload, fetches the exact document shape with GROQ, adds referenced data like owner name or product SKU, and posts the resulting JSON to Make's custom webhook URL with `fetch`. Inside Make, the custom webhook module receives the JSON, determines the data structure, and passes it to downstream modules. A router might send launch content to Slack, Google Sheets, HubSpot, and Jira. The end user sees the result in those tools, such as a Slack message in `#launches`, a new Jira task for localization, or a CRM note attached to an account. Sanity remains the structured source, while Make handles app-to-app routing.

Common use cases

Step-by-step integration

1. 1

   Create a Make scenario

   In Make, create a new scenario and choose Webhooks as the first module. Select Custom webhook, create a webhook, and copy the generated URL. Run the scenario once so Make can detect the incoming JSON structure.

2. 2

   Set up credentials and packages

   If you only receive events through a Make custom webhook, the webhook URL is the credential you need. If you also call Make's REST API to run or inspect scenarios, create an API token in Make and store it as `MAKE_API_TOKEN`. In your Sanity Function or middleware project, install the Sanity client with `npm install @sanity/client`.

3. 3

   Model the content in Sanity Studio

   Define the fields Make needs as typed schema fields, such as `title`, `slug`, `status`, `launchDate`, `locale`, `owner`, `products`, and `channels`. Keep automation-facing fields explicit. A `channels` array with values like `web`, `sales`, and `support` is easier for Make to route than freeform instructions in a rich text field.

4. 4

   Create the sync trigger

   Add a Sanity webhook filtered to the document types that should start automation, or use a Sanity Function if you need to fetch references, remove draft-only fields, or sign outgoing requests. For publish-only workflows, filter out drafts and trigger on create, update, and delete events as needed.

5. 5

   Send the payload to Make

   Use GROQ to select the fields Make needs, then post JSON to the Make custom webhook URL. In Make, add filters and routers to send different content types or locales to different app modules.

6. 6

   Test the full path

   Publish a test document in Sanity Studio, confirm the Sanity webhook or Function ran, inspect the webhook bundle in Make, and check each destination app. Then build the frontend experience from the same Sanity data so the website, automation workflows, and internal tools all read from one structured source.

Code example

import {createClient} from '@sanity/client';

const client = createClient({
  projectId: process.env.SANITY_PROJECT_ID!,
  dataset: process.env.SANITY_DATASET!,
  apiVersion: '2025-02-19',
  token: process.env.SANITY_READ_TOKEN!,
  useCdn: false
});

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

  const doc = await client.fetch(`
    *[_id == $id][0]{
      _id,
      _type,
      title,
      "slug": slug.current,
      launchDate,
      locale,
      "owner": owner->{name, email},
      "products": products[]->{sku, title}
    }
  `, {id});

  if (!doc || doc._id.startsWith('drafts.')) {
    return new Response('Ignored', {status: 202});
  }

  const res = await fetch(process.env.MAKE_WEBHOOK_URL!, {
    method: 'POST',
    headers: {'content-type': 'application/json'},
    body: JSON.stringify({event: 'sanity.publish', document: doc})
  });

  if (!res.ok) throw new Error(`Make webhook failed: ${res.status}`);
  return Response.json({sent: true});
}

How Sanity + Make (Integromat) works

CMS approaches to Make (Integromat)

Keep building

Explore related integrations to complete your content stack.