How to Use UnifyPort with Kommo CRM for Messenger Sales

Sales conversations now start in WhatsApp, Instagram, TikTok, Telegram, LINE, Zalo, and X — often all at once. Kommo CRM is built for that reality: it is an AI-powered CRM designed for messenger-based sales, trusted by thousands of teams to automate conversations across WhatsApp, Instagram, TikTok, and other channels. But Kommo's native connectors cover a fixed set of providers. If your customers write to you on LINE, Zalo, or X, you either build a separate integration for each network or you lose the conversation.

UnifyPort closes that gap. It is a unified messaging API platform that connects WhatsApp, Telegram, LINE, TikTok, Zalo, and X behind one REST API and one standard webhook event stream. Pair it with Kommo and you get a single pipeline: every inbound message from any supported channel becomes a normalized event, and every event can become a lead, a contact, or a task inside Kommo.

This guide explains how the two products fit together, the setup path, the code-level workflow, and the trade-offs to weigh before you commit.

Why pair UnifyPort with Kommo CRM

First viewport screenshot of UnifyPort — One API. Every Channel..

The combination solves three concrete problems that messenger-first sales teams hit as they scale.

Channel fragmentation. Kommo ships integrations for WhatsApp Business, TikTok, Instagram, Facebook Messenger, Telegram, Viber, WeChat, and Apple Messages for Business, among others. That is a strong native set — but each one is a separate connector with its own configuration, and providers outside the list require custom work. UnifyPort replaces the per-provider build with one integration surface: send with a single POST /v1/messages call and receive every provider's inbound traffic in one JSON shape.

Provider-specific code in your CRM sync layer. Without a normalization layer, your middleware has to parse WhatsApp payloads differently from Telegram updates, handle each provider's status callbacks, and maintain separate SDKs. UnifyPort's standard event layer converts every message, status update, and account event into one stable JSON structure, so your Kommo sync logic is written once.

Delivery reliability. Messenger channels rate-limit, retry, and fail in different ways. UnifyPort provides a reliable delivery queue with built-in rate limits, retries, idempotency, and failure isolation, plus a webhook control plane for signatures, subscriptions, retry behavior, and failure tracking. That means fewer dropped follow-ups and fewer duplicate leads in Kommo.

How the two products divide the work

Think of the split like this:

UnifyPort organizes resources around workspaces, messaging accounts, and connection runtime states, with a documented account lifecycle covering authentication flows such as QR code, verification code, password, Passkey, and session import. Kommo organizes work around leads, contacts, companies, notes, and tasks. Your job is to keep those two models in sync.

Prerequisites

Before you start, confirm you have:

• A UnifyPort workspace with at least one messaging account connected. Free messaging accounts are included in every workspace, and pricing is based on messaging-account costs in USD with transparent graduated pricing.
• A Kommo account with permission to create integrations under Settings → Integrations.
• A publicly reachable HTTPS endpoint for your middleware — this receives UnifyPort webhooks and calls both APIs.
• A server-side environment for your workspace API key. Never expose it to a browser or mobile client.

Step 1: Create the Kommo integration and collect credentials

Kommo supports two authentication types for integrations: OAuth2 and a long-lived token.

OAuth2 (recommended for production):

1. In Kommo, go to Settings → Integrations → Create Integration.
2. Provide the required details, including a Redirect URI that matches your application.
3. Select the access scopes your app needs — account data, files, and the specific entity actions you plan to call.
4. Save the integration, then open the Key and Scopes section.
5. Copy the Integration ID (client ID) and the generated client secret. Store both as secrets.

Token-based (faster for internal tools):

1. Create the integration and define the required scopes.
2. In Key and Scopes, generate a long-lived token.
3. Store the token securely — it grants access to your Kommo account.

Scope selection matters. If you only need to create leads and contacts, request only those actions. The Kommo integration model exposes granular actions such as create lead, create contact, create lead with contact, create note, create task, find lead, find contact, update lead, and link entities — plus triggers for lead created, lead updated, lead status updated, contact created, task created, and similar events. Requesting the minimum set reduces blast radius if a credential leaks.

Step 2: Register a signed UnifyPort webhook

UnifyPort's webhook control plane is where you manage signatures, subscriptions, retry behavior, and failure tracking. Register your middleware endpoint and subscribe to the event types you care about — at minimum inbound message events and delivery status updates.

Security is handled through workspace API keys and HMAC-SHA256 signatures. Verify the signature on every delivery before you parse the body, and reject anything that fails. If you want a channel-by-channel walkthrough of this pattern, the Telegram setup guide covers account creation, signed webhook registration, HMAC-SHA256 verification, and routing message.received events into your application.

Step 3: Normalize the inbound event and map it to Kommo

First viewport screenshot of Estimate your WhatsApp Business API costs.

This is the core of the integration. A typical handler does four things:

1. Verify the HMAC-SHA256 signature.
2. Identify the workspace, messaging account, and channel from the normalized event.
3. Resolve the sender to a Kommo contact — search first, create only if missing.
4. Route the message: attach it as a note on the existing lead, or create a new lead with contact if none exists.

A simplified Node.js sketch:

app.post('/webhooks/unifyport', async (req, res) => {
  if (!verifyHmac(req.headers['x-unifyport-signature'], req.rawBody)) {
    return res.status(401).end();
  }

  const event = req.body; // one stable JSON shape across all providers
  res.status(200).end();  // acknowledge fast, process async

  if (event.type !== 'message.received') return;

  const contact = await findOrCreateKommoContact({
    channel: event.channel,          // whatsapp | telegram | line | tiktok | zalo | x
    externalId: event.sender.id,
    name: event.sender.displayName,
  });

  const lead = await findOpenLeadFor(contact.id);

  if (lead) {
    await addKommoNote(lead.id, formatMessage(event));
  } else {
    await createKommoLeadWithContact({
      contactId: contact.id,
      pipeline: 'Messenger Sales',
      source: event.channel,
      note: formatMessage(event),
    });
  }
});

Two details keep this reliable. First, acknowledge the webhook immediately and process asynchronously — UnifyPort's retry behavior will re-deliver on failure, and slow handlers cause duplicate work. Second, use idempotency keys when writing to Kommo so a retried delivery does not create a second lead for the same message.

Step 4: Send replies back through one endpoint

When a Kommo agent or AI agent replies, your middleware sends it out through UnifyPort's single messages endpoint rather than a provider SDK:

curl -X POST https://api.unifyport.com/v1/messages \
  -H "Authorization: Bearer $UNIFYPORT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "account_id": "acc_whatsapp_sales",
    "to": "+15551234567",
    "type": "text",
    "text": { "body": "Thanks for reaching out — here is your quote." }
  }'

The same call shape works for Telegram, LINE, TikTok, Zalo, and X. Official SDKs are available for Node.js, PHP, Go, and Python if you prefer typed clients over raw HTTP.

Practical example: a multi-channel lead capture flow

First viewport screenshot of WhatsApp CRM for fitness centers.

A retail brand runs ads on TikTok and Instagram, keeps a support line on WhatsApp, and serves customers in Vietnam and Japan on Zalo and LINE.

1. A shopper messages the TikTok account asking about sizing.
2. UnifyPort normalizes the inbound event and delivers it to the middleware with a verified signature.
3. The middleware finds no existing Kommo contact for that TikTok handle, so it creates a contact and a lead in the Messenger Sales pipeline, with the channel recorded as the source.
4. Kommo's AI agent drafts a reply with the size chart; the agent approves and sends.
5. The middleware posts the reply through POST /v1/messages to the TikTok account.
6. Two days later the shopper writes on Zalo. UnifyPort delivers the event, the middleware matches the phone number to the existing contact, and the message lands as a note on the same lead — one continuous thread across two channels.

That last step is the payoff. Without a normalization layer, step 6 usually produces a second, disconnected record.

Where Kommo's native integrations are the better choice

First viewport screenshot of WhatsApp CRM for beauty salons.

UnifyPort is not automatically the right answer for every team. Kommo's built-in connectors are a strong fit when:

• You only use channels Kommo already supports natively, and you do not expect to add more.
• Your team works entirely inside Kommo's interface and has no engineering capacity to run middleware.
• You want the tightest possible integration with Kommo's own AI agent and automation builder without an external hop.

UnifyPort becomes the better choice when you need channels outside Kommo's native list, when you want one code path for all providers, when you need delivery guarantees and failure isolation you can observe, or when messaging is a product feature rather than just a sales inbox. If you are still evaluating the API layer itself, the multi-channel messaging and email API comparison and the UnifyPort vs MessengerPeople.dev vs CM.com breakdown cover pricing, webhook design, and WhatsApp setup in more depth.

Operational checklist

• Store workspace API keys and Kommo tokens in a secrets manager, never in client code.
• Verify HMAC-SHA256 signatures on every inbound webhook before parsing.
• Acknowledge webhooks within a second and process asynchronously.
• Make every Kommo write idempotent so retries do not duplicate leads.
• Log the mapping between UnifyPort sender IDs and Kommo contact IDs; you will need it for reconciliation.
• Monitor the webhook failure tracking view in the UnifyPort control plane and alert on sustained failures.
• Request only the Kommo scopes you actually call.

Related reading

• HubSpot Review: Pricing, Pros, Cons & Best-Fit Users - An evidence-based HubSpot review covering ideal users, use cases, pricing signals, setup, strengths, limitations, and decision criteria for 2026.

Sources and further reading

• Kommo - Connect your app with Kommo to streamline CRM workflows, automate sales processes, and enhance customer engagement
• All Integrations - A list of all Kommo integrations which will help you customize your account and add new features
• Kommo Knowledge base - Find step-by-step guides to set up Kommo, connect messaging channels, manage leads, automate workflows, and troubleshoot common issues.

FAQ

Does Kommo already support WhatsApp, Instagram, and TikTok natively?

Yes. Kommo offers native integrations for WhatsApp Business, WhatsApp Lite, TikTok, Instagram, Facebook Messenger, Telegram, Viber, WeChat, and Apple Messages for Business, along with CRM automation tools like Zapier and Make. UnifyPort is most valuable when you need channels outside that list or want a single normalized API across all of them.

Which channels can I add through UnifyPort?

WhatsApp, Telegram, LINE, TikTok, Zalo, and X (formerly Twitter), all through one REST API and one webhook event stream. Account authentication flows include QR code, verification code, password, Passkey, and session import.

Do I need to write provider-specific code for each channel?

No. That is the point of the standard event layer. Every provider message, status update, and account event arrives as one stable JSON shape, so your Kommo sync logic does not branch per provider. Official SDKs exist for Node.js, PHP, Go, and Python.

How is the integration secured?

UnifyPort uses workspace API keys and HMAC-SHA256 signatures on webhook deliveries, with a control plane for managing signatures, subscriptions, retry behavior, and failure tracking. On the Kommo side, use OAuth2 or a scoped long-lived token and request only the actions you need.

How does pricing work?

UnifyPort pricing is based on messaging-account costs in USD, with transparent graduated pricing and unified API access. Free messaging accounts are included in every workspace, so you can validate the integration before scaling.

What happens if a webhook delivery fails?

UnifyPort's delivery queue handles retries and failure isolation, and the control plane exposes failure tracking. Pair that with idempotent writes on the Kommo side so a re-delivered event updates the existing lead instead of creating a duplicate.

Conclusion

Kommo CRM gives messenger-based sales teams a place to manage leads, automate replies, and run pipelines. UnifyPort gives them a way to reach every channel their customers actually use without maintaining a separate integration for each one. Together, the stack is straightforward: UnifyPort owns connectivity, normalization, and delivery reliability; Kommo owns the customer record and the sales process; your middleware maps one to the other with verified webhooks and idempotent writes.

Start with one channel, prove the lead-to-note flow end to end, then add providers. The architecture does not change — only the account you point at.