Kommo + Dialpad: AI transcripts and call recordings in the deal card

Dialpad is a cloud telephony platform with a native AI layer: real-time call transcription, automatic Action Items extraction, caller sentiment analysis, and Real-time Assist Cards (coaching prompts for the manager during the call). Unlike Aircall or RingCentral, Dialpad builds its AI layer on top of telephony as a core feature, not an add-on. Without the Kommo integration, call data lives in Dialpad. With the integration, every completed call becomes a Note with transcript, Action Items, and a recording link in the deal card.

Dialpad vs Aircall vs Gong for CRM integration

Dialpad is chosen by teams that need telephony + AI coaching in one product without the enterprise price tag of Gong.

What gets synchronized

Dialpad -> Kommo: — call.ended -> Note with AI summary, duration, link to recording — Action Items from call -> Tasks in Kommo — Sentiment (if negative) -> task: “Client expressed dissatisfaction — follow-up” — Update “Last call” field in deal

Kommo -> Dialpad: — Creating a call from the deal card via Click-to-Call (native Dialpad feature)

Dialpad API: key requests

Base URL: https://dialpad.com/api/v2. Authentication: OAuth 2.0 or API Key (for server-side integrations). API Key: Dialpad Admin -> API -> Create API Key.

import requests
from datetime import datetime, timezone, timedelta

DIALPAD_API_KEY = "your_api_key"
DIALPAD_BASE_URL = "https://dialpad.com/api/v2"
HEADERS = {
    "Authorization": f"Bearer {DIALPAD_API_KEY}",
    "Content-Type": "application/json",
}

def get_call(call_id: str) -> dict:
    resp = requests.get(
        f"{DIALPAD_BASE_URL}/calls/{call_id}",
        headers=HEADERS,
    )
    resp.raise_for_status()
    return resp.json()

def get_call_transcript(call_id: str) -> dict:
    # Returns full transcript with utterances
    resp = requests.get(
        f"{DIALPAD_BASE_URL}/calls/{call_id}/transcript",
        headers=HEADERS,
    )
    resp.raise_for_status()
    return resp.json()

def list_calls(started_after: str, started_before: str) -> list:
    # For polling: ISO 8601 timestamps
    resp = requests.get(
        f"{DIALPAD_BASE_URL}/calls",
        headers=HEADERS,
        params={"started_after": started_after, "started_before": started_before},
    )
    resp.raise_for_status()
    return resp.json().get("items", [])

def build_call_note(call: dict, transcript: dict) -> str:
    duration_sec = call.get("duration", 0)
    duration_str = f"{duration_sec // 60} min {duration_sec % 60} sec"
    recording_url = call.get("recording_url", "")
    started = call.get("date_started", "")[:10]
    direction = "Inbound" if call.get("direction") == "inbound" else "Outbound"

    lines = [
        f"Dialpad: {direction} call ({started}), {duration_str}",
    ]
    if recording_url:
        lines.append(f"Recording: {recording_url}")

    # Action Items from AI
    action_items = call.get("ai_summary", {}).get("action_items", [])
    if action_items:
        lines.append("\nAction Items (AI):")
        for item in action_items[:5]:
            lines.append(f"  • {item}")

    # Sentiment
    sentiment = call.get("ai_summary", {}).get("sentiment", "")
    if sentiment:
        lines.append(f"\nSentiment: {sentiment}")

    return "\n".join(lines)

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

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

    call_id    = payload.get("call_id")
    call       = payload.get("call", {})
    contact_ph = call.get("contact", {}).get("phone", "")

    deal_id = find_deal_by_phone(contact_ph)
    if not deal_id:
        # Try by email
        contact_email = call.get("contact", {}).get("email", "")
        if contact_email:
            deal_id = find_deal_by_email(contact_email)
    if not deal_id:
        return "", 200

    note = build_call_note(call, {})
    create_kommo_note(deal_id, note)

    # Action Items -> tasks
    for item in call.get("ai_summary", {}).get("action_items", [])[:3]:
        create_kommo_task(deal_id, f"Dialpad Action Item: {item}")

    # Negative sentiment -> special task
    sentiment = call.get("ai_summary", {}).get("sentiment", "")
    if sentiment == "negative":
        create_kommo_task(deal_id,
            "Dialpad: client expressed dissatisfaction - urgent follow-up")

    return "", 200

Action Items: how Dialpad AI creates tasks

Dialpad AI automatically extracts Action Items from the conversation — phrases like “I will send you…”, “call me…”, “let’s align by Friday…”. Through the Kommo integration, these AI-extracted points become tasks in the deal card. The manager ends the call and sees tasks already created — without manual entry.

Real-time Assist Cards are a separate Dialpad feature: prompts appear in the Dialpad UI during the call when key words are mentioned (competitors, pricing, objections). They are not passed to Kommo — this is a real-time coaching tool.

Real case

B2B SaaS (Canada, 12 managers, 80–120 calls/day, Kommo + Dialpad):

• Before: after each call — 5 minutes of entering results into the CRM. 40% of calls had no Notes at all. Action Items were lost in the manager’s memory.
• After: call.ended -> Note with AI summary + Action Items -> tasks in Kommo. The manager comes to the next call — the card has the full history. CRM data entry time: 0 min.
• Additionally: sentiment analysis -> on a negative call, Customer Success receives a task the same day. Churn prevention: 3 clients saved in the first quarter through immediate response.

Who should use this

• Teams with 20+ calls per day where CRM data entry is a bottleneck
• Companies already using Dialpad who want to build a CRM layer
• Sales teams where coaching is critical — Dialpad Assist Cards + CRM integration
• SMB companies that need Gong-level AI capabilities without the enterprise price

Frequently asked questions

When is the Dialpad transcript available after a call?

The AI transcript in Dialpad is ready within a few minutes of the call ending (unlike Gong with a 1–4 hour delay). The call.ended webhook fires immediately, and AI summary data is typically included in the payload.

Does Dialpad support EU data residency?

Dialpad has an EU region for data storage (calls, transcripts). It is configured at account creation. For GDPR-compliant storage of calls with EU clients — confirm this during onboarding.

Can Real-time Assist Cards be configured using Kommo data?

Not directly — Assist Cards are configured in Dialpad for specific keywords. But it is possible to build: on keyword mention -> Dialpad webhook -> enrich with Kommo data (plan, history) -> display in custom UI. This is enterprise-level customization.

Dialpad vs Aircall — which to choose for Kommo?

Aircall: more mature integration with popular CRMs, simple setup. Dialpad: AI transcription and Assist Cards natively, single platform for telephony + video (Dialpad Meetings). For teams where AI coaching matters — Dialpad. For teams where the easiest and fastest setup matters — Aircall.

Summary

• Dialpad API: Bearer {api_key}, https://dialpad.com/api/v2
• Webhook call.ended -> Note with AI summary + Action Items as Kommo tasks
• AI transcript ready within minutes of the call (not hours)
• Sentiment analysis -> negative -> priority task for CS team
• Action Items extracted by AI automatically — manager does not manually enter call results

If you use Dialpad and Kommo and want to see AI call summaries in deal cards — describe your call volume and what needs to be captured. Exceltic.dev will configure the webhook and Action Items mapping.