Kommo + Drip: e-commerce email automation from CRM

Drip is an email platform built for e-commerce and DTC brands: behavioral segmentation based on purchases, LTV cohorts, SMS + email in one tool. Without the Kommo integration, pipeline events (Won, plan upgrade, churn) do not reach Drip — the marketer manually updates tags and sequences are delayed by days. With the integration, a stage change in Kommo instantly updates the subscriber profile in Drip and launches the appropriate automation.

Drip vs Kit (ConvertKit) for Kommo integration

Drip is focused on e-commerce: LTV segmentation, Shopify/WooCommerce integration, revenue events (order.paid, cart.abandoned). Better if your business is an online store or DTC brand.

Kit (ConvertKit) is focused on creator economy and SaaS with content onboarding. Kit integration with Kommo is the right choice for SaaS. Drip — for e-commerce and product businesses with purchases.

What gets synchronized

Kommo -> Drip: — Won -> create/update subscriber with attributes from deal — Won -> add tags customer, plan_{tier}, source_{channel} — Won -> add to post-purchase sequence — Plan change -> update plan in Drip, add/remove tags — Client lost -> add tag churned, remove active

Drip -> Kommo: — subscriber.unsubscribed -> Note + task for manager — subscriber.email_bounced -> Note + task to check email — subscriber.received_email -> (optional) Note about sequence start

Drip API v2: key requests

Base URL: https://api.getdrip.com/v2/{account_id}/. Account ID — numeric Drip account ID (in the dashboard URL). Authentication: Basic Auth — API token as username, empty password. API token: Drip -> User Settings -> API Token.

import requests
from requests.auth import HTTPBasicAuth

DRIP_API_TOKEN = "your_api_token"
DRIP_ACCOUNT_ID = "your_account_id"
DRIP_BASE_URL = f"https://api.getdrip.com/v2/{DRIP_ACCOUNT_ID}"
DRIP_AUTH = HTTPBasicAuth(DRIP_API_TOKEN, "")

def upsert_subscriber(email: str, tags: list, custom_fields: dict) -> dict:
    resp = requests.post(
        f"{DRIP_BASE_URL}/subscribers",
        auth=DRIP_AUTH,
        json={
            "subscribers": [{
                "email": email,
                "tags": tags,
                "custom_fields": custom_fields,
                "update_existing_subscriber_tags": False,  # do not overwrite existing tags
            }]
        }
    )
    resp.raise_for_status()
    return resp.json()

def record_event(email: str, action: str, properties: dict = None) -> None:
    resp = requests.post(
        f"{DRIP_BASE_URL}/events",
        auth=DRIP_AUTH,
        json={
            "events": [{
                "email": email,
                "action": action,
                "properties": properties or {},
                "occurred_at": datetime.now(timezone.utc).isoformat(),
            }]
        }
    )
    resp.raise_for_status()

def add_tags(email: str, tags: list) -> None:
    resp = requests.post(
        f"{DRIP_BASE_URL}/tags",
        auth=DRIP_AUTH,
        json={"tags": [{"email": email, "tag": tag} for tag in tags]}
    )
    resp.raise_for_status()

def remove_tag(email: str, tag: str) -> None:
    requests.delete(
        f"{DRIP_BASE_URL}/subscribers/{email}/tags/{tag}",
        auth=DRIP_AUTH
    )

def on_deal_won(lead: dict, contact: dict):
    email = get_contact_email(contact)
    name = contact["name"]
    plan = get_custom_field(lead, PLAN_FIELD_ID) or "starter"
    source = get_custom_field(lead, SOURCE_FIELD_ID) or "direct"
    amount = lead.get("price", 0)

    upsert_subscriber(email,
        tags=["customer", f"plan_{plan}", f"source_{source}"],
        custom_fields={
            "first_name": name.split()[0] if name else "",
            "plan": plan,
            "kommo_deal_id": str(lead["id"]),
            "mrr": amount,
        }
    )

    record_event(email, "deal_won", {
        "plan": plan,
        "amount": amount,
        "deal_id": lead["id"],
    })

    create_kommo_note(lead["id"],
        f"Drip: subscriber updated (tags: customer, plan_{plan})")

def on_plan_upgrade(lead: dict, contact: dict, old_plan: str, new_plan: str):
    email = get_contact_email(contact)
    remove_tag(email, f"plan_{old_plan}")
    add_tags(email, [f"plan_{new_plan}", "upgraded"])
    record_event(email, "plan_upgraded", {
        "from_plan": old_plan,
        "to_plan": new_plan,
    })

def on_deal_lost(lead: dict, contact: dict):
    email = get_contact_email(contact)
    remove_tag(email, "active")
    add_tags(email, ["churned"])
    record_event(email, "churned", {"deal_id": lead["id"]})

Handling Drip Webhooks:

from flask import Flask, request

app = Flask(__name__)

@app.route("/webhooks/drip", methods=["POST"])
def drip_webhook():
    payload = request.json
    event_type = payload.get("event")
    subscriber = payload.get("data", {}).get("subscriber", {})
    email = subscriber.get("email")

    if not email:
        return "", 200

    deal_id = find_kommo_deal_by_contact_email(email)
    if not deal_id:
        return "", 200

    if event_type == "subscriber.unsubscribed":
        create_kommo_note(deal_id, "Drip: client unsubscribed from email list")
        create_kommo_task(deal_id,
            "Clarify communication preferences - client unsubscribed from Drip")

    elif event_type == "subscriber.email_bounced":
        create_kommo_note(deal_id,
            f"Drip: email not delivered (bounce)")
        create_kommo_task(deal_id, "Check contact email - Drip recorded a bounce")

    return "", 200

Drip Webhook setup: Settings -> Webhooks -> Add Webhook. Select events. Drip does not sign webhooks with HMAC — protect your URL with a secret path segment + IP whitelist (Drip publishes their IP list).

E-commerce segmentation: LTV tag strategy

Drip allows building automations based on LTV and purchase count. For Kommo integration — pass order_count and total_value on each update:

# Add revenue event on new purchase
record_event(email, "order_completed", {
    "order_id": str(lead["id"]),
    "grand_total": amount,
    "currency": "USD",
    "items": [{"name": plan, "price": amount, "quantity": 1}]
})

# Drip automatically recalculates LTV and updates segments

Drip automatically creates LTV segments from revenue events — the marketer builds automation workflows without additional code.

Real case

DTC-SaaS (US, subscription model, Kommo + Drip + Shopify, 50–80 new clients per month):

Before: the marketer manually exported Won deals from Kommo once a week and imported them into Drip with tags. Delay of 3–7 days. Upgrades and churns were not synchronized at all.
After: Won -> Drip profile updated within a minute. Post-purchase sequence starts automatically. Drip sees the correct client segment.
Additionally: on churned tag -> Win-back automation in Drip -> series of 3 emails with a discount offer -> 12% of churned clients recovered.

Who should use this

E-commerce and DTC with a subscription model or repeat purchases
Teams where sales are in Kommo and marketing is in Drip — without current client data
Businesses with Shopify + Kommo: Drip is natively integrated with Shopify, Kommo integration closes the CRM layer
40+ active clients — at lower volumes synchronization is still manageable manually

Frequently asked questions

Drip vs Klaviyo for e-commerce?

Klaviyo is the leader for Shopify-first e-commerce, with a richer template set and predictive analytics. Drip is stronger in API flexibility and multichannel automation (email + SMS). For Kommo + Klaviyo integration the architecture is similar — the difference is in platform capabilities.

Drip account_id — where to find it?

In the Drip Dashboard URL: app.getdrip.com/{account_id}/.... The numeric ID after the domain is the account_id for the API.

How do you synchronize opt-out from a specific type of email?

Drip supports global_state: unsubscribed (full unsubscribe) and status: unsubscribed per specific campaign. Via PATCH /subscribers/{email} -> {global_state: "active"} / {global_state: "unsubscribed"}. For granular management — tag flags (no_promo, no_product_updates).

Does Drip support SMS?

Yes, via Drip SMS (US market). SMS messages are triggered from the same workflows based on tags and events. For EU — SMS integration is limited.

Summary

Drip API v2: Basic Auth (api_token:empty password), https://api.getdrip.com/v2/{account_id}/
Upsert subscriber: POST /subscribers with tags and custom_fields
Revenue event: POST /events with action order_completed for LTV segmentation
Add tag: POST /tags, remove: DELETE /subscribers/{email}/tags/{tag}
Webhook: no HMAC, protection via secret URL + IP whitelist
Key events: subscriber.unsubscribed, subscriber.email_bounced

If you use Drip and Kommo and want to synchronize your tag strategy with the pipeline — describe your current tag structure. Exceltic.dev will configure the mapping and event handling.

Kommo + Drip: e-commerce email automation from the sales pipeline