Kommo + GanttPRO: Project from a Won Deal Without Manual Task Creation

When a deal moves to “Won,” the Kommo + GanttPRO integration automatically creates a project from a template: client name, timelines from the deal, and assignees from the card. The manager does not open GanttPRO manually, and the PM does not wait for an email from sales.

GanttPRO is a project management tool with a Gantt chart, popular among agencies, IT companies, and service B2B. The gap between sales (Kommo) and delivery (GanttPRO) is a classic problem: projects are created late, client data is transferred manually, and contract dates never make it into tasks automatically.

In Kommo integration projects for service companies, we see the same pain point every time: when a deal moves to “Won,” the PM receives a message or email describing the client, then manually creates a project in GanttPRO - copying the name, budget, deadline, and assigning team members. With 8-15 new projects per month, this consumes several hours per week and regularly produces errors: wrong deadlines, missing fields, a 1-3 day delay before work actually starts. A custom webhook that fires on the Kommo pipeline stage change eliminates this manual step entirely. Below is the architecture and implementation details.

Why the native integration does not work

GanttPRO has no ready-made integration with Kommo. A Zapier connector for GanttPRO exists but only supports basic actions: create a task, update a status. Creating a full project from a template with a task hierarchy, milestones, resources, and dependencies is not possible through Zapier.

An additional problem: GanttPRO works with the concept of a “project template” - a set of tasks with relative deadlines (“task A starts 3 days after the project start”). Zapier cannot use templates - it only creates individual tasks with fixed dates. With 10-20 tasks per project, that means 10-20 separate Zapier steps and a charge for each.

Reverse synchronization (deadline update in GanttPRO -> notification in Kommo) is completely impossible through Zapier - GanttPRO does not support a task change trigger in the standard Zapier connector.

What gets built - solution architecture

Kommo (deal -> "Won")
        |
        v
  Orchestrator server:
  - reads deal data (name, amount, client, timelines, assignee)
  - determines project template by deal type
        |
        v
  GanttPRO API:
  - create project from template
  - set start date
  - assign task owners
  - add client as stakeholder
        |
        v
  Kommo API:
  - write ganttpro_project_id to deal field
  - add note with project link

  ---

GanttPRO (task overdue / milestone reached)
        |
        v
  GanttPRO Webhook -> Server
        |
        v
  Kommo API:
  - add note to deal
  - if key task overdue -> task for manager

The main value is using GanttPRO templates. Instead of creating tasks one by one, the API creates a project from a ready-made template that the PM set up in advance for a specific type of work.

Technical details

GanttPRO API v1 uses a JWT token for authentication. The token is generated in Account Settings -> API. Key endpoints for the integration: POST /projects (create project), POST /projects/{id}/from-template (create from template), GET /projects/{id}/tasks (get tasks). Webhooks for notifications are configured via the API or in the Integrations section of the UI.

import requests
from datetime import datetime, timedelta
from flask import Flask, request, jsonify

app = Flask(__name__)

GANTTPRO_API_BASE = "https://api.ganttpro.com/v1"
GANTTPRO_TOKEN = "your_ganttpro_jwt_token"

# Mapping of deal types to GanttPRO templates
DEAL_TYPE_TO_TEMPLATE = {
    "website": "tmpl_website_development",
    "integration": "tmpl_integration_project",
    "audit": "tmpl_seo_audit",
    "default": "tmpl_generic_project"
}

def create_project_from_deal(deal_data: dict) -> dict:
    headers = {
        "Authorization": f"Bearer {GANTTPRO_TOKEN}",
        "Content-Type": "application/json"
    }
    
    deal_type = deal_data.get("deal_type", "default")
    template_id = DEAL_TYPE_TO_TEMPLATE.get(deal_type, DEAL_TYPE_TO_TEMPLATE["default"])
    
    # Start date - tomorrow from deal close date
    start_date = (datetime.now() + timedelta(days=1)).strftime("%Y-%m-%d")
    
    # Deadline from deal field or +90 days
    deadline_field = deal_data.get("project_deadline")
    if deadline_field:
        end_date = deadline_field
    else:
        end_date = (datetime.now() + timedelta(days=90)).strftime("%Y-%m-%d")
    
    payload = {
        "templateId": template_id,
        "name": f"{deal_data['company_name']} - {deal_data['deal_name']}",
        "startDate": start_date,
        "endDate": end_date,
        "description": f"Kommo deal #{deal_data['lead_id']}. Budget: {deal_data['price']} {deal_data.get('currency', 'USD')}",
        "members": [
            {
                "email": deal_data["responsible_email"],
                "role": "manager"
            }
        ]
    }
    
    resp = requests.post(
        f"{GANTTPRO_API_BASE}/projects/from-template",
        json=payload,
        headers=headers
    )
    resp.raise_for_status()
    return resp.json()

@app.route("/kommo/webhook", methods=["POST"])
def kommo_webhook():
    data = request.json
    # Event: deal moved to "Won" (lost = false, status = success)
    for lead_update in data.get("leads", {}).get("status", []):
        if lead_update.get("pipeline_id") and lead_update.get("status_id") == WON_STATUS_ID:
            handle_won_deal(lead_update["id"])
    return jsonify({"ok": True})

def handle_won_deal(lead_id: int):
    lead = kommo_api.get_lead(lead_id)
    contact = kommo_api.get_lead_contact(lead_id)
    responsible = kommo_api.get_user(lead.get("responsible_user_id"))
    
    deal_data = {
        "lead_id": lead_id,
        "deal_name": lead["name"],
        "company_name": lead.get("company_name", "Client"),
        "price": lead.get("price", 0),
        "currency": lead.get("custom_fields", {}).get("currency", "USD"),
        "deal_type": lead.get("custom_fields", {}).get("deal_type", "default"),
        "project_deadline": lead.get("custom_fields", {}).get("project_deadline"),
        "responsible_email": responsible.get("email", "")
    }
    
    project = create_project_from_deal(deal_data)
    project_id = project["id"]
    project_url = f"https://app.ganttpro.com/projects/{project_id}"
    
    kommo_api.update_lead(lead_id, {"ganttpro_project_id": str(project_id)})
    kommo_api.add_note(
        lead_id,
        f"GanttPRO project created: {project_url}\n"
        f"Template: {deal_data['deal_type']}\n"
        f"Deadline: {deal_data.get('project_deadline', 'not specified')}"
    )

Step-by-step implementation

Step 1. Create project templates in GanttPRO

Prepare templates for each type of project you run. Important: use relative dates in tasks (“starts N days after the project start”), not absolute dates. This lets the system distribute tasks correctly regardless of the start date. Record the ID of each template.

Step 2. Add custom fields in Kommo

Required fields: deal_type (dropdown: website/integration/audit/…), project_deadline (date), ganttpro_project_id (text), ganttpro_project_url (link). The deal_type field is filled in at deal creation or during qualification.

Step 3. Set up the Kommo webhook for “Won”

Kommo sends a webhook when a deal status changes. You need to filter for the specific transition to “Won” (pipeline_id + status_id of the corresponding stage). This filtering happens on the server side.

Step 4. Set up reverse notifications

In GanttPRO, configure a webhook for the events “task overdue” and “milestone reached.” When the webhook is received, the server finds the deal by ganttpro_project_id and adds a note in Kommo.

Step 5. Test with real deals

Create a test deal with the deal_type and project_deadline fields filled in. Move it to “Won” and verify: was the GanttPRO project created, are the task deadlines correct, was a note added in Kommo?

Real case with numbers

IT integrator from Warsaw, team of 25, 8-12 new projects per month. Before the integration the handoff from sales to PM looked like this:

• The manager sent an email to the PM describing the project
• The PM created a project in GanttPRO manually, copying data from the email
• Average delay from “Won” to project creation: 1-3 business days
• 30-40% of deal data never made it into GanttPRO (budget, specific requirements from Kommo custom fields)

After the Kommo + GanttPRO integration via Exceltic.dev:

• Project is created automatically within 30 seconds of “Won”
• PM receives a GanttPRO notification and sees the already-populated project
• Handoff delay: 0
• Deal data in the project: 100%

PM time to create a project: from 45-60 minutes down to 10-15 minutes (review and detail confirmation only).

For more on setting up a Kommo pipeline for service B2B, see the dedicated article.

Who this is for

The Kommo + GanttPRO integration is relevant for:

• Agencies and IT companies where deals close in CRM and delivery happens in a project tool
• Teams with 5+ projects per month where manual creation has become a bottleneck
• Companies with standard project types - when the task structure repeats and templates can be used
• Companies where the PM team is separate from sales - the integration eliminates the information gap when a client is handed over

If your projects are unique in structure and cannot be templated, consider a Kommo + Notion or Kommo + ClickUp integration, which offer more flexibility in structuring tasks.

Frequently asked questions

Does GanttPRO support an API for creating projects from templates?

Yes. GanttPRO API v1 supports creating projects from templates, task management, resource assignment, and webhook notifications. Documentation is available at help.ganttpro.com/en/articles/API. The API is available on the Team plan and above.

How does the integration handle missing data in Kommo?

The server validates required fields before creating the project. If deal_type is not filled in, the default template is used. If project_deadline is missing, the project deadline is set to 90 days from the creation date. The manager receives a note in Kommo indicating which fields were not populated - a prompt to gather those details from the client.

Can the project status be synced back to Kommo?

Yes. When a project is completed in GanttPRO (all tasks closed), a webhook updates a custom field on the Kommo deal (“Project completed”) and can automatically create a task for the manager: “Request client testimonial” or move the deal to a special upsell stage.

What if the PM changes project dates in GanttPRO - how is that reflected in Kommo?

If a webhook is configured for the event “key task or milestone deadline changed” in GanttPRO, the server adds a note in Kommo about the date change. This gives the manager visibility to notify the client without having to monitor GanttPRO independently. More about custom Kommo integrations for project management is covered in our article.

How much does Kommo + GanttPRO integration development cost?

The basic version (project creation from template on deal win + note in Kommo) takes 2-3 weeks. With reverse synchronization (overdue tasks, project completion, deadline changes) - 3-4 weeks. We estimate after reviewing your project structure and deal types.

If the gap between closing deals in Kommo and managing projects in GanttPRO is costing your team time - describe your requirements to the Exceltic.dev team. We will work through the architecture and estimate the scope.