How to Integrate Close with Your Headless CMS

What is Close?

Close is a CRM built for sales teams that rely on outbound calling, email, SMS, task queues, and pipeline tracking in one workflow. Teams use it to create leads, contacts, opportunities, activities, and follow-up sequences through the Close app or API. It's common with startups, agencies, and B2B sales teams that need fast rep workflows without a large CRM admin layer.

Why integrate Close with a headless CMS?

Sales teams lose context when campaign content, landing pages, gated assets, and CRM records live in separate systems. A rep may see a lead in Close with an email address and company name, but not the exact guide they downloaded, the industry page they visited, the persona they matched, or the offer that triggered the conversation. That missing context turns into slower follow-up and generic outreach.

Architecture overview

A typical Sanity and Close integration starts when a content editor publishes or updates a sales-related document in Sanity Studio, such as a campaign, gated asset, partner page, event lead, or sales play. The published document lands in the Content Lake as structured JSON. A Sanity webhook fires on the publish event, or a Sanity Function runs directly on the content mutation. The handler uses GROQ to fetch the document plus any referenced content, such as persona, product, region, CTA, and owner fields. It then calls Close's REST API at https://api.close.com/api/v1 using the Close API key as HTTP Basic auth. Depending on your workflow, the handler can create a lead with contacts, update custom fields, add a note activity, create a task for the assigned rep, or attach source content to an opportunity. The end result is practical: the website still renders from Sanity, while the sales rep sees the right campaign context in Close before making the first call.

Common use cases

Step-by-step integration

1. 1

   Set up Close API access

   Create or sign in to your Close account, then generate an API key from Close settings. Close uses HTTP Basic auth, with the API key as the username and an empty password. Keep the key in an environment variable such as CLOSE_API_KEY.

2. 2

   Install the Sanity client

   In the app, webhook listener, or Sanity Function that will sync data, install the Sanity client with npm install @sanity/client. Add SANITY_PROJECT_ID, SANITY_DATASET, SANITY_API_VERSION, and a read token if your dataset isn't public.

3. 3

   Model sales-ready content in Sanity Studio

   Create schemas for the content Close needs, such as campaignLead, gatedAsset, salesPlay, persona, and product. Useful fields include companyName, contactName, email, phone, website, campaign reference, persona reference, sourceUrl, closeLeadId, lifecycleStage, and assignedRepEmail.

4. 4

   Create the sync trigger

   Use a Sanity webhook filtered to the document types you want to sync, for example _type == 'campaignLead'. For server-side logic inside Sanity, use Functions so the sync runs on content events without a separate job runner.

5. 5

   Call the Close API

   Use GROQ to fetch the exact fields and references needed for Close, then call the Close Lead API to create a lead, update a lead, add a contact, or create a note activity. If you need idempotency, store the returned Close lead ID back on the Sanity document.

6. 6

   Test the full sales workflow

   Publish a test document in Sanity Studio, confirm the webhook or Function runs, verify the lead or activity in Close, and open the frontend page to make sure the same content is visible to customers. Test updates and deletes too, not just first publish.

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 {_id} = await req.json();

  const lead = await sanity.fetch(`
    *[_id == $id][0]{
      companyName,
      website,
      contactName,
      email,
      phone,
      sourceUrl,
      campaign->{title},
      persona->{name}
    }
  `, {id: _id});

  const auth = Buffer.from(`${process.env.CLOSE_API_KEY!}:`).toString('base64');

  const closeRes = await fetch('https://api.close.com/api/v1/lead/', {
    method: 'POST',
    headers: {
      Authorization: `Basic ${auth}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      name: lead.companyName,
      url: lead.website,
      description: `Source: ${lead.sourceUrl}
Campaign: ${lead.campaign?.title}
Persona: ${lead.persona?.name}`,
      contacts: [{
        name: lead.contactName,
        emails: [{email: lead.email, type: 'office'}],
        phones: lead.phone ? [{phone: lead.phone, type: 'office'}] : [],
      }],
    }),
  });

  if (!closeRes.ok) {
    return Response.json({error: await closeRes.text()}, {status: 500});
  }

  return Response.json(await closeRes.json());
}

How Sanity + Close works

CMS approaches to Close

Keep building

Explore related integrations to complete your content stack.