Kommo + CloudTalk: calls, recordings, and AI transcripts automatically in the deal card

CloudTalk is a cloud-based call center solution for EU sales and support teams: AI call transcription, power dialer, IVR, 160+ ready-made integrations, EU-based servers (GDPR-compliant). It is popular in European SaaS and e-commerce — especially where local number coverage matters (CloudTalk provides numbers in 160+ countries). Unlike Aircall or Dialpad, CloudTalk focuses on EU infrastructure and compliance. There is no native Kommo integration in the marketplace — we break down the correct architecture via API.

CloudTalk vs Aircall vs Dialpad for Kommo teams

CloudTalk is chosen by EU teams where GDPR and local number coverage are requirements, not optional.

Architecture: what gets synchronized

CloudTalk -> Kommo: — call.ended -> Note with duration, direction (in/out), link to recording — call.ended + AI transcript -> Note with transcript text (if CloudTalk AI is connected) — Missed inbound call -> Task for manager “Call back”

Kommo -> CloudTalk: — New contact/lead -> sync to CloudTalk Phone Book — Name/company change -> update CloudTalk Contact

CloudTalk REST API: key requests

Base URL: https://my.cloudtalk.io/api. Authentication: Basic Auth (API key as login, API secret as password from CloudTalk -> Account -> Integrations -> API).

import requests
from requests.auth import HTTPBasicAuth

CT_API_KEY    = "your_api_key"
CT_API_SECRET = "your_api_secret"
CT_BASE_URL   = "https://my.cloudtalk.io/api"
CT_AUTH       = HTTPBasicAuth(CT_API_KEY, CT_API_SECRET)

def get_call_detail(call_id: str) -> dict:
    resp = requests.get(
        f"{CT_BASE_URL}/calls/{call_id}.json",
        auth=CT_AUTH,
    )
    resp.raise_for_status()
    return resp.json().get("responseData", {})

def get_call_recording_url(call_id: str) -> str:
    call = get_call_detail(call_id)
    return call.get("recordingUrl", "")

def create_cloudtalk_contact(name: str, phone: str, email: str = "",
                              company: str = "") -> dict:
    payload = {
        "name":    name,
        "phone":   phone,
        "email":   email,
        "company": company,
    }
    resp = requests.post(
        f"{CT_BASE_URL}/contacts.json",
        auth=CT_AUTH,
        json=payload,
    )
    resp.raise_for_status()
    return resp.json().get("responseData", {})

def update_cloudtalk_contact(contact_id: str, data: dict) -> dict:
    resp = requests.put(
        f"{CT_BASE_URL}/contacts/{contact_id}.json",
        auth=CT_AUTH,
        json=data,
    )
    resp.raise_for_status()
    return resp.json().get("responseData", {})

Webhook: CloudTalk -> Kommo Note

CloudTalk supports webhooks: Account -> Integrations -> Webhook -> Add. The call-ended event sends a payload with call details.

@app.route("/webhooks/cloudtalk", methods=["POST"])
def cloudtalk_webhook():
    payload  = request.json
    event    = payload.get("event")
    call     = payload.get("call", {})

    if event != "call-ended":
        return "", 200

    call_id     = call.get("id")
    phone       = call.get("callerNumber") or call.get("destinationNumber", "")
    direction   = call.get("direction", "")
    duration    = call.get("talkTime", 0)
    recording   = call.get("recordingUrl", "")
    agent_name  = call.get("agentName", "")
    transcript  = call.get("transcript", "")

    lead_id = find_kommo_lead_by_phone(phone)
    if not lead_id:
        return "", 200

    dir_label = "Inbound" if direction == "inbound" else "Outbound"
    note_parts = [
        f"CloudTalk: {dir_label} call ({agent_name}), {duration} sec.",
    ]
    if recording:
        note_parts.append(f"Recording: {recording}")
    if transcript:
        short = transcript[:500] + ("..." if len(transcript) > 500 else "")
        note_parts.append(f"Transcript: {short}")

    create_kommo_note(lead_id, "\n".join(note_parts))

    if direction == "inbound" and duration == 0:
        create_kommo_task(lead_id, f"CloudTalk: missed call from {phone} - call back")

    return "", 200

Kommo -> CloudTalk contact synchronization

When a new lead is created in Kommo — the contact is added to the CloudTalk Phone Book. This allows CloudTalk agents to see the caller’s name and call history:

@app.route("/webhooks/kommo", methods=["POST"])
def kommo_lead_webhook():
    payload = request.json
    event   = payload.get("type")

    if event == "contact_add":
        contact = payload.get("data", [{}])[0]
        name    = contact.get("name", "")
        phone   = get_phone_from_contact(contact)
        email   = get_email_from_contact(contact)
        company = get_company_from_contact(contact)

        if phone:
            ct_contact = create_cloudtalk_contact(name, phone, email, company)
            save_cloudtalk_contact_id(contact["id"], ct_contact.get("id"))

    elif event == "contact_update":
        contact    = payload.get("data", [{}])[0]
        ct_id      = get_cloudtalk_contact_id(contact["id"])
        if ct_id:
            update_cloudtalk_contact(ct_id, {
                "name":    contact.get("name"),
                "company": get_company_from_contact(contact),
            })

    return "", 200

CloudTalk AI: transcription and summaries

CloudTalk AI (available on Expert plans) automatically transcribes calls and generates summaries. The transcript is passed in the webhook payload in the transcript field, the summary in aiSummary. For Kommo Note it is enough to include both fields:

def format_cloudtalk_note(call: dict) -> str:
    lines = []
    direction = "Inbound" if call.get("direction") == "inbound" else "Outbound"
    lines.append(
        f"CloudTalk: {direction}, {call.get('talkTime', 0)} sec, "
        f"agent: {call.get('agentName', '')}"
    )
    if call.get("recordingUrl"):
        lines.append(f"Recording: {call['recordingUrl']}")
    if call.get("aiSummary"):
        lines.append(f"AI summary: {call['aiSummary']}")
    elif call.get("transcript"):
        preview = call["transcript"][:300]
        lines.append(f"Transcript: {preview}...")
    return "\n".join(lines)

Real case

B2B SaaS (Czech Republic, 40 people, Kommo + CloudTalk + EU numbers):

• Before: after each call, the manager manually wrote a note in Kommo — what was discussed, next steps. 5–10 minutes of administrative work per call. Missed calls were lost — there was no systematic follow-up.
• After: call-ended -> Note with duration + recording link automatically. CloudTalk AI transcript -> first 300 characters in Note. Missed call -> Task “Call back” assigned to the same manager.
• Result: administrative overhead per call — from 8 min to 0 (manager only adds their own summary if needed). Follow-up on missed calls: 100% vs ~60% previously. Team lead started listening to recordings via Kommo Notes directly — without logging into CloudTalk.

Who should use this

• EU sales teams where GDPR matters: call data on CloudTalk EU servers
• Companies with localized numbers (Germany, France, Netherlands) — CloudTalk 160+ countries
• SDR/BDR teams with high outbound volume — power dialer + automatic history
• Support teams where interaction history in the CRM is critical

Frequently asked questions

Does CloudTalk have a native integration with Kommo?

CloudTalk has native integrations with HubSpot, Pipedrive, Salesforce, and Freshdesk. Kommo — no. CloudTalk supports a Generic CRM Integration via their open webhook + REST API. Exceltic.dev builds a custom two-way connector: CloudTalk webhook -> Kommo Notes, Kommo webhook -> CloudTalk Contacts.

How does CloudTalk identify which manager handled the call?

The webhook payload has agentId and agentName — the CloudTalk agent who answered/made the call. If Kommo users match CloudTalk agents (same email), you can match by email and create Notes from the correct user via the Kommo API using the created_by parameter.

CloudTalk Power Dialer — how to integrate with the call queue from Kommo?

CloudTalk Power Dialer works with contact lists inside CloudTalk. To automatically load a queue from Kommo: a cron job every hour selects leads in the required pipeline stage -> creates/updates contacts via the CloudTalk Contacts API -> adds them to a Dialer Campaign via POST /campaigns/{id}/contacts. This way the manager opens CloudTalk in the morning and sees a call queue sourced from the Kommo pipeline.

Where are CloudTalk call recordings stored?

On CloudTalk servers (EU, AWS eu-west-1). The link in the webhook is a direct link to an MP3/WAV file, valid for 7 days without authentication. For long-term storage: on webhook receipt — download the recording to S3/GCS, save a permanent link in the Kommo Note. CloudTalk Enterprise offers a custom retention period.

Summary

• API: Basic Auth (API key + API secret), base URL https://my.cloudtalk.io/api
• Webhook call-ended -> Note in Kommo: direction, duration, agent, recording, transcript
• CloudTalk AI transcript and aiSummary available on Expert plans — no separate service needed
• Missed call -> Task “Call back” — 100% follow-up
• Kommo Contacts -> CloudTalk Phone Book sync — agent sees client name on call

If you use CloudTalk and Kommo and want automatic call history in the CRM — describe your call volume and whether AI transcripts are needed. Exceltic.dev will configure the integration in 3–5 business days.