Kommo + Google Meet: meetings from the pipeline automatically

There is no separate Google Meet API — meetings are created via the Google Calendar API with the conferenceData parameter. That is where the Meet link lives. The Kommo integration automates the cycle: deal moved to the “Schedule Meeting” stage -> a Google Calendar event with a Meet link is created -> the client receives an invitation -> the link appears in the Kommo card.

Why Meet is created through Calendar, not directly

Google Meet is not a standalone platform with its own API. It is a layer on top of Google Calendar: every Meet meeting is a Calendar event with a conferenceData field. This means creating a meeting requires:

Google Calendar API (calendar.events.insert)
OAuth 2.0 with scope https://www.googleapis.com/auth/calendar
Parameter conferenceDataVersion=1 when creating the event

This is an important distinction from Zoom, which has its own Meetings API. More about the Zoom integration with Kommo — in the article Kommo + Zoom.

What gets synchronized

Kommo -> Google Calendar / Meet:
— Contact name and email -> attendee in the Calendar event
— Date and time from a Kommo custom field -> event start/end
— Deal name -> event summary
— Meeting duration (default or from a field) -> duration

Google Calendar -> Kommo:
— Meet link (hangoutLink or entryPoints[].uri) -> custom field “Meeting Link”
— Event ID -> custom field for subsequent updates or cancellation
— Status “cancelled” -> Note on the deal

Architecture

Kommo Webhook: deal moved to "Schedule Meeting" stage
  ↓ Backend
  1. GET /api/v4/leads/{id} + contacts
     -> client name, email, meeting date from custom field
  2. Google Calendar API: POST /calendars/primary/events
     -> create event with conferenceData (Meet)
     -> get hangoutLink
  3. Kommo: PATCH /leads/{id}
     -> update fields: meet_link, calendar_event_id
  4. Optional: send email invitation to client
     (Google Calendar sends automatically if email is added to attendees)

Google Calendar API: creating a Meet meeting

OAuth 2.0 authorization:

from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build

SCOPES = ['https://www.googleapis.com/auth/calendar']
creds = Credentials.from_authorized_user_file('token.json', SCOPES)
service = build('calendar', 'v3', credentials=creds)

Creating an event with Google Meet:

import uuid
from datetime import datetime, timedelta

def create_meet_event(client_email, client_name, deal_name, meeting_dt, duration_min=60):
    end_dt = meeting_dt + timedelta(minutes=duration_min)

    event = {
        'summary': f'Meeting: {deal_name}',
        'description': f'Meeting with {client_name} regarding deal {deal_name}',
        'start': {
            'dateTime': meeting_dt.isoformat(),
            'timeZone': 'Europe/Berlin',
        },
        'end': {
            'dateTime': end_dt.isoformat(),
            'timeZone': 'Europe/Berlin',
        },
        'attendees': [
            {'email': client_email, 'displayName': client_name},
        ],
        'conferenceData': {
            'createRequest': {
                'requestId': str(uuid.uuid4()),  # unique ID for idempotency
                'conferenceSolutionKey': {
                    'type': 'hangoutsMeet'
                }
            }
        },
        'sendUpdates': 'all',  # Google Calendar will send invitation to attendees
    }

    created_event = service.events().insert(
        calendarId='primary',
        body=event,
        conferenceDataVersion=1,  # required for Meet creation
        sendNotifications=True
    ).execute()

    meet_link = created_event.get('hangoutLink')
    event_id = created_event['id']
    return meet_link, event_id

Retrieving the link from the response:

# Option 1 - hangoutLink field (simplest)
meet_link = created_event.get('hangoutLink')
# Example: 'https://meet.google.com/abc-defg-hij'

# Option 2 - from entryPoints (when conferenceData is fully populated)
conf_data = created_event.get('conferenceData', {})
entry_points = conf_data.get('entryPoints', [])
video_entry = next(
    (ep for ep in entry_points if ep.get('entryPointType') == 'video'),
    None
)
meet_link = video_entry['uri'] if video_entry else None

Updating Kommo with the Meet link:

requests.patch(
    f'https://{KOMMO_DOMAIN}.kommo.com/api/v4/leads/{deal_id}',
    headers={'Authorization': f'Bearer {kommo_token}'},
    json={
        'custom_fields_values': [
            {'field_id': MEET_LINK_FIELD_ID, 'values': [{'value': meet_link}]},
            {'field_id': CALENDAR_EVENT_ID_FIELD_ID, 'values': [{'value': event_id}]},
        ]
    }
)

Cancelling a meeting on stage change

If the deal moves to the “Declined” or “Postponed” stage — the meeting needs to be cancelled:

def cancel_meet_event(event_id: str):
    service.events().delete(
        calendarId='primary',
        eventId=event_id,
        sendUpdates='all'  # notify attendees of cancellation
    ).execute()

The Event ID is taken from the Kommo custom field that was written when the meeting was created.

Edge case: conferenceData status = pending

When creating an event, Google Calendar sometimes returns conferenceData.createRequest.status = 'pending' — the Meet link is not ready yet. In this case:

import time

def get_event_with_meet(event_id: str, max_retries=5) -> str:
    for _ in range(max_retries):
        event = service.events().get(
            calendarId='primary',
            eventId=event_id
        ).execute()
        status = event.get('conferenceData', {}).get('createRequest', {}).get('status')
        if status == 'success':
            return event.get('hangoutLink')
        time.sleep(1)
    raise RuntimeError('Meet link not ready')

In practice, pending is rare — in most requests the link comes back immediately.

Real-world case

IT company (B2B sales, 8 managers, clients in EU and US):

Before: the manager manually created a Google Meet via Calendar, copied the link to Kommo, and sent it to the client in a separate email. Updated the CRM stage manually after the meeting.
After: deal on “Schedule Meeting” stage -> manager fills in date and time in the custom field -> within 30 seconds the link is in the card, and the client has received the Calendar invitation.
Additional benefit: all team meetings are visible in one corporate Calendar without manual duplication.

Similar logic was implemented for Calendly and Kommo — there the client chooses the time, here the manager sets the time from CRM.

Who this is relevant for

Team uses Google Workspace: Calendar, Gmail, Meet
5+ meetings per day currently created manually
Need the meeting link directly in the Kommo card — to open Meet in one click
Important that the client receives an official Calendar invitation, not just a link in an email
Cycle: inquiry -> qualification -> schedule meeting — automatically with no extra switching

Frequently asked questions

Is there a native Google Meet and Kommo integration?

There is no native integration. The Kommo Marketplace does not include Google Meet or Google Calendar. The integration is built via the Google Calendar API with OAuth 2.0 — this is 2–3 weeks of development. The difference from manual creation: the link appears in Kommo automatically, and the client receives an invitation without the manager’s involvement.

Is a Google service account or regular OAuth needed?

For corporate use (Google Workspace), a Service Account with Domain-Wide Delegation is preferred — it can create events on behalf of any user in the organization. For smaller teams — regular OAuth 2.0 from a specific account (manager or shared calendar@company.com).

How do I pass the client’s time zone?

The time zone is set in the start.timeZone and end.timeZone fields when creating the event. If the client is in a different time zone — Google Calendar automatically shows the time in their zone. For correct operation, the client’s time zone needs to be stored in a Kommo custom field and passed when creating the event.

Can recurring meetings be created?

Yes. Google Calendar API supports recurrence via RRULE (RFC 5545). For example, a weekly status with a client is created with a single event using recurrence: ['RRULE:FREQ=WEEKLY;COUNT=8']. All instances will share the same Meet link.

What if the manager has not filled in the meeting date field?

The webhook logic should check whether the date field is filled before creating the event. If the date is not filled — send a task to the manager in Kommo with a reminder to specify the time. This avoids creating events with incorrect data.

Summary

Google Meet is created via Calendar API: POST /calendars/primary/events with conferenceDataVersion=1
Meeting link — in the hangoutLink field of the response; saved to a Kommo custom field
Client receives a Google Calendar invitation automatically via sendUpdates: all
Meeting cancellation on stage change — DELETE /calendars/primary/events/{id}
Typical development timeline — 2 weeks

If you use Google Workspace and want to automate meeting creation from Kommo — describe the scheme: who creates the meeting (manager from Kommo or client via form), whether recurring meetings are needed. Exceltic.dev will propose the right architecture.

Kommo + Google Meet: automatic meeting creation from the deal card