Kommo + Loom: call videos and transcripts in the deal card

Loom lets you record your screen and camera in seconds and share a link instead of scheduling a meeting. For sales, this means personalized video outreach: a manager records a 90-second video demonstrating a relevant scenario specifically for this client. Without a Kommo integration, the Loom link only lives in an email thread — there is no deal history, no information on whether the client watched the video, and no transcript for the next manager. With the integration, every new video automatically appears in the deal card with a transcript, and a view is recorded as an event.

What the Kommo + Loom connection delivers

Without integration:
— Manager records a Loom -> pastes the link manually into a Note or a message
— Unknown whether the client watched — no signal for follow-up
— Transcript stays in Loom; the next manager cannot see what was discussed
— After the deal is transferred to another manager — video history is unavailable in the CRM

With integration:
— Loom recorded -> transcript + link automatically in the deal Note within 2–3 minutes
— video.viewed -> Note: “Client opened the video” -> signal for a follow-up call
— Tag kommo:{deal_id} -> automatic mapping of the video to the correct deal
— Transcript in deal history — the next manager sees everything without watching the video

Architecture

Manager records a Loom with tag kommo:{deal_id}
  ↓ Loom finishes processing
  Loom Webhook: video.transcription_complete
  ↓ Backend
  1. From payload: video_id, title, share_url, transcript (text)
  2. Extract deal_id from video tags (tag = "kommo:12345")
  3. GET /api/v4/leads/{deal_id} -> verify the deal exists
  4. Kommo: POST /leads/{deal_id}/notes
     -> "Loom: {title}\n{share_url}\nTranscript: {transcript[:500]}..."
  5. Kommo: PATCH /leads/{deal_id}
     -> custom field loom_last_video_id = video_id

Loom Webhook: video.viewed (if available on the plan)
  ↓ Backend
  1. Find deal by loom_last_video_id
  2. Kommo: POST /leads/{deal_id}/notes
     -> "Loom: client watched the video - time for a follow-up"
  3. (optional) Kommo: POST /tasks -> task to call today

Loom API: key requests

Base URL: https://www.loom.com/v1.
Authentication: Bearer token (Authorization: Bearer {api_key}).
API key: Loom -> Settings -> API -> Create API key.

Retrieve video information:

import requests

LOOM_API_KEY = "your_loom_api_key"
LOOM_BASE_URL = "https://www.loom.com/v1"

headers = {
    "Authorization": f"Bearer {LOOM_API_KEY}",
    "Content-Type": "application/json"
}

def get_video(video_id: str) -> dict:
    resp = requests.get(
        f"{LOOM_BASE_URL}/videos/{video_id}",
        headers=headers
    )
    resp.raise_for_status()
    return resp.json()

def get_video_transcript(video_id: str) -> str:
    resp = requests.get(
        f"{LOOM_BASE_URL}/videos/{video_id}/transcript",
        headers=headers
    )
    if resp.status_code == 404:
        return ""
    resp.raise_for_status()
    data = resp.json()
    # Combine segments into text
    segments = data.get("segments", [])
    return " ".join(seg.get("text", "") for seg in segments)

Handle Loom Webhook:

from flask import Flask, request, abort
import hmac, hashlib

app = Flask(__name__)
LOOM_WEBHOOK_SECRET = "your_loom_webhook_secret"

def verify_loom_signature(payload: bytes, signature: str) -> bool:
    expected = "sha256=" + hmac.new(
        LOOM_WEBHOOK_SECRET.encode(),
        payload,
        hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(expected, signature)

def extract_deal_id_from_tags(video: dict) -> int | None:
    # Manager adds tag kommo:12345 when recording
    tags = video.get("tags", [])
    for tag in tags:
        if tag.startswith("kommo:"):
            try:
                return int(tag.split(":")[1])
            except (ValueError, IndexError):
                pass
    return None

@app.route("/webhooks/loom", methods=["POST"])
def loom_webhook():
    sig = request.headers.get("X-Loom-Signature", "")
    if not verify_loom_signature(request.data, sig):
        abort(403)

    payload = request.json
    event_type = payload.get("type")
    video_data = payload.get("data", {})
    video_id = video_data.get("id")

    if event_type == "video.transcription_complete":
        video = get_video(video_id)
        deal_id = extract_deal_id_from_tags(video)
        if not deal_id:
            return "", 200

        title = video.get("name", "Loom video")
        share_url = video.get("share_url", "")
        duration_sec = video.get("duration", 0)
        transcript = get_video_transcript(video_id)

        note_text = (
            f"Loom: {title} ({duration_sec}s)\n"
            f"{share_url}\n"
        )
        if transcript:
            note_text += f"\nTranscript:\n{transcript[:800]}"
            if len(transcript) > 800:
                note_text += "... (full version in Loom)"

        create_kommo_note(deal_id, note_text)
        update_kommo_deal(deal_id, {"loom_last_video_id": video_id})

    elif event_type == "video.viewed":
        video_id_from_event = video_data.get("id")
        deal_id = find_deal_by_field("loom_last_video_id", video_id_from_event)
        if deal_id:
            create_kommo_note(deal_id,
                "Loom: client opened the video - a good moment for a follow-up call")
            create_kommo_task(deal_id, "Follow-up after Loom video view")

    return "", 200

Setting up a Webhook in Loom: Settings -> Webhooks -> Add webhook endpoint. Select events: video.transcription_complete, video.viewed (available from the Business plan). A secret for verification is generated upon creation.

Using a tag to link a video to a deal

The manager adds a tag kommo:12345 to the video when uploading to Loom — via the UI or a Chrome extension. To automate this step, a bookmarklet can be created: while the manager is in the deal card, the bookmarklet opens Loom with the pre-filled tag via a URL parameter.

An alternative is a naming convention: [Kommo:12345] Demo for Acme Corp. Parsed via regex:

import re

def extract_deal_id_from_title(title: str) -> int | None:
    match = re.search(r"\[Kommo:(\d+)\]", title)
    return int(match.group(1)) if match else None

Real-world case

B2B SaaS (US, enterprise segment, Kommo + Loom, 15–20 active deals simultaneously):

• Before: managers used Loom for personalized demos, but links only lived in email. When a deal was transferred, the next manager had no idea what had already been shown.
• After: every Loom video is automatically in the deal history with a transcript. During a handover — the new manager reads the transcript in 3 minutes instead of a call with the previous one.
• Additionally: video.viewed -> follow-up task the same day -> follow-up call conversion improved because calls happened while the client was still “warm”.

Who this is relevant for

• Enterprise B2B with a long deal cycle — personalized video for each champion
• Teams with frequent deal transfers between managers — transcript in history is critical
• Sales teams that already use Loom but want to see activity in the CRM
• SDR/AE model — SDR records a warm-up video, AE continues in Kommo with the full history

Frequently asked questions

Which Loom plan is needed for webhook and API access?

API access and the video.transcription_complete webhook are available from the Business plan ($12.50/user/month). The Starter (free) plan allows recording videos but API and webhooks are locked. video.viewed — Business and above only.

How accurate is the Loom transcript?

Loom uses its own transcription engine. For English — good quality (technical terms are occasionally transcribed incorrectly). For other languages — transcription works but accuracy may be lower. Use transcripts as a helpful reference rather than a word-for-word record when dealing with non-English speakers.

How do I link a video to a deal without tags?

Via the video title: [Kommo:12345] at the beginning — the manager enters the deal ID when recording. Or via an intermediate webhook: before recording, the manager clicks a button in Kommo that generates a unique code and opens Loom with that code in the parameters. The code is stored in a pending table and matched when the webhook arrives.

Loom vs Vidyard for CRM integration?

Vidyard is focused on sales automation — deep integration with HubSpot, Salesforce, and Outreach. Loom is a general-purpose tool with an API. Both are equally implementable for a custom Kommo integration. Loom is simpler for day-to-day use; Vidyard provides richer view analytics.

Summary

• Loom API: Bearer token, https://www.loom.com/v1
• Get video: GET /videos/{video_id}, transcript: GET /videos/{video_id}/transcript
• Webhook verification: HMAC-SHA256, header X-Loom-Signature
• Video -> deal mapping: tag kommo:{deal_id} or a title pattern
• Key events: video.transcription_complete (Business+), video.viewed (Business+)
• Transcript in Note — the main value: conversation history in the deal without switching to Loom

If your team uses Loom for video outreach and you want to see activity in Kommo — describe how the current process of recording and sharing links works. Exceltic.dev will configure the mapping and webhook handler.