Kommo + Notion: tasks and databases from the sales pipeline without manual entry

There is no native integration between Kommo and Notion. When a deal moves to “Production” or “Active Project”, a manager manually creates a card in Notion, copies client data, and assigns tasks to the team. When the project is completed in Notion, the manager goes back to Kommo and manually closes the deal. This gap between sales and delivery is a typical problem for service businesses.

A custom integration bridges this transition: when a deal moves to the relevant stage -> a Notion database record is created automatically with data from the CRM. When the Notion status changes -> Kommo receives an update.

Typical scenario: agency or service company

Sales are managed in Kommo: leads, negotiations, contract. After signing, work begins — managed in Notion: project board, team tasks, documents, client onboarding.

Without integration:

1. Manager signs the contract, moves deal to “Production”
2. Opens Notion, creates a new page/database record
3. Copies: client name, contact, amount, terms, deadline
4. Assigns tasks to the team
5. Team works in Notion
6. Project completed -> manager goes back to Kommo to close the deal

With integration, steps 2–4 are completed automatically in 5 seconds after the stage change.

What the custom integration does

Kommo -> Notion (triggered by stage):
— When a deal moves to “Production” -> a record is created in the Notion “Projects” database
— Deal fields (name, client, amount, responsible, deadline) -> Notion record properties
— A task checklist is automatically created from a template for this project type
— The Notion page link is saved to a custom field in the Kommo deal

Notion -> Kommo (via polling or Notion webhooks):
— Notion record status changes to “Completed” -> deal in Kommo moves to the next stage
— Project completion date is saved in the deal field
— Optional: if status is “On hold” -> task for manager in Kommo “Clarify with client”

Working with the Notion API

Notion has an official REST API (version 2022-06-28). An Integration Token with access to the relevant databases is required.

Create a record in a Notion database:

POST https://api.notion.com/v1/pages
Notion-Version: 2022-06-28
Authorization: Bearer {integration_token}

{
  "parent": { "database_id": "{projects_db_id}" },
  "properties": {
    "Name": {
      "title": [{ "text": { "content": "Project: {deal_name}" } }]
    },
    "Client": {
      "rich_text": [{ "text": { "content": "{client_name}" } }]
    },
    "Amount": { "number": {deal_amount} },
    "Deadline": { "date": { "start": "{deadline_date}" } },
    "Status": { "select": { "name": "In Progress" } },
    "Kommo ID": {
      "rich_text": [{ "text": { "content": "{kommo_lead_id}" } }]
    }
  }
}

Add a task checklist to a page:

PATCH https://api.notion.com/v1/blocks/{page_id}/children
{
  "children": [
    {
      "type": "to_do",
      "to_do": {
        "rich_text": [{ "text": { "content": "Onboarding call with client" } }],
        "checked": false
      }
    },
    {
      "type": "to_do",
      "to_do": {
        "rich_text": [{ "text": { "content": "Access credentials received" } }],
        "checked": false
      }
    }
  ]
}

Task templates are stored in the backend config and selected based on the project type (a custom field in the Kommo deal).

Syncing status from Notion back to Kommo

Notion does not have native webhooks (as of Q2 2026 — the feature is in beta for Enterprise). For other plans, polling is used:

The backend queries changed pages every 5–10 minutes:

POST https://api.notion.com/v1/databases/{db_id}/query
{
  "filter": {
    "and": [
      { "property": "Status", "select": { "equals": "Completed" } },
      { "timestamp": "last_edited_time",
        "last_edited_time": { "after": "{last_check_timestamp}" } }
    ]
  }
}

For found records: reads the Kommo ID from the page property -> updates the deal stage in Kommo.

If Notion webhooks are available on your plan — polling is replaced by an event-driven approach: instant update instead of a 5–10 minute delay.

Different databases for different project types

If the company has multiple project types with separate Notion databases (for example, “Development”, “Design”, “Consulting”), the mapping is stored in config:

{
  "pipeline_stage_mapping": {
    "18766543": {
      "deal_type_field": "Project Type",
      "databases": {
        "Development": "db_id_development",
        "Design": "db_id_design",
        "Consulting": "db_id_consulting"
      },
      "task_templates": {
        "Development": ["Technical brief", "Repository access", "Environment setup"],
        "Design": ["Design brief", "References approved", "First draft"]
      }
    }
  }
}

Real-world case

For a web agency (8 managers, 4 developers, projects $3,000–20,000):
— Before integration: a manager spent 15–20 minutes creating a project in Notion after each sale. With 10 deals per month — 3+ hours just on “setting up” projects.
— The team periodically received incomplete data (the manager forgot to copy a phone number or deadline)
— After project completion, Kommo was updated at best the next day

After integration:
— The Notion project is created within 8 seconds of the stage change
— All deal data is transferred automatically — no “forgot to copy” errors
— “Completed” status in Notion updates Kommo within 10 minutes (polling)
— Managers noted: “we can see in Kommo that the project is closed, no need to ask developers”

Who this is relevant for

Kommo + Notion integration makes sense if:
— The company is a service business (agency, consulting, development): sales in CRM, delivery in Notion
— When closing a deal, a project page with tasks needs to be created automatically
— Project status synchronization back to CRM without manual updates is important
— Notion has templated projects — one deal type = one set of tasks

For companies that use ClickUp instead of Notion — a similar scheme is available through Kommo and ClickUp integration with the native ClickUp API.

Frequently asked questions

Is the Notion API free?

Yes. The Notion API is available on all paid Notion plans (Plus, Business, Enterprise) and on the free plan with limitations. An Integration Token is created in Notion settings -> My connections -> Develop or manage integrations. API requests — no explicit limits, but rate limiting applies at high load (3 requests per second).

Can multiple Notion pages be created for a single deal?

Yes. For example: when the stage changes to “Design” -> a page is created in the “Design Projects” database. When it changes to “Development” -> a page is created in “Dev Projects”. The backend stores multiple Notion IDs for one deal in different Kommo custom fields.

What if a manager renames a record in Notion?

By default, synchronization works by ID, not by name. Renaming in Notion does not break the link — the backend uses the Kommo ID from the page’s service property for identification. The title in Notion can be changed freely.

Is Notion adequate as a full project management tool?

For teams of up to 15–20 people with straightforward projects — yes. For more complex scenarios (task dependencies, Gantt charts, time tracking) it is better to look at ClickUp, Jira, or Asana. The Kommo integration scheme is analogous — only the target API changes.

Summary

• No native Kommo + Notion integration; Zapier only provides basic page creation without tasks and templates
• Custom integration: stage change in Kommo -> Notion record created with a task checklist
• Reverse sync: polling every 5–10 minutes or Notion webhooks (Enterprise)
• Project type -> Notion database -> task template mapping is configured in the backend config
• Typical development timeline — 2–3 weeks

If your team manages sales in Kommo and projects in Notion — describe your workflow. Exceltic.dev will assess the complexity and propose a concrete solution.