Kommo + 8x8: UCaaS Call Recordings and Transcripts in the Deal Card

When Kommo and 8x8 are integrated, every completed call automatically appears in the timeline of the relevant deal: date, duration, direction (inbound/outbound), recording, and transcript. Sales reps stop switching between tabs and stop entering notes manually.

8x8 is a UCaaS (Unified Communications as a Service) platform that combines voice, video conferencing, and team chat in a single solution. It is popular among international companies as a corporate replacement for fragmented phone systems. Unlike purpose-built sales dialers (Aircall, JustCall), 8x8 is full corporate telephony, which creates friction when integrating with CRM: the API is structured differently and call events arrive in a different format.

In 7 out of 10 projects connecting corporate UCaaS telephony to Kommo, we see the same pattern: sales managers work across two systems in parallel - they make calls through 8x8, then try to recall the conversation context or transfer it manually into the CRM. The 8x8 native widget does not pass custom call fields (direction, duration by segment, outcome) and cannot link a recording to a specific deal when a contact has multiple active pipelines. That is precisely where context is lost when a client is handed between managers. This article covers the integration architecture that closes these gaps, using custom fields in Kommo and automatic full-cycle call logging.

Why the native integration does not work

8x8 has no ready-made integration with Kommo. 8x8 is absent from the Kommo Marketplace. The only path without custom development is Zapier, but three problems arise:

First, the 8x8 Zapier trigger fires on “call ended” but does not pass the Kommo contact identifier - meaning you cannot automatically link a call to the correct deal without additional phone-number matching logic.

Second, 8x8 stores call recordings on its own servers with a limited retention period (depending on the plan). Zapier cannot download the audio file and attach it to the Kommo card.

Third, call transcripts in 8x8 appear with a delay of up to 15-20 minutes after the conversation ends. A Zapier step triggered at call end sees only metadata, not the text.

What gets built - solution architecture

8x8 (call ended)
        |
        v
  8x8 Webhook -> Your server
  - phone_from, phone_to, duration, call_id
        |
        v
  Matching logic:
  - search Kommo contact by phone number
  - identify the contact's active deal
        |
        v
  Kommo API:
  - add call note
  - create task if no answer
        |
  (20 min later - polling or webhook)  |
        v
  8x8 API: retrieve transcript
        |
        v
  Kommo API: attach transcript to note

The key architectural point is matching the phone number from 8x8 to a contact in Kommo. 8x8 passes numbers in E.164 format (+12025551234). Kommo stores phones in various formats. Normalizing both values before comparison is a mandatory step.

Technical details

8x8 provides two API types: CPaaS API (for programmable telephony) and Work API (for UCaaS functionality). CRM integration uses Work API v2 - it gives access to call records, recordings, and transcripts.

Authentication is OAuth 2.0 with a Bearer token. Webhooks are configured in 8x8 Admin Console -> Integrations -> Webhooks.

import requests
import re
from flask import Flask, request, jsonify
import time

app = Flask(__name__)

EIGHTx8_API_BASE = "https://api.8x8.com/work/v2"
EIGHTx8_TOKEN = "your_8x8_api_token"

def normalize_phone(phone: str) -> str:
    """Normalize phone number to E.164 format without +"""
    digits = re.sub(r"\D", "", phone)
    if len(digits) == 10:  # US number without country code
        digits = "1" + digits
    return digits

def find_kommo_deal_by_phone(phone: str):
    """Find a deal in Kommo by contact phone number"""
    normalized = normalize_phone(phone)
    contacts = kommo_api.search_contacts_by_phone(normalized)
    if not contacts:
        return None
    # Take the contact with an open deal
    for contact in contacts:
        deals = kommo_api.get_contact_deals(contact["id"], statuses=["open"])
        if deals:
            return deals[0], contact
    return None

@app.route("/8x8/webhook", methods=["POST"])
def handle_8x8_webhook():
    data = request.json
    event = data.get("event")  # call.ended
    
    if event != "call.ended":
        return jsonify({"ok": True})
    
    call_data = data["call"]
    call_id = call_data["id"]
    duration_sec = call_data.get("duration", 0)
    direction = call_data.get("direction", "inbound")  # inbound | outbound
    
    # Determine who the external party is
    if direction == "outbound":
        external_phone = call_data["to"]
    else:
        external_phone = call_data["from"]
    
    result = find_kommo_deal_by_phone(external_phone)
    if not result:
        # Contact not found - create new lead or skip
        return jsonify({"ok": True, "msg": "Contact not found"})
    
    deal, contact = result
    duration_min = duration_sec // 60
    duration_str = f"{duration_min} min {duration_sec % 60} sec"
    
    note_text = (
        f"8x8 call ({direction})\n"
        f"Duration: {duration_str}\n"
        f"Number: {external_phone}\n"
        f"Call ID: {call_id}"
    )
    
    if duration_sec == 0:
        note_text += "\nNo answer"
        kommo_api.create_task(
            deal["id"],
            text=f"Call back: missed call from {external_phone}",
            deadline_hours=2
        )
    
    kommo_api.add_note(deal["id"], note_text)
    
    # Schedule transcript retrieval in 20 minutes
    schedule_transcript_fetch(call_id, deal["id"], delay_seconds=1200)
    
    return jsonify({"ok": True})

def fetch_and_attach_transcript(call_id: str, deal_id: int):
    headers = {"Authorization": f"Bearer {EIGHT_X8_TOKEN}"}
    resp = requests.get(
        f"{EIGHT_X8_API_BASE}/calls/{call_id}/transcript",
        headers=headers
    )
    if resp.status_code == 200:
        transcript = resp.json().get("text", "")
        if transcript:
            kommo_api.add_note(
                deal_id,
                f"8x8 call transcript:\n\n{transcript[:2000]}"
            )

Step-by-step implementation

Step 1. Enable API access in 8x8

Go to 8x8 Admin Console -> Account -> API Access. Create an API key with the permissions calls:read, recordings:read, transcripts:read. Save the token - it is required for all API requests.

Step 2. Configure a webhook in 8x8

In 8x8 Admin Console -> Integrations -> Webhooks, create a new webhook with the URL https://yourserver.com/8x8/webhook. Select the events: call.ended, call.missed. The system will send a test request to verify the endpoint is reachable.

Step 3. Configure custom fields in Kommo

Add fields to the deal: last_call_duration (text), last_call_direction (dropdown), call_count_total (number). This enables building reports and filtering deals by communication activity.

Step 4. Configure missed-call logic

When duration = 0, the integration creates a “Call back” task with a 2-hour deadline and assigns it to the deal’s responsible manager. This is critical for teams where inbound calls are the primary lead channel.

Step 5. Configure recording storage

If you need to store call recordings (not just links), add logic to download the audio file via the 8x8 API and upload it to cloud storage (S3, Google Cloud Storage). Add the file link to the Kommo note. This matters when the 8x8 plan does not include long-term recording retention.

Real case with numbers

A European B2B professional services company uses 8x8 as its corporate PBX. 15 sales managers make 200-300 calls per week.

Before the integration the situation was typical: managers logged calls manually after conversations, and roughly 30-40% of calls never made it into the CRM. The client communication history was incomplete, and it was hard for management to understand where a deal stood.

A common scenario: a manager changed, the new hire opened the card, saw no context - called the client again, asked the same questions, lost trust.

After the Kommo + 8x8 integration via Exceltic.dev:

• 100% of calls are recorded in the deal card automatically
• Transcripts let management hear real conversations without listening to recordings
• Callback tasks are created automatically - no missed call is lost
• Time spent on manual logging: 0

For guidance on setting up a Kommo CRM pipeline that accounts for phone activity, see the dedicated article.

Who this is for

The Kommo + 8x8 integration is relevant for:

• Companies using 8x8 as their corporate PBX who want to see call history in the CRM
• Teams with 10+ sales managers where manual logging is not scalable
• B2B with a long deal cycle - communication history is critical when handing a client between managers
• Companies with compliance requirements for call recording - the integration helps store and locate specific recordings

If you use a purpose-built sales dialer (Aircall, JustCall, CloudTalk), ready-made solutions already exist for those. 8x8 as a UCaaS platform requires custom development, but it is justified when telephony is used company-wide rather than just by the sales team.

For a broader look at IP telephony integration with CRM systems, see the overview article.

Frequently asked questions

Does 8x8 support webhook notifications for calls?

Yes. The 8x8 Work API supports webhooks for the events call.ended, call.missed, and call.answered. Webhooks are configured in the Admin Console and deliver events in real time. Documentation is available at developer.8x8.com. API access requires at minimum the X2 or X4 (Business) plan.

How does the integration determine which deal to link a call to?

By phone number. When 8x8 sends a webhook with the external party’s number, the server searches Kommo for a contact with that number (with format normalization). If the contact has multiple open deals, the most recently active one is used. If there is no contact, you can configure automatic new-lead creation or send a notification to the manager.

Are transcripts available on all 8x8 plans?

AI-powered call transcription is available on the X4 plan and above. On X2, only recordings are available without transcripts. If transcription is not needed, the integration still works - just without the step that retrieves the conversation text.

Can the integration automatically create a lead for an inbound call from an unknown number?

Yes. If 8x8 sends a webhook with a number that does not exist in Kommo, the server can automatically create a new contact and deal at the first pipeline stage. This is especially useful for companies where an inbound call is the primary channel for new inquiries. More about custom Kommo integrations for automating inbound requests.

How long does Kommo + 8x8 integration development take?

The basic version (call logging + notes + callback tasks) takes 2-3 weeks. With transcription and recordings - 3-4 weeks. If integration with other company systems (ERP, helpdesk) is needed, we estimate separately.

If 8x8 is your corporate telephony and you want all calls visible in Kommo - describe your requirements to the Exceltic.dev team. We will work through the architecture for your call stack and estimate the scope of work.