How to Integrate Profound with Your Headless CMS

What is Profound?

Profound is an AI visibility platform that helps marketing, SEO, and content teams understand how brands appear in AI answer engines such as ChatGPT, Perplexity, Gemini, and Copilot. Teams use it to track prompts, citations, share of voice, competitor mentions, and content opportunities across AI-generated answers. Its core value is connecting what people ask AI systems with the content and sources those systems cite.

Why integrate Profound with a headless CMS?

AI answer visibility changes when your content changes. If a product page ships on Monday, a pricing update goes live on Wednesday, and a comparison article is published on Friday, Profound needs the latest URLs, titles, summaries, topics, and ownership metadata to make the analysis useful. Without an integration, teams usually export URLs from a spreadsheet, paste updates into another tool, and hope the tracked content matches what's actually live.

Architecture overview

A typical Sanity and Profound integration starts when an editor publishes or updates content in Sanity Studio. A Sanity webhook, filtered with GROQ, fires only for content types that matter to AI visibility, such as articles, product pages, help docs, comparison pages, and landing pages. The webhook can call a Sanity Function, or your own API route, with the document ID and mutation details. The server-side handler uses @sanity/client to query the Content Lake with GROQ. Instead of sending the full document, the query projects only the fields Profound needs: title, slug, canonical URL, excerpt, body text, topic tags, product references, language, market, and publish status. GROQ can also join references, for example pulling a product name, category, and industry from referenced documents in the same request. The handler then calls Profound's API with an API key from your Profound workspace. In many implementations, that means upserting a content item or URL source in Profound so it can be associated with prompt tracking, citation analysis, and AI answer visibility reports. From there, Profound analyzes how that content is cited or omitted in AI answer engines, and your team sees the results in Profound. The end user still reads content on your website, app, or help center, while Profound gives your team feedback about how that same content performs in AI-generated answers.

Common use cases

Step-by-step integration

1. 1

   Set up Profound access

   Create or open your Profound workspace, confirm API access with your Profound account team, and generate an API key. Note the workspace ID, the API base URL shown in your Profound settings, and whether your account accepts content item upserts, URL submissions, or sitemap-based ingestion.

2. 2

   Install the Sanity client

   In the service that will handle sync events, install @sanity/client. For a Sanity Function, add it to your function package. For a Next.js or Node.js API route, add it to the same app that receives the webhook.

3. 3

   Model AI visibility fields in Sanity Studio

   Add fields that Profound can use for analysis and reporting, such as seoTitle, metaDescription, canonicalUrl, excerpt, targetPromptCluster, market, language, product references, topic tags, and publish status. Keep editorial notes in separate fields so you don't send internal context to Profound by accident.

4. 4

   Create the publish trigger

   Create a Sanity webhook that fires on create, update, and delete events for published content. Use a GROQ filter such as _type in ['article', 'productPage', 'helpArticle'] && defined(slug.current) so draft-only documents and unrelated content don't trigger Profound syncs.

5. 5

   Fetch clean content with GROQ

   In the webhook handler or Sanity Function, use GROQ to fetch the published document by ID. Project only the fields Profound needs, and join referenced products, categories, authors, or markets in the same query.

6. 6

   Push to Profound, then test the frontend

   Call Profound's content or URL ingestion endpoint with the API key. Publish a test article in Sanity Studio, confirm the webhook fires, verify the item appears in Profound, and check that the public page has the same canonical URL you sent to Profound.

Code example

import {createClient} from '@sanity/client'

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

export async function POST(req: Request) {
  const {ids} = await req.json()
  const id = ids?.created?.[0] || ids?.updated?.[0]
  if (!id) return Response.json({skipped: true})

  const doc = await sanity.fetch(`
    *[_id == $id][0]{
      _id,
      _type,
      title,
      "url": canonicalUrl,
      "summary": coalesce(metaDescription, excerpt),
      "topics": topics[]->title,
      "products": products[]->{name, category},
      language,
      market
    }
  `, {id})

  if (!doc?.url) return Response.json({skipped: true})

  const res = await fetch(`${process.env.PROFOUND_API_BASE_URL}/v1/content/items`, {
    method: 'PUT',
    headers: {
      Authorization: `Bearer ${process.env.PROFOUND_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      external_id: doc._id,
      url: doc.url,
      title: doc.title,
      summary: doc.summary,
      metadata: {
        type: doc._type,
        topics: doc.topics,
        products: doc.products,
        language: doc.language,
        market: doc.market,
      },
    }),
  })

  if (!res.ok) throw new Error(await res.text())
  return Response.json({synced: doc._id})
}

How Sanity + Profound works

CMS approaches to Profound

Keep building

Explore related integrations to complete your content stack.