Nextiva is an American UCaaS (Unified Communications as a Service) platform with VoIP, video conferencing, and team chat. For sales teams the important part is CRM integration: every call should automatically appear in the deal card with a recording, duration, and outcome. There is no native Nextiva + Kommo integration, but the Nextiva Flow API and webhook system make it possible to build a complete custom integration.
This is a standard task from the category of custom telephony integrations with Kommo: the principle is similar to JustCall, Dialpad, or CloudTalk, but the Nextiva API has its own specifics.
What does not work through Zapier
Nextiva is available in Zapier, but CRM integration via Zap has fundamental limitations.
The call mapping problem. Zapier can create a new task when a call ends, but it cannot “find” the right deal in Kommo by phone number and link the call recording to it. The result: everything goes into one generic task or gets lost.
The recordings problem. Nextiva stores call recordings behind an authenticated link. Zapier cannot download the file and pass it to Kommo as an attachment. The manager cannot see the recording directly in the CRM - they have to go to Nextiva.
The analytics problem. Call statistics (duration, initiator, call type, outcome) are not passed through the basic Zap triggers.
A custom integration via the Nextiva API solves all three problems.
Integration architecture
Nextiva Flow API is the programmatic interface for managing calls and subscribing to events. Authentication uses OAuth 2.0 client credentials.
How it works:
- An inbound or outbound call through Nextiva ends.
- Nextiva sends a webhook to the microservice with call details.
- The service searches Kommo for a contact/deal by phone number.
- If found - creates a call record in the deal timeline.
- Downloads the call recording (if recording is enabled) and attaches it to the deal.
- Updates the “Last contact” custom field in Kommo.
import requests
from datetime import datetime
NEXTIVA_TOKEN_URL = "https://api.nextiva.com/v1/oauth/token"
NEXTIVA_CALLS_URL = "https://api.nextiva.com/v1/calls"
def get_nextiva_token(client_id: str, client_secret: str) -> str:
resp = requests.post(NEXTIVA_TOKEN_URL, data={
"grant_type": "client_credentials",
"client_id": client_id,
"client_secret": client_secret,
})
resp.raise_for_status()
return resp.json()["access_token"]
def get_call_recording(access_token: str, call_id: str) -> bytes | None:
"""Retrieve the binary recording file for a call."""
headers = {"Authorization": f"Bearer {access_token}"}
resp = requests.get(
f"{NEXTIVA_CALLS_URL}/{call_id}/recording",
headers=headers
)
if resp.status_code == 404:
return None # Recording not enabled
resp.raise_for_status()
return resp.content
def process_nextiva_call_webhook(payload: dict, kommo_client, nextiva_token: str):
"""
Process a completed Nextiva call.
"""
call_id = payload["call_id"]
phone = payload["remote_phone_number"]
direction = payload["direction"] # inbound | outbound
duration_sec = payload["duration_seconds"]
start_time = payload["start_time"]
# Search Kommo for a contact by phone number
contact = kommo_client.search_contact_by_phone(phone)
if not contact:
# Create a new contact if not found
contact = kommo_client.create_contact(phone=phone)
# Find the contact's active deal
lead_id = kommo_client.get_active_lead_for_contact(contact["id"])
# Build call note text
direction_label = "Inbound" if direction == "inbound" else "Outbound"
note_text = (
f"{direction_label} Nextiva call\n"
f"Duration: {duration_sec // 60} min {duration_sec % 60} sec\n"
f"Time: {start_time}\n"
f"Call ID: {call_id}"
)
# Add note to the deal
kommo_client.add_call_note(
entity_id=lead_id or contact["id"],
entity_type="leads" if lead_id else "contacts",
text=note_text,
phone=phone,
duration=duration_sec,
direction=direction
)
# Attach call recording
recording = get_call_recording(nextiva_token, call_id)
if recording:
kommo_client.attach_file(
entity_id=lead_id or contact["id"],
filename=f"nextiva_call_{call_id}.mp3",
content=recording
)Step-by-step implementation
Step 1 - Nextiva API access. Nextiva Flow API is available on Enterprise plans and above. Contact your Nextiva account manager to activate API access. You will receive a Client ID and Client Secret.
Step 2 - configure Nextiva webhooks. In the Nextiva Admin Portal, configure Call Event Webhooks. Select the events: call.completed, call.missed. Enter the URL of your microservice.
Step 3 - phone number normalization. Phone numbers in Nextiva and Kommo may have different formats (+1-555-xxx vs 15555xx vs 555-xxx). Use the phonenumbers library to normalize to E.164 before searching.
import phonenumbers
def normalize_phone(raw: str, default_region: str = "US") -> str:
try:
parsed = phonenumbers.parse(raw, default_region)
return phonenumbers.format_number(parsed, phonenumbers.PhoneNumberFormat.E164)
except Exception:
return raw.strip()Step 4 - map call types in Kommo. Kommo supports a call note type with direction, duration, and phone fields. Use this type specifically - it appears in the timeline as a call, not as a text note.
Step 5 - enable call recording in Nextiva. In Nextiva settings, enable Call Recording for the relevant users or queues. Recordings are stored for 30/90 days depending on the plan - account for this in your design.
Step 6 - outbound calls from Kommo. For Click-to-Call from Kommo, you can add a button that initiates an outbound call via the Nextiva API. This is an optional step but significantly speeds up the manager’s workflow.
Real case: SaaS with US sales
SaaS company, 25 employees, sales team of 6. All calls through Nextiva, CRM is Kommo. Before the integration managers manually recorded each call’s outcome in Kommo. Call recordings stayed in Nextiva and nobody listened to them again - switching between systems was too inconvenient.
After the integration: every call automatically appears in the deal timeline. The sales manager listens to recordings for problem deals once a week, directly from Kommo. New hires use recordings of top-performing calls for training.
Numbers: time spent manually entering call data dropped from 45 minutes/day to zero. The percentage of deals with a complete call history rose from 60% to 100%.
Who this is for
The Kommo + Nextiva integration is relevant for:
- Companies in the US market already using Nextiva as corporate telephony
- Sales teams with a high volume of outbound calls (50+ per day)
- Managers who need call recordings for coaching purposes
- Organizations with compliance requirements for recording storage
If you are choosing between VoIP systems, also look at Kommo + JustCall and Kommo + Dialpad - both are also aimed at the US market and have more mature CRM integration APIs.
Frequently asked questions
Does Nextiva support AI transcription of calls?
Nextiva offers Voice Analytics with transcription on Enterprise plans. Transcripts are available via API 2-5 minutes after the call ends. The integration can include a separate polling mechanism or webhook to retrieve the transcript and add it as a note to the Kommo deal.
What happens with missed calls?
Nextiva sends a call.missed webhook with the caller’s number. The integration creates a “Call back” task in Kommo, assigned to the responsible manager with a deadline - for example, 2 hours. If the contact already exists in Kommo, the task is created linked to their active deal.
How does the integration work with call queues?
Nextiva supports call queues - where a call is handled by one of several agents. The webhook includes information about which agent actually answered. The integration uses this field to correctly link the call to the right manager’s deal.
Can Nextiva Team Collaboration (chat) be integrated with Kommo?
Nextiva has a separate API for team chat. It is technically possible to sync client mentions in the Nextiva chat with Kommo, but this is a more complex scenario. Typically teams start with call integration - it delivers the most immediate value.
Is multi-location support available (multiple offices)?
Yes. Nextiva Enterprise supports multiple locations with different phone numbers. The integration can be configured with a mapping: calls from the “New York” location go to the NY team’s managers in Kommo, from “Los Angeles” - to the LA team.
Next step
If you need a Kommo + Nextiva integration - describe your requirements to the Exceltic.dev team. We will review your call scenarios, queues, and recording requirements. A standard call-to-deal integration takes 2 weeks.