Kommo + Slack: Deal Notifications Without the Noise

The sales team does not know in real time what is happening in the pipeline. A manager closes a major deal — nobody sees it. A hot lead has been stuck at a stage for a week — nobody reacts. A Kommo and Slack integration solves this — provided the notifications are configured intelligently. The naive approach of “send everything” produces the opposite effect: the channel becomes noise and the team turns off notifications.

Two Scenarios: Notifications and Commands

The Kommo -> Slack integration covers two classes of tasks:

Notifications (Kommo -> Slack): — New lead received -> message in #leads channel — Deal moved to “Contract Signed” stage -> message in #wins — Deal overdue (deadline passed, stage unchanged) -> ping to manager in #alerts — Large deal (amount exceeds threshold) closed -> message in the team’s general channel

Commands (Slack -> Kommo): creating a task in Kommo from a Slack message via slash command or reaction — a more complex scenario requiring a Slack App with a Bot Token.

In most cases the first scenario is sufficient — a directed flow of Kommo notifications to Slack.

Slack Incoming Webhooks vs Bot API

Incoming Webhooks — the simplest approach: a URL is created, and a POST with JSON is sent to it. Setup takes 5 minutes, no Slack App with permissions is required. Limitation: one webhook = one channel. Suitable for most notification scenarios.

Slack Web API (chat.postMessage) — requires a Bot Token and Slack App. Allows: — Sending messages to any channel dynamically — Sending DMs to a specific user (e.g. the responsible manager) — Updating or deleting previously sent messages — Uploading files

For routing “different events -> different channels or users” — the Slack API with Bot Token is needed.

Integration Architecture

Kommo: pipeline event (stage change, new lead)
  ↓ Webhook -> Backend
  1. Parse event: type, deal, stage, manager, amount
  2. Apply filters (see below)
  3. Build Slack Block Kit message
  4. POST -> Slack Incoming Webhook URL or chat.postMessage

Filtering: What to Send, What Not to Send

Rule: a notification should require action or inform about an important event. Changing stage from “New” to “In Progress” is not an event. A closed deal at $10,000 is an event.

def should_notify(event: dict) -> bool:
    lead = event["lead"]
    old_status = event["old_status_id"]
    new_status = event["new_status_id"]

    # Always notify about closed deals
    if new_status == STATUS_WON:
        return True

    # Notify about large leads
    if new_status == STATUS_NEW and lead["price"] > 5000:
        return True

    # Notify if deal is stuck (unchanged for N days)
    days_stuck = (now() - lead["updated_at"]).days
    if days_stuck > 7 and new_status not in [STATUS_WON, STATUS_LOST]:
        return True

    return False

Formatting with Slack Block Kit

Plain text in Slack gets lost quickly. Block Kit allows building a structured message with sections, a deal link button, and status emoji.

def build_slack_message(lead: dict, event_type: str) -> dict:
    emoji = "🏆" if event_type == "won" else "🆕" if event_type == "new" else "⚠️"

    return {
        "blocks": [
            {
                "type": "section",
                "text": {
                    "type": "mrkdwn",
                    "text": f"{emoji} *{lead['name']}*\n"
                            f"Amount: ${lead['price']:,} · "
                            f"Manager: {lead['responsible_user']}"
                }
            },
            {
                "type": "actions",
                "elements": [{
                    "type": "button",
                    "text": {"type": "plain_text", "text": "Open deal"},
                    "url": f"https://app.kommo.com/leads/detail/{lead['id']}"
                }]
            }
        ]
    }

Channel Routing

Different events -> different channels:

For DMs, the manager’s Slack user ID is needed. It can be stored as a custom field for the Kommo user or in a mapping table on the backend.

Real-World Case

SaaS company (5 sales managers, Kommo, 80–100 leads per month):

• Before integration: the CEO learned about closed deals from the monthly report. Hot leads stalled without escalation.
• Implementation: Incoming Webhook for #wins (Won deals) + Slack API for DMs to managers (leads with no activity for 5+ days).
• Filter: notifications only for deals > $1,000 and on closing.
• Result: #wins became a live channel — the team sees closings in real time. Leads with no activity are automatically escalated — the number of “forgotten” leads decreased by 60%.

Who This Is Relevant For

The Kommo + Slack integration makes sense when: — The team already uses Slack as its primary messenger — Real-time visibility of important pipeline events is needed without opening the CRM — Escalation of stalled leads to the responsible manager is required — Separating “significant” events from routine stage changes matters

If the primary messenger is Microsoft Teams, a similar integration is described in the Kommo and Microsoft Teams article.

Frequently Asked Questions

Kommo already sends Slack notifications — why a custom integration?

Kommo has built-in notifications, but they are limited: fixed message format, no routing by channel depending on deal parameters, no filtering by amount or duration of stagnation. For basic notifications, the built-in option is sufficient. For conditional logic — it is not.

How do I send a DM to a specific manager rather than a channel?

For DMs, the Slack Web API (chat.postMessage) and Bot Token are needed. The Slack user ID of the manager must be mapped to the Kommo user — stored in a mapping table or as a custom field. This is slightly more complex than Incoming Webhooks but covers the personal escalation scenario.

Can I create tasks in Kommo from Slack?

Yes, via Slack Slash Commands or Workflow Builder. The user types /kommo task 'Call the client back' @ivan -> the backend creates a task in Kommo assigned to the specified manager. This is a two-way integration — more complex to set up, requires a Slack App.

How many webhook events does Kommo generate with an active pipeline?

Kommo generates a webhook on every stage change, contact addition, task creation, etc. At 100 leads per month and several stages — 300–500 events. Without filtering, all of them will become Slack spam. Backend filtering is mandatory.

Is a separate server required for the integration?

Yes, a webhook receiver is needed: a small backend (Python/Node.js) on a VPS or serverless (AWS Lambda, Vercel Functions). It receives Kommo events, applies filters, and sends to Slack. Minimum configuration for 500 events per month — the cheapest VPS ($4–5 USD/month).

Summary

• Key principle: filter events before sending, otherwise Slack becomes noise
• Slack Incoming Webhooks — for simple cases (one channel). Slack Bot API — for routing and DMs
• Block Kit: structured messages with a deal link button are better than plain text
• Typical triggers: Won, large new lead, deal stuck 5–7+ days
• Development time: 1–2 weeks

If you want to configure Kommo notifications in Slack — describe which events matter to your team. Exceltic.dev will analyse the filtering logic and propose an architecture without unnecessary noise.