Kommo + Intercom: Chat History Into the Deal Card

A custom integration via Intercom Webhooks transfers the full conversation history from Intercom into Kommo notes automatically - when a chat is created and on every user reply. Sales see the conversation context directly in the deal card, without switching between interfaces.

The native Kommo + Intercom integration creates a lead when a new chat appears and syncs contact details. That is enough for a basic scenario - but it does not write the conversation text into the deal card and does not react to deal stage changes in Kommo. A custom webhook connector closes both gaps.

In integration projects at Exceltic.dev one situation comes up regularly: the support team handles chats in Intercom, the sales team works in Kommo. When a chat converts to a deal, the manager opens the Kommo card and sees contact details - but not what support talked about. Context is lost. The manager either writes to the client again with the same questions, or spends 10-15 minutes hunting for the right chat in Intercom. This article describes the architecture of a custom integration that solves the problem without Zapier and without manual work.

The Operational Pain: Sales Start Conversations Blind

When a lead moves from support to the sales pipeline, the manager loses up to 20 minutes restoring context for each new chat. At 30-50 new leads per week that is 10+ hours of team time spent searching for information that already exists in the system - just in a different one.

Typical breakdown pattern: user wrote in Intercom -> support qualified the lead -> handed it to a manager in Kommo -> manager called the client without knowing the details of the request.

Native Integration: What It Does and Where It Tops Out

Kommo offers a native integration with Intercom through Settings -> Integrations. As of Q2 2026, it does the following: when a new chat appears in Intercom, it creates a lead in Kommo and populates the contact name and email.

What the native integration does not do:

• Does not write conversation text into deal notes
• Does not sync Intercom tags to Kommo fields
• Does not react to chat updates after the lead is created
• Does not work in reverse: a deal stage change in Kommo does not push a tag to Intercom

This is not a bug - it is an architectural limit. The native integration solves lead capture, not context synchronization across the full deal cycle.

What the Custom Integration Delivers

The custom connector is built on four Intercom webhook events and the Kommo REST API.

Forward Branch: Intercom -> Kommo

Event conversation.user.created - a user opened a new chat.

After the webhook fires, the application does the following:

1. Extracts conversation.id and contacts[0].email from the payload
2. Calls GET https://api.intercom.io/conversations/{id} - retrieves the full object with conversation_parts[]
3. Builds text from the conversation_parts array: each part contains body, author.name, created_at
4. Looks up the contact in Kommo: GET /api/v4/contacts?query={email}
5. If the contact is found and has an open deal - adds a note: POST /api/v4/leads/notes with note_type: 4 (common_note) and the conversation text in params.text
6. If no deal exists - creates a lead and adds the note to it

Event conversation.user.replied - a user replied in an existing chat.

The same logic applies, but instead of creating a new note an update is added to the existing deal. The manager sees a chronological conversation log directly in the card feed.

Intercom Tags as Labels in Kommo. The conversation object contains a tags array - a list of labels that support agents assign manually (for example: “interested”, “hot lead”, “technical question”). The custom connector maps these tags to a Kommo custom field of type “checkbox” or “list”.

Reverse Branch: Kommo -> Intercom

Kommo supports outgoing webhooks through Settings -> Integrations -> Webhooks. When the pipeline stage changes (for example, “Qualified” or “Won”), the application calls POST https://api.intercom.io/conversations/{id}/tags and adds the corresponding tag to the Intercom conversation.

This lets support agents see the deal status without logging into Kommo.

Step-by-Step Integration Scheme

1. Create an app in the Intercom Developer Hub. You need an OAuth App with “Read conversations” permission. Webhook subscriptions are set up for conversation.user.created and conversation.user.replied.

2. Set up the endpoint. The application accepts POST requests from Intercom. Intercom signs each webhook with an X-Hub-Signature header (HMAC-SHA256). The signature is verified before processing.

3. Fetch the full conversation. After verifying the signature, the application calls GET https://api.intercom.io/conversations/{conversation_id} with a Bearer token. The endpoint returns up to 500 conversation_parts in a single request.

4. Build the conversation text. From the conversation_parts array, parts with a non-empty body are filtered. Each line is formatted: [HH:MM author]: text. HTML tags from body are stripped before writing.

5. Look up the deal in Kommo. Using the email from contacts[0].email, a GET /api/v4/contacts?query=email is performed. If the contact is found, a linked open deal is sought via _embedded.leads.

6. Write the note. POST /api/v4/leads/notes with the body:

[
  {
    "entity_id": 12345,
    "note_type": 4,
    "params": {
      "text": "[Intercom] Chat #conv_id from 2026-06-25\n\n[10:15 Ivan]: Hi, interested in the Pro plan...\n[10:18 Support]: Hello! Tell us more..."
    }
  }
]

7. Reverse webhook from Kommo. An outgoing webhook is configured in Kommo for the stage change event. When the status changes, the application calls the Intercom Conversations API to add a tag to the conversation.

8. Idempotency. Each note contains the conversation_id from Intercom. Before adding a new note, the application checks whether a note with this ID has already been written - to avoid duplicates on repeated webhook deliveries.

Real-World Case

A B2B SaaS company with a 4-person support team and a 6-person sales team was using Intercom for inbound chats and Kommo for the sales pipeline. There was no integration between them.

The problem: about 40 new chats per week were being converted to leads manually - a support agent would summarize the conversation to a manager in Slack or copy-paste the text into the “Description” field of the Kommo deal. The process took 5-7 minutes per lead.

After deploying the custom integration:

• The history of each chat appears in Kommo notes within 5-10 seconds of the event
• The manager sees the full conversation text before the first call to the client
• Tags “hot”, “evaluating competitor”, “technical question” from Intercom are mapped to a Kommo custom field - the manager immediately sees the priority
• Reverse branch: when a deal moves to “Won”, the tag deal_won is automatically added to the Intercom conversation - the support team sees the result without logging into the CRM

Typical project development volume: 3-4 working days including tests and deployment.

Who This Integration Is For

The solution is relevant for companies of 15+ people where support and sales work in different tools. The benefit is especially pronounced when:

• Inbound chat volume is 20+ per week - at lower volumes manual context transfer is manageable
• Leads from Intercom go through qualification before entering the pipeline - the custom integration preserves the qualification result
• The sales manager does not have access to Intercom or does not want to switch between interfaces
• Intercom tags are used to segment conversations - they can be automatically transferred to Kommo fields

If you already use custom integrations for Kommo and want to add Intercom to that stack, the connector architecture is standard and fits onto existing infrastructure. A similar approach works for AI-generated conversation summaries - more on that in the article about ChatGPT conversation summaries in deals.

Term: conversation_parts - an array of objects in the Intercom API, each representing one message in a conversation. Contains the fields body (text), author (author with name and type - admin, user, bot), and created_at (Unix timestamp).

Frequently Asked Questions

What exactly goes into the Kommo note - the entire chat or only the last message?

The note contains the full conversation history at the time of the event. On conversation.user.created this is the user’s first message and the agent’s greeting reply (if it already exists). On conversation.user.replied an update is added with the new messages. This way the deal card accumulates a chronological conversation log - not individual messages, but a structured log.

Does the integration work with the Intercom bot (Fin AI)?

Yes. Fin AI replies are also delivered in conversation_parts with author.type: "bot". The custom connector can either include bot replies in the log (marked [Bot]) or filter them out - depending on whether the manager needs context from automated replies. By default Exceltic.dev configures inclusion of bot replies, since they contain information about what the user was trying to find.

Is Zapier or Make required for this integration?

No. The architecture is direct: Intercom webhook -> custom application -> Kommo API. Zapier and Make add latency (up to 15 minutes on free plans), limit data volume per step, and do not support business logic like note deduplication or tag mapping. The custom connector processes an event within seconds and is not subject to third-party service limits.

What happens if there is no contact in Kommo with that email?

There are two configurable behaviors. First: if no contact is found, a new lead is automatically created in Kommo with data from Intercom (name, email, conversation text) - the lead enters the top of the pipeline. Second: the event is logged and the manager receives a notification (for example, in Slack) about a new chat with no match - for manual resolution. The first option is used more often.

How does the integration handle confidential internal agent notes?

Intercom has a conversation_part type with part_type: "note" - these are internal agent notes not visible to the user. By default the custom connector filters these parts and does not write them to Kommo. If the manager should see internal notes, this can be configured separately with proper data access policy in place.

Summary: What to Set Up So Sales Work with Context

• Subscribe to webhook events conversation.user.created and conversation.user.replied in the Intercom Developer Hub - these two events cover 95% of scenarios
• Configure the custom connector to call GET /conversations/{id}, build text from conversation_parts, and write to Kommo API via POST /api/v4/leads/notes
• Add mapping of Intercom tags to custom Kommo fields
• If needed - configure the reverse branch: stage change in Kommo -> tag in Intercom

If you have Intercom and Kommo and chats are currently being transferred manually or lost during the transition to the pipeline - describe the task to the Exceltic.dev team. We will work through the architecture for your stack and estimate the scope of work.