Kommo + Monday.com: automatic project creation from won deals

Monday.com uses a GraphQL API — not REST. This matters for integration architecture: all requests go to a single endpoint https://api.monday.com/v2, and the body is JSON with a query field. The Kommo connection automates an operational moment: deal Won -> item in the correct board with client name, amount, and deadline -> as work progresses, the status returns to Kommo.

Kommo + Monday.com vs Kommo + Asana: when to choose which

Both tools address the task of “create a project from a CRM deal”. The choice depends on how the team works with tasks:

Monday wins on board structure flexibility and visualization. For teams already using Monday — the choice is clear. A similar integration with Asana and Kommo is implemented via REST API.

What is synchronized

Kommo -> Monday.com:
— Deal name -> item name
— Contact name and email -> text columns
— Deal amount -> Numbers column
— Deadline from custom field -> Date column
— Kommo deal ID -> column for back-tracing
— Responsible manager -> People column (via mapping)

Monday.com -> Kommo:
— Item status changed to “Delivered” / “Done” -> stage update in Kommo
— Completion date -> Note on the deal

Architecture

Kommo Webhook: deal Won
  ↓ Backend
  1. GET /api/v4/leads/{id} + contacts
     -> client name, email, amount, deadline, manager
  2. Monday.com GraphQL: create_item mutation
     -> board_id + item_name + column_values
     -> receive item_id
  3. Kommo: PATCH /leads/{id}
     -> update field monday_item_id

Monday.com Webhook: column_values_updated (status -> Done)
  ↓ Backend
  1. Extract item_id from payload
  2. Monday.com GraphQL: items query
     -> find column with kommo_deal_id
  3. Kommo: PATCH /leads/{deal_id}
     -> stage -> 'Delivered'
  4. Kommo: POST /notes
     -> completion date + link to item

Monday.com GraphQL API: key requests

Monday.com API works via POST to https://api.monday.com/v2. Authentication — API Token in the Authorization header.

Create an item with deal data:

import requests
import json

MONDAY_TOKEN = 'your_api_token'
BOARD_ID = 1234567890  # Monday.com board ID

headers = {
    'Authorization': MONDAY_TOKEN,
    'Content-Type': 'application/json'
}

def create_monday_item(deal_name, client_email, amount, deadline_str, kommo_deal_id):
    # column_values - JSON string, keys are column IDs
    column_values = {
        'text_email': client_email,           # Text column
        'numbers_amount': amount,             # Numbers column
        'date_deadline': {'date': deadline_str},  # 'YYYY-MM-DD'
        'text_deal_id': str(kommo_deal_id),   # for back-tracing
        'status': {'label': 'In Progress'}   # status
    }

    query = '''
    mutation ($boardId: ID!, $itemName: String!, $columnValues: JSON!) {
        create_item(
            board_id: $boardId,
            item_name: $itemName,
            column_values: $columnValues
        ) {
            id
            name
        }
    }
    '''

    variables = {
        'boardId': BOARD_ID,
        'itemName': deal_name,
        'columnValues': json.dumps(column_values)
    }

    response = requests.post(
        'https://api.monday.com/v2',
        headers=headers,
        json={'query': query, 'variables': variables}
    )
    data = response.json()
    return data['data']['create_item']['id']

Get column IDs for a board:

def get_board_columns(board_id):
    query = '''
    query ($boardId: [ID!]) {
        boards(ids: $boardId) {
            columns {
                id
                title
                type
            }
        }
    }
    '''
    response = requests.post(
        'https://api.monday.com/v2',
        headers=headers,
        json={'query': query, 'variables': {'boardId': [board_id]}}
    )
    return response.json()['data']['boards'][0]['columns']

Register a webhook in Monday.com:

def create_monday_webhook(board_id, callback_url):
    mutation = '''
    mutation ($boardId: ID!, $url: String!, $event: WebhookEventType!) {
        create_webhook(
            board_id: $boardId,
            url: $url,
            event: $event
        ) {
            id
            board_id
        }
    }
    '''
    requests.post(
        'https://api.monday.com/v2',
        headers=headers,
        json={
            'query': mutation,
            'variables': {
                'boardId': board_id,
                'url': callback_url,
                'event': 'change_status_column_value'  # or change_column_value
            }
        }
    )

Mapping Kommo manager -> People in Monday.com

The Monday.com People column accepts Monday user IDs. A mapping is required:

# Mapping Kommo user_id -> Monday.com user_id
OWNER_MAP = {
    12345: 67890123,  # Kommo ID -> Monday user ID
    12346: 67890124,
}

def get_monday_user_id(kommo_owner_id):
    return OWNER_MAP.get(kommo_owner_id)

# In column_values:
'people_owner': {'personsAndTeams': [{'id': monday_user_id, 'kind': 'person'}]}

Monday.com user IDs are retrieved via the query query { users { id name email } }.

Creating from a template (Board Template)

For complex projects, it is better to create an entire board from a template instead of creating an item:

def create_board_from_template(deal_name, template_id, folder_id=None):
    mutation = '''
    mutation ($name: String!, $templateId: ID!) {
        duplicate_board(
            board_id: $templateId,
            duplicate_type: duplicate_board_with_pulses_and_updates,
            board_name: $name
        ) {
            board {
                id
                name
            }
        }
    }
    '''
    response = requests.post(
        'https://api.monday.com/v2',
        headers=headers,
        json={'query': mutation, 'variables': {'name': deal_name, 'templateId': template_id}}
    )
    return response.json()['data']['duplicate_board']['board']['id']

This approach is used when each client gets a dedicated board — for example, agencies with individual projects.

Real-world case

Marketing agency (EU market, 10–15 clients simultaneously, team of 12):

• Before: the sales manager won a deal in Kommo, sent an email to the head of delivery with client details. That person manually created a board in Monday.com. Average time from Won to project start — 2 days.
• After: Won in Kommo -> within a minute a Monday.com board from a template is ready with the client name, amount, and deadline -> a link to the board appears in the Kommo card -> the delivery team starts work immediately.
• Additional effect: the manager sees all active client projects in a single Monday.com Portfolio view — without additional status updates from managers.

Who this is relevant for

• Monday.com is used for project management, Kommo for sales
• There is a gap between closing a deal and starting a project — data is transferred manually
• Delivery and sales teams work in different tools
• Volume: 5+ new projects per month
• Traceability is needed: what is happening in which project is visible in Kommo without switching to Monday.com

Frequently asked questions

Monday.com GraphQL — is it harder than REST API?

GraphQL differs in query structure but is not more difficult. One endpoint, body is a query/mutation string. The main challenge — correctly forming the column_values JSON: keys must match the column IDs of the specific board. Column IDs are retrieved via a separate API query or from the URL in the Monday.com interface.

How do I find column IDs without programming?

In Monday.com: open the board -> any item -> three dots on the column -> Copy column ID. Or via a GraphQL query boards { columns { id title } } — returns all board columns with IDs and types.

Is a special API plan required for Monday.com?

API is available on all paid plans (Basic and above). On the Basic plan — 100,000 requests/min. More than sufficient for a typical Kommo integration volume. Webhooks are available on Standard and above.

Can subitems be created automatically?

Yes. The Monday.com API supports the create_subitem mutation: create_subitem(parent_item_id: ID!, item_name: String!, column_values: JSON!). Used when a deal needs to create a structure: item-project with subitems-tasks (design, development, QA, launch).

How to handle project cancellation (deal moved to Lost)?

Via a Kommo Webhook on a stage change event: if the new stage is “Lost” -> update the item status in Monday.com via the change_column_value mutation. Or archive the board if the project never started.

Summary

• Monday.com API — GraphQL, endpoint https://api.monday.com/v2, authentication via API Token
• Create item: create_item mutation with board_id, item_name, column_values (JSON string with column IDs)
• Webhook on status change -> stage update in Kommo
• For agencies: duplicate_board mutation creates a board from a template for each client
• Typical development timeline — 2–3 weeks

If you use Monday.com and Kommo and want to automate deal handoff to delivery — describe your board structure and which deal data is needed. Exceltic.dev will work out the column mapping and propose an architecture.