How do we migrate from Zendesk to Intercom—data import, macros/automations, and keeping reporting intact?

Most teams moving off Zendesk worry about three things: not losing historical data, not breaking agent workflows, and not going blind on reporting mid-migration. You can address all three if you treat the move to Intercom as a phased rollout, not a “big bang” cutover—standing up the new Helpdesk, Fin AI Agent, and reporting in parallel while Zendesk is still live, then switching traffic once your core flows are validated.

Quick Answer: Migrating from Zendesk to Intercom means exporting what matters (contacts, companies, tickets, tags, and macros), mapping it into Intercom’s objects (users, companies, conversations, tags, macros, Workflows), and recreating your automations and reports against Intercom’s unified Inbox and Help Center—so you get one connected system with AI, not just a like-for-like helpdesk swap.

The Quick Overview

What It Is: A structured, phased migration plan to move your customer support operations from Zendesk to Intercom—covering data import, macros and automation rebuilding, and reporting continuity.
Who It Is For: Support, operations, and CX leaders who own the helpdesk stack and need to de-risk a move without downtime or surprises for agents and customers.
Core Problem Solved: You outgrew Zendesk or want AI-native support, but can’t afford broken workflows, lost history, or black holes in your metrics during the transition.

How It Works

The most reliable Zendesk → Intercom migrations I’ve run follow a predictable sequence: stabilize your Intercom foundation first, then layer in data, then automations, then AI, then cut over reporting.

You’re not just “importing tickets.” You’re moving from a tickets-first model to a conversations-first, AI-powered system where Fin, Workflows, Helpdesk, and reporting are all part of one feedback loop.

Here’s the high-level migration path:

Prepare & Model:
Audit Zendesk (objects, triggers, macros, views, tags, fields), design your Intercom data model (users, companies, custom attributes, tags, SLAs), and set up your workspace, Messenger, and basic Helpdesk configuration.
Import & Rebuild:
Export contacts, organizations, and tickets from Zendesk; import them into Intercom via CSV/API; recreate macros as Intercom macros; rebuild business rules as Workflows and SLA rules; stand up your Help Center and initial Fin configuration.
Run, Compare & Cut Over:
Run Intercom alongside Zendesk for a short overlap period, validate data and automation behavior, align reporting, and then cut over channels (email, Messenger, web, social) once you’ve confirmed performance and visibility.

Phase 1: Prepare & Model

1. Audit your Zendesk setup

Start with an inventory of how Zendesk actually runs your support today:

Ticket types and forms (incident, task, question, etc.)
Custom fields on tickets, users, and organizations
Macros (agent-initiated) and triggers/automations (system-initiated)
Views and routing rules
Tags and their meaning (topics, severity, customer segment)
SLAs (first reply, next reply, resolution targets)
Channels in use (email addresses, web widget, social, SMS)

Document:

Which pieces directly affect customer experience (auto-responders, assignment rules)
Which are legacy / unused (dead macros, dormant triggers)
Which you want to improve in Intercom instead of copy-paste.

This becomes your migration backlog.

2. Design your Intercom data model

In Intercom, you’ll work with:

Users (end customers / end-users)
Companies (B2B accounts / organizations)
Conversations (instead of tickets)
Custom attributes on users/companies (plan, MRR, lifecycle stage, etc.)
Tags on users, companies, and conversations
Helpdesk configuration: teams, SLAs, inboxes, routing
Workflows: automated routing, assignment, SLAs, autoresponders, Fin escalation logic

Map Zendesk objects to Intercom like this:

Zendesk Users → Intercom Users
Zendesk Organizations → Intercom Companies
Zendesk Tickets → Intercom Conversations (with historical messages)
Zendesk Ticket fields → Intercom conversation custom attributes or tags
Zendesk User/Org fields → Intercom user/company attributes
Zendesk Tags → Intercom tags (customers, companies, conversations)

Be opinionated: this is your chance to clean up an overgrown tag schema or redundant fields before they become technical debt in Intercom.

3. Stand up your Intercom foundation

Before you import anything, create a stable shell for the new system:

Configure teams and inboxes (e.g., “Tier 1,” “Billing,” “Technical Support,” “Sales Assist”).
Set SLA rules and working hours.
Install the Messenger on your product/site (you can keep it hidden or limited to internal testing initially).
Connect key channels: support email(s), WhatsApp, SMS, Facebook/Instagram if relevant.
Define permissions and roles, especially for admins who will manage security and settings (e.g., “Can manage general and security settings”).

This gives you a safe environment to test imports and workflow behavior without customer impact.

Phase 2: Data Import from Zendesk to Intercom

1. Export Zendesk data

From Zendesk, export:

Users: include email, name, role, created_at, and any custom fields you need.
Organizations: name, domain(s), custom fields.
Tickets: ticket IDs, subject, status, priority, tags, requester, assignee, created_at, updated_at, solved_at, and custom fields. Include comments/updates if you want full history.
Tags & fields: export lists or document them so you can map them consciously.

Note: For large exports you may need to use Zendesk’s API and batch your exports.

2. Prepare your CSVs for Intercom

Intercom’s CSV import expects clean, column-based data:

Create separate CSVs for Users and Companies, with a unique identifier:
- Users: email (primary), or user_id if you use your own IDs.
- Companies: a unique company_id or company name + domain.
For ticket history, decide:
- Do you need every historical message, or just summary-level attributes (status, created/closed dates, tags)?
- Many teams prefer a lean import: bring in key dates, tags, and high-level metadata, and keep Zendesk read-only for deep historical lookup.

Map Zendesk fields to Intercom columns:

user_email → email
ticket_created_at → conversation created date (if using a historical import script)
ticket_status → custom attribute or tag (“zendesk_status_closed”)
Important ticket fields → conversation attributes (e.g., priority, issue_type, product_area)

Important: Normalize values (e.g., status “Solved” vs “Closed”) and tags (snake_case or kebab-case) before import.

3. Import users and companies into Intercom

In Intercom:

Go to Contacts > Import.
Import Users first. Map all required fields and create new custom attributes where needed (e.g., zendesk_user_id, plan_tier).
Then import Companies, and link users to companies based on domain or explicit company_id.

This ensures that when historical conversations arrive, they attach to the right contact and account context.

4. Handle historical tickets/conversations

There are two common patterns:

Lightweight history (recommended for most):
- Keep Zendesk in read-only for old tickets.
- Import only:
  - Ticket ID (as zendesk_ticket_id on the user or as a conversation attribute on a “summary” conversation).
  - Ticket creation/close dates (for lifetime metrics).
  - Key tags/fields that power segmentation.
- Benefit: Fast, clean, minimal noise for agents.
Full conversation history (for regulated / enterprise):
- Use a migration script that calls Zendesk’s API and Intercom’s API to recreate conversations with their original timestamps and messages.
- Mark them as historical (e.g., tag: imported_from_zendesk, status “Closed”).
- Benefit: Agents see full past context without switching tools; cost: more effort and Intercom conversation volume during import.

Whichever you choose, test on a small subset first (e.g., one segment or 500 tickets) and validate:

Contacts are correctly linked.
Time-based attributes look right.
No unexpected PII is exposed to teams that shouldn’t see it (check permissions).

Phase 3: Recreating Macros and Automations

Zendesk’s macros, triggers, automations, and views map into Intercom as combinations of macros, Workflows, inbox rules, and Fin tasks/procedures.

1. Migrate Zendesk macros → Intercom macros

Zendesk macros are agent shortcuts; they map very cleanly.

Steps:

Export your Zendesk macros or manually document the ones agents actually use.
In Intercom, go to Inbox > Macros and recreate them:
- Pre-written responses
- Internal notes
- Conversation state changes (assign to team, set priority)
- Tags to apply
Use variables where possible (customer name, product, etc.) to keep them flexible.
Involve a few frontline agents in UAT—they’ll catch small differences that matter in live workflows.

Tip: Use this moment to standardize tone and policy; Intercom macros can become the source of truth that Fin AI Agent learns from.

2. Migrate triggers & automations → Intercom Workflows

Zendesk triggers/automations typically handle:

Assignment based on channel, subject, or tags
Auto-responses
SLAs and escalations
Status updates / notifications

In Intercom, these live primarily as Workflows plus SLA rules.

Examples of mappings:

Zendesk: “If ticket via support@company.com and subject contains ‘billing’ → assign to Billing group”
→ Intercom Workflow:
- Trigger: conversation started on Email to support@company.com
- Condition: subject or body contains “billing”
- Actions: assign to Billing team, set priority, tag billing.
Zendesk: “Send auto-acknowledgment for new email tickets”
→ Intercom Workflow:
- Trigger: conversation started on Email
- Action: send an auto-reply message with expected reply time, link to Help Center, and Fin availability.
Zendesk: SLA rules
→ Intercom: configure SLAs in Helpdesk, and optionally build Workflows for escalations when SLA is breached (e.g., tag, assign to escalation team, send Slack/webhook).

Key operational tips:

Use Workflows to separate logic by channel (web Messenger vs email vs WhatsApp) so Fin and automation behave appropriately.
For email, take advantage of predicates like “Email To” vs “Email Cc” when designing Workflows that control if/when Fin replies—e.g., only respond if your support address is in “To”, not if your team is cc’d on a customer-to-customer thread.

3. Introduce Fin AI Agent instead of “deflection-only” bots

If Zendesk Answer Bot or basic bots were used, don’t try to re-create them 1:1. Fin fills a different role: resolving a large share of queries, not just deflecting.

Set up Fin as part of the migration:

Train Fin on your:
- Help Center content (articles you’ll host in Intercom)
- Policy/procedure documents
- Macros (great source of high-quality answers)
Test Fin in a staging or limited environment:
- Use Intercom’s testing to see how it answers common and edge-case questions.
- Check for policy-sensitive areas (billing changes, account cancellations) and gate them behind Fin Tasks/Procedures with identity verification and approval logic.
Deploy Fin:
- Start with web Messenger and maybe a single high-volume email address.
- Configure handoff rules: when Fin should offer to escalate to a human, tag conversations, and which teams they go to.

Fin’s average resolution rate sits around 66% across customers and increases over time as you refine content and procedures—so include Fin in your migration metrics from day one.

Phase 4: Keeping Reporting Intact (and Better)

The risk with any migration is a data black hole. The goal is not identical reports; it’s continuous visibility with clear mapping between “Zendesk world” and “Intercom world.”

1. Identify your critical Zendesk reports

Typical must-haves:

Volume by channel, topic, and segment
First response time, resolution time
CSAT / NPS tied to tickets
Backlog and SLA breaches
Agent productivity (conversations handled, time per convo)
Self-serve and Help Center usage

List each report, its fields, and how you use it (weekly ops review, exec dashboard, on-call rotation, etc.).

2. Recreate core metrics in Intercom

In Intercom:

Use Reports to replicate:
- Inbox performance (volume, first reply, resolution time)
- Team and agent performance
- SLAs met/breached
- Channel breakdown (Messenger, Email, WhatsApp, etc.)
Use Articles Reporting in Help Center to track:
- Article views, searches, and failed searches (“what customers searched for but couldn’t find”).
- This is crucial for ongoing Fin improvement and content backlog.

For macro-level continuity:

Consider storing zendesk_ticket_id as an attribute so you can join historical datasets outside the tools if you need a unified multi-year report.

3. Add AI-specific reporting

Intercom gives you AI-centric visibility you won’t have had in Zendesk:

Fin AI Agent performance:
- Resolution rate by topic and channel
- Handoffs to humans and resolution after handoff
AI Insights:
- Topic clustering by what customers ask, where Fin succeeds/fails
- Content gaps (what Fin can’t answer yet)
Copilot impact (for agents):
- Teams using Copilot close 31% more conversations daily on average—measure before/after to quantify your gains.

Use these to create a new layer in your weekly ops reviews:

“Top 10 topics by volume”
“Fin resolution rate by topic and channel”
“Content/Workflow changes shipped and resulting impact”

4. Manage the overlap period

During the transition, you’ll have:

Some conversations in Zendesk
Some in Intercom

To avoid losing visibility:

Freeze new automation changes in Zendesk; only invest in Intercom going forward.
Decide a cutover date for each channel (e.g., email, Messenger, WhatsApp) and annotate your reporting timelines.
For 4–6 weeks, accept that some cross-system reporting requires simple spreadsheet stitching—but limit this by cutting over channels quickly once Intercom performance matches or beats Zendesk.

Phase 5: Cutover Strategy & Go-Live

A structured go-live minimizes risk:

Internal-only testing:
- Restrict Messenger visibility to internal users, or use a staging environment.
- Have agents run test flows across all key paths: new conversation, assignment, macro use, SLA breach, Fin escalation.
Soft launch with a segment/channel:
- Route one region, product, or email address to Intercom first.
- Monitor metrics and agent feedback daily.
- Tune Workflows and macros based on real data.
Full channel cutover:
- Update DNS/MX records or forwarding so support@ now points to Intercom.
- Switch web widget to Messenger.
- Connect social and messaging channels.
- Keep Zendesk read-only for a defined window (e.g., 3–6 months) while you retire it gradually.
Post-go-live optimization loop:
- Review AI Insights weekly.
- Update Help Center content and Fin training based on failed answers and article search data.
- Tune Workflows, SLA rules, and team assignments in response to actual load.

PayShepherd did this across a 30-day implementation window with an Intercom onboarding specialist and saw:

40% reduction in response times
20% increase in Help Center engagement
100% CSAT in March 2024

That’s the benchmark: measurable improvement, not just a tool swap.

Features & Benefits Breakdown

Core Feature	What It Does	Primary Benefit
Unified Helpdesk & Inbox	Replaces Zendesk tickets and views with a single conversations-first Inbox across Messenger, Email, WhatsApp, SMS, and social.	Agents work from one shared view of every customer—so context switching drops and complex issues resolve faster.
Fin AI Agent & Workflows	Handles common queries using your content and procedures, routes complex ones via automation, and enforces SLAs and business logic.	Customers get faster, more accurate resolutions—while your team focuses on edge cases instead of repetitive questions.
Integrated Help Center & Reporting	Hosts your support content, surfaces it in Messenger, and powers detailed reporting on searches, gaps, and article performance.	You get a self-improving system—content, AI answers, and Workflows are all measured in one place, so you always know what to fix next.

Ideal Use Cases

Best for teams leaving Zendesk for an AI-first system: Because you want Fin and Copilot integrated into every conversation—not a separate bot layer bolted onto a legacy ticketing system.
Best for scaling B2B SaaS support organizations: Because you need account-level context (companies, plan, MRR), omnichannel routing, and advanced automation that can call external systems via Data connectors and Fin Tasks/Procedures.

Limitations & Considerations

Historical fidelity vs complexity:
Pulling every Zendesk comment into Intercom is possible but can be heavy. Many teams choose a hybrid approach—full history for VIP/regulatory segments, summarized for everyone else.
1:1 report matching isn’t realistic:
Some Zendesk metrics (e.g., very specific custom views) won’t map exactly. The goal is continuity on core KPIs (volume, time to respond/resolve, CSAT) and improved visibility with AI Insights—plan internal communication accordingly.

Pricing & Plans

Intercom’s pricing depends on:

The products you use (Customer Service Suite vs standalone components).
Your volume (contacts, conversations).
AI usage (Fin resolutions, Copilot usage) and channel mix.

In practice for a Zendesk migration, teams typically:

Start with the Customer Service Suite: Helpdesk + Inbox + Messenger + Help Center + Fin + Workflows—best for teams that want a full Zendesk replacement and AI-first operations in one system.
Layer Fin onto an existing helpdesk during transition, if needed, then consolidate into Intercom once volumes prove out.
Suite for Scaling Teams: Best for support orgs that need to replace Zendesk entirely, with robust reporting, multi-channel support, and AI from day one.
Suite for Larger / Enterprise Teams: Best for organizations needing advanced governance (2FA enforcement, SSO/SAML, detailed permissions), complex routing/Workflows, and high-volume AI automation via Fin Tasks/Procedures and Data connectors.

For exact pricing, Intercom will size it to your volume and channels.

Frequently Asked Questions

How do we avoid losing Zendesk ticket history when we switch to Intercom?

Short Answer: Keep Zendesk read-only for a period, import key metadata (and full history where truly required), and link old ticket IDs into Intercom so nothing is lost—even if it isn’t all fully rehydrated as conversations.

Details:
Most teams adopt a layered approach:

Import Users and Companies fully.
Import key ticket attributes (status, created/closed dates, tags, priority, custom fields) as conversation attributes or contact attributes—so you can segment and report on historical behavior.
For segments that require deep history (regulatory, VIP, long-lived contracts), use an API-based migration to recreate full conversations in Intercom and tag them clearly as historical.
Keep Zendesk in a restricted, read-only mode for 3–6 months so agents can look up rare edge cases while you fully normalize your operations in Intercom.

How do we keep our existing Zendesk automations and SLAs working during the migration?

Short Answer: Rebuild critical Zendesk triggers and automations as Intercom Workflows and SLA rules, then switch channels to Intercom only after those flows are tested and live.

Details:
During migration:

Identify must-have automations: assignment, auto-acknowledgments, SLA alerts, escalations.
Rebuild them in Intercom’s Workflows and Helpdesk SLA configuration.
Use test channels or a small subset of real traffic to validate behavior:
- Verify routing by channel, team, and topic.
- Confirm autoreplies are on-brand and correct.
- Check SLA timers and escalations.
Once the behavior matches (or improves on) Zendesk, update your DNS/forwarding so each channel (email, web, messaging) points to Intercom, and stop creating new tickets in Zendesk.

You get continuity in automation and SLAs with an overlap period where you can inspect and tune behavior before fully turning Zendesk off.

Summary

Migrating from Zendesk to Intercom is less about copying tickets and more about upgrading to a connected, AI-first support system. If you:

Model your data deliberately (users, companies, conversations, attributes, tags),
Import the history you truly need,
Rebuild macros and automations as Intercom macros and Workflows,
And re-establish reporting with Intercom’s Inbox, Help Center, and AI Insights,

you’ll come out with better visibility, faster responses, and a self-improving system where Fin resolves the bulk of straightforward queries and your team focuses on high-value work.

Next Step

Get Started