How to Integrate Datadog with Your Headless CMS

What is Datadog?

Datadog is a monitoring and observability platform for infrastructure metrics, application performance monitoring, logs, real user monitoring, synthetic tests, dashboards, and alerts. Engineering, SRE, DevOps, and security teams use it to understand how systems behave in production. It’s one of the most widely used observability tools for teams running cloud infrastructure, distributed applications, and customer-facing digital products.

Why integrate Datadog with a headless CMS?

When content changes break production, the problem rarely looks like a content problem at first. A landing page publish can increase API latency, a pricing update can trigger checkout errors, or a deleted reference can cause 500s on a high-traffic route. If Datadog only sees server logs and deploys, your team has to guess whether the issue came from code, infrastructure, or content.

Connecting Datadog to a headless CMS gives content events the same visibility as deploys, incidents, and performance metrics. You can send a Datadog log or event every time a document is published, updated, deleted, or moved through a release. Then you can correlate that event with APM traces, RUM sessions, Core Web Vitals, error rates, and synthetic test failures.

The cleanest setup starts with structured content. With Sanity’s Content Lake, content is typed JSON, so you can query fields like _type, slug, market, campaignId, author, and releaseId without parsing HTML. GROQ selects exactly what Datadog needs, webhooks fire on the mutations you care about, and Functions can run the server-side sync without a separate worker. The disconnected alternative is usually a spreadsheet of publish times, manual incident notes, and Slack archaeology at 2:00 AM.

Architecture overview

A typical Sanity and Datadog integration starts when an editor publishes or updates content in Sanity Studio. A Sanity webhook listens for specific mutations, such as documents where _type matches article, product, landingPage, or campaign. The webhook can use a GROQ filter so Datadog only receives operationally useful content events, not every draft save. From there, you have two common paths. For simple setups, the webhook calls an API route in your app, such as a Next.js route handler. For setups that should live closer to the content event, a Sanity Function can run the server-side logic when the mutation occurs. In either case, the handler uses @sanity/client to fetch the final document from the Content Lake with a GROQ projection, including fields like title, slug, market, release name, references, and publish timestamp. The handler then calls Datadog’s API through @datadog/datadog-api-client. Most teams start by sending a structured log to the Datadog Logs API with ddsource set to sanity, service set to content-operations, and tags like content_type:article, market:us, and env:production. You can also send custom metrics through the Metrics API or create Datadog events for publish markers. Datadog indexes those records, monitors can alert on patterns, and dashboards can overlay content publishes against latency, error rate, synthetic test failures, and RUM data. The end user never sees the integration, but your team gets a faster path from content change to production impact.

Common use cases

Step-by-step integration

1. 1

   Set up Datadog access

   Create or use an existing Datadog account. In Organization Settings, create an API key and an application key. Set DD_API_KEY, DD_APP_KEY, and DD_SITE, such as datadoghq.com or datadoghq.eu, in your runtime environment.

2. 2

   Install the SDKs

   Install Datadog’s Node SDK and Sanity’s client in the service that will receive the webhook: npm install @datadog/datadog-api-client @sanity/client.

3. 3

   Model operational fields in Sanity Studio

   Add fields that help Datadog filters and dashboards, such as slug, market, audience, campaignId, release, owner, and riskLevel. Keep these as typed schema fields, not text buried inside Portable Text or HTML.

4. 4

   Create a Sanity webhook or Function

   Create a webhook filtered to publish, update, or delete events for the content types you want to observe. If you’d rather keep the logic inside Sanity, use a Function to run the same Datadog call on mutation events without hosting a separate listener.

5. 5

   Fetch the final document with GROQ

   In the webhook handler, use @sanity/client and GROQ to fetch only the fields Datadog needs. Include joined reference data, such as the release title or author name, so Datadog tags and logs are useful during incidents.

6. 6

   Send logs, metrics, or events to Datadog and test the flow

   Start with the Logs API because it accepts structured records and works well with tags. Publish a test document, confirm the log appears in Datadog Log Explorer, then build a dashboard or monitor that overlays content events with APM, RUM, or synthetic test data.

Code example

import {NextRequest, NextResponse} from 'next/server';
import {createClient} from '@sanity/client';
import {client as ddClient, v2} from '@datadog/datadog-api-client';

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

const ddConfig = ddClient.createConfiguration({
  authMethods: {
    apiKeyAuth: process.env.DD_API_KEY!,
    appKeyAuth: process.env.DD_APP_KEY!,
  },
});
const logsApi = new v2.LogsApi(ddConfig);

export async function POST(req: NextRequest) {
  const body = await req.json();
  const id = body._id || body.ids?.updated?.[0] || body.ids?.created?.[0];

  const doc = await sanity.fetch(
    `*[_id == $id][0]{
      _id,
      _type,
      title,
      "slug": slug.current,
      market,
      riskLevel,
      "release": release->title
    }`,
    {id}
  );

  if (!doc) return NextResponse.json({ok: true, skipped: true});

  await logsApi.submitLog({
    body: [{
      ddsource: 'sanity',
      service: 'content-operations',
      hostname: 'sanity-content-lake',
      status: 'info',
      message: `Sanity content published: ${doc._type} ${doc.slug || doc._id}`,
      ddtags: `env:${process.env.VERCEL_ENV || 'dev'},content_type:${doc._type},market:${doc.market || 'global'}`,
      attributes: {
        sanity: doc,
        mutation: body.transition || 'publish',
      },
    }],
  });

  return NextResponse.json({ok: true});
}

How Sanity + Datadog works

CMS approaches to Datadog

Keep building

Explore related integrations to complete your content stack.