Kommo + JustCall: calls, SMS, and AI transcripts from a sales phone system into the deal card

JustCall is a cloud phone system for sales teams: inbound/outbound calls, SMS and WhatsApp, power dialer, predictive dialer, AI transcription with coaching insights, SMS campaigns. It is popular among US/EU startups and scale-up teams as an alternative to Aircall or Dialpad. JustCall offers 100+ native integrations — but Kommo is not among them. We break down how to build a two-way integration: call completed -> Note with recording and AI summary in Kommo; contacts from Kommo -> JustCall.

JustCall vs Aircall vs Dialpad

JustCall is chosen by teams that need a power dialer + SMS campaigns in one tool with a limited budget.

Architecture: what is synchronized

JustCall -> Kommo:
— call_completed -> Note: agent, direction, duration, recording link, AI transcript
— call_missed -> Task: “Call back {phone}”
— sms_received -> Note: SMS body + sender number

Kommo -> JustCall:
— New contact -> POST /contacts in JustCall (for CallerID on inbound calls)
— Phone/name change -> update JustCall contact

JustCall REST API: key requests

Base URL: https://api.justcall.io/v1. Authentication: Basic Auth (API Key as username, API Secret as password — from JustCall -> Settings -> Developers -> API Keys).

import requests
from requests.auth import HTTPBasicAuth

JC_API_KEY    = "your_api_key"
JC_API_SECRET = "your_api_secret"
JC_BASE       = "https://api.justcall.io/v1"
JC_AUTH       = HTTPBasicAuth(JC_API_KEY, JC_API_SECRET)

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

def get_call_transcript(call_id: str) -> str:
    resp = requests.get(
        f"{JC_BASE}/calls/{call_id}/transcript",
        auth=JC_AUTH,
    )
    if resp.status_code == 404:
        return ""
    resp.raise_for_status()
    data = resp.json().get("data", {})
    return data.get("transcript", "")

def get_call_ai_summary(call_id: str) -> str:
    resp = requests.get(
        f"{JC_BASE}/calls/{call_id}/summary",
        auth=JC_AUTH,
    )
    if resp.status_code in (404, 422):
        return ""
    resp.raise_for_status()
    return resp.json().get("data", {}).get("summary", "")

def create_justcall_contact(name: str, phone: str,
                             email: str = "", company: str = "") -> dict:
    payload = {
        "firstname": name.split()[0] if name else "",
        "lastname":  " ".join(name.split()[1:]) if len(name.split()) > 1 else "",
        "phone":     phone,
        "email":     email,
        "company":   company,
    }
    resp = requests.post(
        f"{JC_BASE}/contacts",
        auth=JC_AUTH,
        json=payload,
    )
    resp.raise_for_status()
    return resp.json().get("data", {})

def send_sms(from_number: str, to_number: str, message: str) -> dict:
    resp = requests.post(
        f"{JC_BASE}/texts",
        auth=JC_AUTH,
        json={
            "justcall_number": from_number,
            "contact_number":  to_number,
            "body":            message,
        },
    )
    resp.raise_for_status()
    return resp.json().get("data", {})

Webhook: JustCall -> Kommo

JustCall supports webhooks: Settings -> Integrations -> Webhooks -> Add URL.

@app.route("/webhooks/justcall", methods=["POST"])
def justcall_webhook():
    payload = request.json
    event   = payload.get("type", "")
    data    = payload.get("data", {})

    if event == "call_completed":
        call_id   = str(data.get("id", ""))
        phone     = data.get("contact_number", "")
        direction = data.get("direction", "")
        duration  = data.get("duration", 0)
        agent     = data.get("agent_name", "")
        recording = data.get("recording_url", "")

        # Try to retrieve AI data (requires JustCall AI add-on)
        ai_summary = get_call_ai_summary(call_id)
        transcript = "" if ai_summary else get_call_transcript(call_id)

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

        dir_label = "Inbound" if direction == "inbound" else "Outbound"
        note_lines = [
            f"JustCall: {dir_label} ({agent}), {duration} sec.",
        ]
        if recording:
            note_lines.append(f"Recording: {recording}")
        if ai_summary:
            note_lines.append(f"AI summary: {ai_summary}")
        elif transcript:
            note_lines.append(f"Transcript: {transcript[:400]}...")

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

    elif event == "call_missed":
        phone   = data.get("contact_number", "")
        lead_id = find_kommo_lead_by_phone(phone)
        if lead_id:
            create_kommo_note(lead_id, f"JustCall: missed call from {phone}")
            create_kommo_task(lead_id, f"JustCall: call back {phone}")

    elif event == "sms_received":
        phone   = data.get("contact_number", "")
        body    = data.get("body", "")
        lead_id = find_kommo_lead_by_phone(phone)
        if lead_id:
            create_kommo_note(lead_id, f"JustCall SMS from {phone}: {body}")

    return "", 200

Power Dialer + Kommo: call queue from the pipeline

JustCall Power Dialer works with contact lists. For an automatic queue from a Kommo pipeline: a cron job runs every hour, selects leads at the required stage, and exports contacts to a JustCall Campaign via API.

def create_dialer_campaign(name: str, justcall_number: str) -> str:
    resp = requests.post(
        f"{JC_BASE}/autodialer/campaigns",
        auth=JC_AUTH,
        json={"name": name, "justcall_number": justcall_number},
    )
    resp.raise_for_status()
    return resp.json().get("data", {}).get("id", "")

def add_contacts_to_campaign(campaign_id: str, contacts: list):
    for contact in contacts:
        requests.post(
            f"{JC_BASE}/autodialer/campaigns/{campaign_id}/contacts",
            auth=JC_AUTH,
            json={"phone": contact["phone"], "name": contact["name"]},
        )

def sync_kommo_stage_to_dialer(stage_id: int, campaign_id: str):
    leads = get_kommo_leads_by_stage(stage_id)
    contacts = []
    for lead in leads:
        contact = get_kommo_contact(lead["id"])
        phone   = get_contact_phone(contact)
        if phone:
            contacts.append({"phone": phone, "name": contact.get("name", "")})
    if contacts:
        add_contacts_to_campaign(campaign_id, contacts)

JustCall AI: coaching insights in Kommo

JustCall AI (the “AI Coaching” add-on) analyzes calls and returns: overall call score, talk-to-listen ratio, sentiment, key topics, and follow-up actions. All of this is available via GET /calls/{id}/summary. When the AI add-on is present, a structured summary is added to the Note instead of a raw transcript.

Real-world case

B2B SDR team (US, 8 agents, Kommo + JustCall):

• Before: after every call, an agent spent 3–5 minutes writing a note in Kommo. Missed calls only got a task if the agent remembered. SMS from clients stayed in JustCall and never reached Kommo.
• After: call_completed -> Note automatically, call_missed -> Task automatically, sms_received -> Note. AI summary (JustCall AI add-on) -> short call recap in the Note without a verbatim transcript.
• Additionally: the power dialer campaign is populated from Kommo every day at 08:00 via cron — agents open JustCall in the morning and see an up-to-date lead queue from the pipeline.

Who this is relevant for

• SDR/BDR teams with a high volume of outbound calls — power dialer + CRM history
• Companies where sales happen through SMS + calls (US market, B2B e-commerce)
• Managers who need AI insights on agent calls directly in Kommo
• Teams with a limited budget — JustCall is cheaper than Aircall for comparable functionality

Frequently asked questions

JustCall has native integrations — why is Kommo not on the list?

JustCall supports 100+ native integrations (HubSpot, Salesforce, Pipedrive, Zoho, Freshsales). Kommo is not on the official list. JustCall is positioned for the US/Western market; Kommo is popular in EU/LatAm. A custom integration via JustCall webhook + REST API fully covers the functionality of native integrations: Notes, Tasks, Contact sync.

Can JustCall SMS campaigns be launched from Kommo?

Yes, via the JustCall Bulk SMS API: POST /texts/bulk with an array of recipients. For a campaign from a Kommo segment: select leads by tag or stage -> retrieve phone numbers -> POST to JustCall Bulk SMS. Delivery status (delivered/failed) is returned via the sms_status webhook.

Is JustCall AI available on all plans?

JustCall AI (transcription + coaching insights) is a separate add-on, available on Team and Business plans (minimum 2 users). The basic Solo plan does not include AI transcription. Without AI, GET /calls/{id}/summary returns 404. The code uses a fallback: if summary is unavailable -> retrieve the raw transcript via /transcript.

How do I match a JustCall agent to a Kommo user?

The JustCall webhook payload contains the field agent_email. If the agent’s email matches a Kommo user’s email, create the Note from the correct user via the Kommo API (the created_by parameter in the Note endpoint). Mapping: {jc_agent_email: kommo_user_id} stored in config or retrieved via Kommo GET /users.

Summary

• API: Basic Auth (API Key + API Secret), base URL https://api.justcall.io/v1
• Webhook: call_completed -> Note (recording + AI summary), call_missed -> Task, sms_received -> Note
• AI summary: GET /calls/{id}/summary (requires JustCall AI add-on), fallback to /transcript
• Power Dialer: POST /autodialer/campaigns + contacts — queue from Kommo pipeline
• Bulk SMS: POST /texts/bulk — SMS campaign to a Kommo segment

If you use JustCall and Kommo and want automatic call and SMS history in the CRM — describe your call volume and whether a power dialer is needed. Exceltic.dev will set up the integration in 2–4 business days.