Klaviyo is an email marketing platform focused on behavioral segmentation: who opened an email, clicked a link, made a repeat purchase. Kommo is a sales pipeline: who is at which stage, when a deal closed, which manager is handling it. Without integration, these data sets exist in isolation. With integration, Klaviyo knows the deal history — and can trigger the right flow at the right moment: an offer after a deal is picked up, onboarding after Won, a win-back after a loss.
What the Kommo + Klaviyo connection delivers
Without integration:
— Klaviyo sees: email opened, clicked, purchased on site
— Does not see: pipeline stage, whether the deal closed, customer LTV from CRM
With integration:
— Contact enters a Kommo deal -> a profile is automatically created/updated in Klaviyo
— Deal Won -> Deal Won event in Klaviyo -> onboarding flow triggered
— Deal Lost -> Deal Lost event -> win-back flow triggered after 30 days
— Deal stage -> profile property crm_stage -> segmentation for targeted campaigns
What is synchronized
Kommo -> Klaviyo:
— Contact email and name -> Klaviyo profile (upsert by email)
— Company name, phone -> profile properties
— Current deal stage -> custom property crm_stage
— Deal amount -> property deal_amount
— Kommo deal ID -> property kommo_deal_id (for tracing)
— Events: Deal Created, Stage Changed, Deal Won, Deal Lost -> Events API
Klaviyo -> Kommo:
— Email interactions (optionally via Klaviyo Webhooks): open, click -> Note in the deal
Architecture
Kommo Webhook: any deal event (create, update, stage_change, won, lost)
↓ Backend
1. GET /api/v4/leads/{id} + contacts
-> email, name, company, stage, amount
2. Klaviyo API: POST /api/profile-import
-> create or update profile
-> obtain profile_id
3. Klaviyo API: POST /api/lists/{list_id}/relationships/profiles
-> add profile to the appropriate list (e.g. 'CRM Leads')
4. Klaviyo API: POST /api/events
-> record event (Deal Won, Stage Changed, etc.)
-> deal data in event propertiesKlaviyo REST API: key requests
Klaviyo API uses an API Key (Private Key). All requests go to https://a.klaviyo.com/api/. The revision header with the API version is required.
Create or update a profile:
import requests
KLAVIYO_KEY = 'pk_your_private_key'
HEADERS = {
'Authorization': f'Klaviyo-API-Key {KLAVIYO_KEY}',
'revision': '2026-04-15',
'Content-Type': 'application/json'
}
def upsert_profile(email, first_name, last_name, company, deal_stage, deal_amount, deal_id):
payload = {
'data': {
'type': 'profile',
'attributes': {
'email': email,
'first_name': first_name,
'last_name': last_name,
'organization': company,
'properties': {
'crm_stage': deal_stage,
'deal_amount': deal_amount,
'kommo_deal_id': deal_id
}
}
}
}
response = requests.post(
'https://a.klaviyo.com/api/profile-import',
headers=HEADERS,
json=payload
)
return response.json()['data']['id'] # profile_idAdd a profile to a list:
def add_to_list(profile_id, list_id):
requests.post(
f'https://a.klaviyo.com/api/lists/{list_id}/relationships/profiles',
headers=HEADERS,
json={
'data': [{
'type': 'profile',
'id': profile_id
}]
}
)
# Returns 204 on successSend an event (Track Event):
def track_event(email, event_name, deal_data):
payload = {
'data': {
'type': 'event',
'attributes': {
'profile': {
'data': {
'type': 'profile',
'attributes': {'email': email}
}
},
'metric': {
'data': {
'type': 'metric',
'attributes': {'name': event_name}
}
},
'properties': {
'deal_name': deal_data['name'],
'deal_stage': deal_data['stage'],
'deal_amount': deal_data['amount'],
'kommo_deal_id': deal_data['id']
}
}
}
}
requests.post(
'https://a.klaviyo.com/api/events',
headers=HEADERS,
json=payload
)Usage:
# On a Won event from Kommo
profile_id = upsert_profile(
email='client@company.com',
first_name='John', last_name='Smith',
company='ACME Corp',
deal_stage='Won',
deal_amount=12000,
deal_id=98765
)
add_to_list(profile_id, KLAVIYO_CUSTOMERS_LIST_ID)
track_event('client@company.com', 'Deal Won', deal_data)Segments by pipeline stage
After syncing the crm_stage property in Klaviyo, segments are created:
crm_stage = Qualification-> nurture flow with contentcrm_stage = Negotiation-> case studies and ROI materialscrm_stage = Won-> onboarding and cross-sellcrm_stage = Lost-> win-back after 30 days
Each segment updates automatically when the stage changes in Kommo — no need to manually move contacts between lists.
Real-world case
SaaS company (EU market, B2B, deal cycle 3–6 weeks):
- Before: the email marketer manually exported Won deals from Kommo once a week and uploaded them to Klaviyo. Onboarding delay — up to 7 days. Win-back for lost deals — not set up at all.
- After: Won in Kommo -> within 2 minutes the Klaviyo profile receives a
Deal Wonevent -> onboarding flow starts -> lost deals automatically receive a win-back email after 30 days. - Result: onboarding conversion improved by 18% due to timely flow start. The win-back flow recovered 4% of lost deals.
A similar approach was implemented for Brevo (Sendinblue) and Kommo — Klaviyo is stronger in behavioral segmentation, Brevo excels at multi-channel communication (email + SMS).
Who this is relevant for
- Using Klaviyo for email marketing and Kommo for sales
- Need event-driven flows based on CRM events: Won, Lost, stage change
- Deal cycle of 2+ weeks — nurture and onboarding are critical
- Marketing wants to see lead status from CRM for campaign segmentation
- Volume: 50+ contacts per month requiring personalized communication
Frequently asked questions
Is there a native Klaviyo and Kommo integration?
No native integration exists. Klaviyo offers native connectors for Shopify, WooCommerce, BigCommerce — e-commerce platforms. For CRMs like Kommo, the integration is built through the REST API. This gives full control over which events and properties are passed.
Klaviyo vs Brevo: which to choose for Kommo integration?
Klaviyo is stronger in behavioral segmentation and event-driven automation — ideal when marketing is built on data-driven triggers. Brevo wins for multi-channel communication (email + SMS + WhatsApp) and lower cost at high volume. For B2B SaaS with a long deal cycle — Klaviyo. For e-commerce and transactional communication — Brevo.
Can data from Klaviyo be synced back to Kommo?
Yes, via Klaviyo Webhooks. Klaviyo sends events (email opened, link clicked, unsubscribed) to your backend URL. The backend updates a Note or custom field in Kommo. This lets the manager see the client’s email activity directly in the deal card.
How to deduplicate profiles in Klaviyo?
Klaviyo deduplicates by email automatically when using POST /api/profile-import. If a profile with that email already exists, it is updated. It is possible to end up with multiple profiles (one by email, another by phone_number) — this is resolved via POST /api/profiles/{id}/merge.
What are the Klaviyo API rate limits?
Profile-import: 75 requests/sec (burst), 750/min (steady). Events API: similar. For a typical Kommo volume (up to 500 deals per month), the limits are not critical. During peak loads — implement a queue with exponential backoff.
Summary
- Klaviyo REST API:
POST /api/profile-import(profile upsert),POST /api/events(deal event),POST /api/lists/{id}/relationships/profiles(add to list) - Key events from Kommo:
Deal Won,Deal Lost,Stage Changed— each triggers a separate flow in Klaviyo - Segments based on the
crm_stageproperty update automatically with every Kommo change - Typical development timeline — 2 weeks
If you use Klaviyo and Kommo and want to set up automatic triggers based on pipeline events — describe which flows you need and at which events. Exceltic.dev will propose the architecture and event mapping.