Intercom MCP Server: Automating Customer Data Workflows

Building integrations between customer data platforms and messaging tools often involves repetitive API calls, manual data synchronization, and constant maintenance. An Intercom MCP server provides a standardized way to interact with customer data structured way to automate these workflows directly from your development environment, enabling you to interact with Intercom’s customer data through Claude and other MCP-compatible tools.

What is an Intercom MCP Server?

A Model Context Protocol (MCP) server for Intercom exposes Intercom’s API capabilities as tools that Claude can invoke. This means you can automate customer data operations—creating users, updating attributes, managing segments, and retrieving conversation history—without leaving your coding environment or writing custom API wrappers each time.

The MCP approach differs from traditional integrations because it treats Intercom as a context source that Claude can query and manipulate programmatically. You gain conversational control over your customer data workflowsustomer data while maintaining the auditability and error handling you’d expect from API-based automation.

Core Capabilities

An Intercom MCP server typically provides tools for three operational categories:

User and Lead Management — Create, read, update, and delete user records. You can sync user profiles from your database to Intercom, update custom attributes based on application events, and manage lead conversion workflows.

Segmentation and Tagging — Add or remove tags from users, update segment membership based on behavioral triggers, and query users by attribute combinations. This supports automated onboarding flows and churn prevention campaigns.

Conversation Operations — Retrieve conversation history, send replies from automated workflows, and extract conversation metadata for analysis. Combined with tools like the pdf skill or xlsx skill, you can generate reports from conversation data.

Setting Up Your Server

You’ll need an Intercom access token and Node.js installed. Create a basic MCP server structure:

// server/index.js
const { MCPServer } = require('@modelcontextprotocol/server');
const { IntercomClient } = require('intercom-client');

const server = new MCPServer({
  name: 'intercom-customer-data',
  version: '1.0.0',
});

const client = new IntercomClient({ token: process.env.INTERCOM_ACCESS_TOKEN });

// Tool: Create or update user
server.addTool({
  name: 'upsert_user',
  description: 'Create or update a user in Intercom',
  inputSchema: {
    type: 'object',
    properties: {
      email: { type: 'string', description: 'User email address' },
      name: { type: 'string', description: 'User full name' },
      custom_attributes: { 
        type: 'object', 
        description: 'Custom attributes to set' 
      }
    },
    required: ['email']
  },
  handler: async ({ email, name, custom_attributes }) => {
    const user = await client.users.create({
      email,
      name,
      custom_attributes
    });
    return { user_id: user.id, created: user.created_at };
  }
});

// Tool: Add tags to user
server.addTool({
  name: 'tag_user',
  description: 'Add tags to a user by email',
  inputSchema: {
    type: 'object',
    properties: {
      email: { type: 'string' },
      tags: { type: 'array', items: { type: 'string' } }
    },
    required: ['email', 'tags']
  },
  handler: async ({ email, tags }) => {
    const user = await client.users.find({ email });
    const results = await Promise.all(
      tags.map(tag => client.tags.tag({ id: user.id, tag }))
    );
    return { tagged: results.length };
  }
});

// Tool: Get user segments
server.addTool({
  name: 'get_user_segments',
  description: 'List all segments for a user',
  inputSchema: {
    type: 'object',
    properties: {
      email: { type: 'string' }
    },
    required: ['email']
  },
  handler: async ({ email }) => {
    const user = await client.users.find({ email });
    return { segments: user.segments };
  }
});

server.start();

Practical Automation Examples

Automated User Onboarding

When new users sign up for your application, you can trigger Intercom profile creation and segment assignment:

// In your signup handler
async function onUserSignup(user) {
  await mcpCall('upsert_user', {
    email: user.email,
    name: user.name,
    custom_attributes: {
      plan: user.plan,
      signup_source: user.referrer,
      account_created: new Date().toISOString()
    }
  });
  
  await mcpCall('tag_user', {
    email: user.email,
    tags: ['new-signup', `plan-${user.plan}`]
  });
}

This replaces manual Intercom admin actions and ensures every new user enters your marketing automation pipeline immediately.

Behavior-Triggered Tag Updates

Use the MCP server to update user segments based on application behavior. When users complete key actions, their Intercom profile reflects these milestones:

async function onFeatureUsage(email, featureName, usageCount) {
  if (usageCount === 1) {
    await mcpCall('tag_user', { email, tags: [`first-use-${featureName}`] });
  }
  if (usageCount === 10) {
    await mcpCall('tag_user', { email, tags: [`power-user-${featureName}`] });
  }
}

This enables segment-based messaging—you can send different onboarding sequences to first-time users versus power users without manual list management.

Customer Data Export for Analysis

Pull user data for analysis using the MCP server, then process it with other skills:

async function exportUserMetrics() {
  const users = await mcpCall('list_users', { 
    filter: { created_after: '2026-01-01' }
  });
  
  // Use xlsx skill to create analysis spreadsheet
  await createSpreadsheet({
    data: users,
    filename: 'q1-2026-user-metrics.xlsx'
  });
}

Combining with Claude Skills

The Intercom MCP server becomes more powerful when combined with other Claude skills. The xlsx skill can transform raw user data into formatted reports with pivot tables and charts. The pdf skill lets you generate personalized onboarding PDFs triggered by segment membership. The supermemory skill can maintain context across customer interactions, surfacing relevant history when Claude assists with support conversations.

For testing your automation workflows, the tdd skill helps you write integration tests that verify user data flows correctly between your application and Intercom. If you’re building a frontend dashboard to visualize Intercom data, the frontend-design skill provides component patterns and styling guidance.

Security Considerations

When automating customer data through MCP servers, several practices protect sensitive information:

Store your Intercom access token in environment variables rather than configuration files. Use scoped tokens with minimum required permissions—if your automation only reads user data, avoid granting write access. Implement request logging to maintain audit trails of automated data modifications. Consider rate limiting on tools that perform bulk operations to avoid hitting Intercom API limits.

Error Handling Patterns

Well-written MCP tool implementations handle common failure scenarios:

server.addTool({
  name: 'safe_upsert_user',
  handler: async (params) => {
    try {
      return await client.users.create(params);
    } catch (error) {
      if (error.code === 'duplicate_record') {
        const existing = await client.users.find({ email: params.email });
        return await client.users.update({ 
          id: existing.id, 
          ...params 
        });
      }
      throw error;
    }
  }
});

This pattern ensures your automation handles duplicate emails gracefully rather than failing silently or crashing.

Next Steps

Start with a single automation—perhaps syncing new user signups—and expand as you validate the workflow. The MCP architecture makes it straightforward to add new tools as your customer data needs evolve. Document your tool definitions so team members understand what automated operations are possible.

Built by theluckystrike — More at zovo.one