Kissmetrics Integrations | Blue Frog Docs

Kissmetrics integrates with a wide range of marketing, sales, and product tools to create a unified view of customer behavior across your entire stack. These integrations enable automatic event tracking, bidirectional data syncing, and cross-platform customer journey analysis without extensive custom development.

Integrations Overview

Kissmetrics offers three primary integration approaches:

Native Integrations: Pre-built, one-click integrations that automatically sync data between Kissmetrics and popular platforms. These require minimal technical setup and are maintained by Kissmetrics.

Customer Data Platform Integrations: Connect Kissmetrics through Segment, RudderStack, or mParticle to centralize data collection and distribution across your entire marketing stack.

API and Webhook Integrations: Build custom integrations using Kissmetrics' HTTP API for event tracking and properties, or receive data from Kissmetrics via webhooks for custom workflows.

Benefits of Integrated Analytics:

Unified Customer View: Combine behavioral data from multiple sources into a single customer profile
Automated Workflows: Trigger marketing actions based on Kissmetrics events and cohorts
Enhanced Attribution: Track customer journey across advertising, email, product, and support touchpoints
Reduced Implementation Time: Pre-built integrations eliminate custom coding for common use cases
Cross-Platform Segmentation: Build audiences based on combined data from multiple platforms

Native Integrations

Stripe Integration

Track subscription lifecycle events, payment data, and revenue metrics automatically from Stripe.

What Gets Tracked:

Subscription Events: Created, updated, canceled, renewed
Payment Events: Charge succeeded, charge failed, refund issued
Customer Properties: Plan name, MRR, LTV, payment method
Revenue Metrics: Transaction amount, subscription value, churn

Setup Process:

Enable Integration in Kissmetrics:
- Navigate to Settings > Integrations
- Click Stripe integration
- Click Connect to Stripe
Authorize Kissmetrics in Stripe:
- Log in to your Stripe account
- Authorize Kissmetrics to access your Stripe data
- Select which Stripe account to connect (if multiple)
Configure Event Mapping:
- Choose which Stripe events to track in Kissmetrics
- Map Stripe customer ID to Kissmetrics identity
- Set properties to capture (plan name, amount, currency, etc.)
Test Integration:
- Create a test subscription in Stripe
- Verify events appear in Kissmetrics Live feed
- Check that properties are correctly populated

Event Examples:

// Automatically tracked when subscription created
Event: "Subscription Started"
Properties:
  - plan_id: "pro_monthly"
  - plan_name: "Pro Plan"
  - amount: 99
  - currency: "USD"
  - interval: "month"
  - customer_id: "cus_ABC123"
  - subscription_id: "sub_XYZ789"

// Tracked when charge succeeds
Event: "Payment Successful"
Properties:
  - amount: 99
  - currency: "USD"
  - payment_method: "Visa ending in 4242"
  - invoice_id: "in_123456"

Common Use Cases:

Segment customers by subscription plan for targeted messaging
Track conversion from trial to paid
Identify customers at risk of churn (failed payments)
Calculate customer lifetime value (LTV) by cohort
Analyze upgrade and downgrade patterns

Troubleshooting:

Events delayed: Stripe events typically appear in Kissmetrics within 5-10 minutes
Missing events: Check that webhooks are enabled in Stripe settings
Incorrect amounts: Verify currency conversion settings if using multiple currencies

Shopify Integration

Automatic e-commerce event tracking for product views, cart additions, purchases, and customer properties.

What Gets Tracked:

Product Events: Viewed product, added to cart, removed from cart
Purchase Events: Started checkout, completed purchase, refunded order
Customer Properties: Order count, total revenue, average order value, first purchase date
Product Properties: Product name, SKU, price, category, variant

Setup Process:

Install Kissmetrics App from Shopify App Store:
- In Shopify admin, go to Apps
- Search for "Kissmetrics"
- Click Add app and authorize
Configure Tracking:
- Enter your Kissmetrics API key
- Enable e-commerce tracking
- Choose which events to track (recommended: all)
- Set up customer identification (email or customer ID)
Customize Event Names (optional):
- Map Shopify events to custom Kissmetrics event names
- Add custom properties to capture (tags, collections, etc.)
Test Integration:
- Complete a test order in your Shopify store
- Verify events appear in Kissmetrics
- Check that product and order properties are captured

Event Examples:

// Product viewed
Event: "Viewed Product"
Properties:
  - product_name: "Wireless Headphones"
  - product_id: "123456"
  - sku: "WH-1000XM4"
  - price: 349.99
  - category: "Electronics"
  - url: "https://store.com/products/wireless-headphones"

// Order completed
Event: "Completed Purchase"
Properties:
  - order_id: "1234"
  - total: 349.99
  - subtotal: 299.99
  - shipping: 10.00
  - tax: 40.00
  - currency: "USD"
  - items: [
      {name: "Wireless Headphones", quantity: 1, price: 299.99},
      {name: "Carrying Case", quantity: 1, price: 49.99}
    ]

Advanced Configuration:

Track Abandoned Carts:

// Automatically tracked when user adds to cart but doesn't purchase
Event: "Abandoned Cart"
Properties:
  - cart_value: 349.99
  - items_in_cart: 2
  - time_since_last_activity: 3600 // seconds

Customer Segmentation: Use Kissmetrics cohorts to segment by:

Number of purchases (first-time vs. repeat customers)
Total revenue (high-value vs. low-value customers)
Product categories purchased
Days since last purchase (active vs. lapsed)

Intercom Integration

Sync customer communication data, support interactions, and in-app messaging events.

What Gets Synced:

Message Events: Conversation started, message sent, message received
Support Events: Ticket created, ticket resolved, satisfaction rating
User Properties: Last seen, conversation count, support tier
Bidirectional Sync: Kissmetrics properties visible in Intercom profiles

Setup Process:

Connect Accounts:
- In Kissmetrics, go to Settings > Integrations > Intercom
- Click Connect
- Authorize Kissmetrics in Intercom
Configure Data Sync:
- Choose direction: Kissmetrics → Intercom, Intercom → Kissmetrics, or bidirectional
- Select which events to track in Kissmetrics
- Choose which Kissmetrics properties to send to Intercom
Map User Identities:
- Map email or user ID between platforms
- Handle anonymous users (optional)

Event Examples:

// Conversation started
Event: "Started Conversation"
Properties:
  - conversation_id: "conv_123"
  - source: "In-app chat"
  - initial_message: "How do I upgrade my plan?"

// Ticket resolved
Event: "Support Ticket Resolved"
Properties:
  - ticket_id: "12345"
  - resolution_time_hours: 2.5
  - satisfaction_rating: 5
  - agent: "Sarah J."

Use Cases:

Segment customers by support interaction volume for upsell campaigns
Track correlation between product usage and support needs
Identify power users who might become advocates
Trigger proactive support based on in-app behavior

Salesforce Integration

Bidirectional CRM data sync for leads, contacts, opportunities, and custom objects.

What Gets Synced:

From Kissmetrics to Salesforce: Behavioral events, engagement scores, product usage data, lifecycle stage
From Salesforce to Kissmetrics: Lead source, deal stage, account properties, custom fields
Objects Supported: Leads, Contacts, Accounts, Opportunities, Custom Objects

Setup Process:

Install Kissmetrics Package in Salesforce:
- In Salesforce Setup, go to AppExchange
- Search for Kissmetrics
- Click Get It Now and install
Configure Field Mapping:
- Map Kissmetrics properties to Salesforce fields
- Choose sync direction for each field
- Set up lead scoring based on Kissmetrics events
Set Up Triggers (optional):
- Create workflows that fire on Kissmetrics events
- Update lead status based on product usage
- Assign leads to sales reps based on engagement
Test Integration:
- Create test lead in Salesforce
- Trigger events in your product
- Verify events and properties sync to Salesforce

Sync Examples:

// Kissmetrics → Salesforce: Update lead score
When: User completes "Viewed Pricing Page" event
Action: Increase Lead Score by 10 points in Salesforce

// Salesforce → Kissmetrics: Track deal stages
When: Opportunity stage changes to "Closed Won"
Event in Kissmetrics: "Became Customer"
Properties:
  - deal_size: $50,000
  - close_date: "2024-07-15"
  - sales_rep: "John D."

Advanced Features:

Lead Scoring Based on Behavior:

// Score calculation example
Base Score: 0
+ Viewed pricing: +10
+ Started trial: +20
+ Invited team member: +15
+ Used feature 5+ times: +25
= Total Score: 70 (Hot Lead)

Automated Lead Routing:

Route high-engagement leads to senior sales reps
Assign leads based on product interest (feature usage)
Create tasks for sales when key events occur

Slack Integration

Real-time notifications for key events, cohort milestones, and data alerts.

What Gets Sent to Slack:

Event Notifications: Key conversion events, high-value signups
Cohort Alerts: User entered/exited important segment
Data Alerts: Metric thresholds crossed (e.g., churn spike)
Custom Webhooks: Any Kissmetrics event can trigger Slack message

Setup Process:

Add Kissmetrics to Slack Workspace:
- In Kissmetrics, go to Settings > Integrations > Slack
- Click Add to Slack
- Select channel for notifications
- Authorize integration
Configure Notifications:
- Choose which events trigger Slack messages
- Set up filters (e.g., only notify for high-value events)
- Customize message format and mentions
Set Up Alerts:
- Create alerts for metric thresholds
- Configure cohort milestone notifications
- Set up daily/weekly summary reports

Notification Examples:

🎉 New High-Value Signup
user@company.com just signed up for Enterprise plan!
Plan Value: $999/month
Source: Google Ads - Brand Campaign
View Profile: [Link]

---

⚠️ Churn Alert
10 users canceled in the last hour (2x normal rate)
Common attribute: All on Basic plan, churned after 30 days
Investigate: [Link to Cohort]

---

📊 Daily Summary
Yesterday's Metrics:
• 127 signups (+12% vs. last week)
• 45 upgrades (+5%)
• 12 churns (-3%)
• MRR: $152,340 (+$4,230)

Advanced Configuration:

Channel Routing by Event Type:

Product events → #product-analytics
Revenue events → #finance
Churn events → #customer-success
High-value signups → #sales

Customer Data Platform Integrations

Segment Integration

Send data from Segment to Kissmetrics or use Segment as the source of truth for all customer data.

Integration Benefits:

Single SDK Implementation: Implement Segment once, send to Kissmetrics and 300+ other tools
Data Governance: Control which events and properties flow to Kissmetrics
Historical Data Import: Backfill Kissmetrics with historical data from Segment warehouse
Simplified Maintenance: Update tracking in one place, propagates to all destinations

Setup Process:

Enable Kissmetrics Destination in Segment:
- In Segment workspace, go to Destinations
- Search for Kissmetrics
- Click Add Destination
- Enter your Kissmetrics API key
Configure Event Mapping:
- Map Segment event names to Kissmetrics event names
- Choose which events and properties to send
- Set up user identity resolution
Enable Identity Stitching:
- Configure how anonymous and identified users are merged
- Set up alias calls for user identification
- Handle multi-device tracking
Test Integration:
- Send test events through Segment
- Verify they appear in Kissmetrics
- Check property mapping

Segment SDK Examples:

// JavaScript SDK
analytics.identify('user@example.com', {
  name: 'Jane Doe',
  email: 'user@example.com',
  plan: 'Enterprise',
  company: 'Acme Inc'
});

analytics.track('Completed Purchase', {
  order_id: '12345',
  total: 99.99,
  currency: 'USD',
  products: ['Product A', 'Product B']
});

// Automatically forwards to Kissmetrics
// Event: "Completed Purchase"
// Identity: user@example.com
// Properties: order_id, total, currency, products, plan, company

Server-Side Integration:

# Python SDK
from analytics import Client
analytics = Client('SEGMENT_WRITE_KEY')

analytics.identify('user_123', {
    'email': 'user@example.com',
    'name': 'John Smith',
    'subscription_plan': 'Pro'
})

analytics.track('user_123', 'Feature Used', {
    'feature_name': 'Export Data',
    'usage_count': 5
})

Advanced Configuration:

Event Filtering: Only send high-value events to Kissmetrics to reduce costs:

// In Segment destination settings
Filter Events:
- Include: Signed Up, Completed Purchase, Upgraded Plan, Churned
- Exclude: Page Viewed, Clicked Button (too high volume)

Property Transformation: Rename or transform properties before sending to Kissmetrics:

// Segment schema controls
Map:
  - Segment "userId" → Kissmetrics "_p" (person identifier)
  - Segment "properties.revenue" → Kissmetrics "Revenue"
  - Segment "properties.product_id" → Kissmetrics "Product ID"

RudderStack Integration

Open-source alternative to Segment with similar capabilities.

Setup:

Add Kissmetrics destination in RudderStack dashboard
Configure API key and event mapping
Use RudderStack SDKs to send data

Advantages:

Self-hosted option for data residency compliance
Lower cost for high-volume implementations
More granular control over data pipelines

mParticle Integration

Enterprise customer data platform integration.

Features:

Data quality monitoring before sending to Kissmetrics
Advanced identity resolution across devices and platforms
Compliance tools (GDPR/CCPA data deletion)
Real-time and batch data forwarding

Email Platform Integrations

Mailchimp Integration

Sync Kissmetrics cohorts to Mailchimp audiences for targeted email campaigns.

What Gets Synced:

Kissmetrics cohorts → Mailchimp audiences/segments
User properties → Mailchimp merge fields
Email engagement events → Kissmetrics (opens, clicks, unsubscribes)

Setup:

Connect Mailchimp account in Kissmetrics integrations
Select cohorts to sync as audiences
Map Kissmetrics properties to Mailchimp merge fields
Enable email event tracking

Use Cases:

Send cart abandonment emails to "Abandoned Cart" cohort
Upsell campaigns to high-engagement users
Re-engagement campaigns to dormant users
Personalize emails based on product usage data

HubSpot Integration

Bidirectional sync between Kissmetrics and HubSpot for marketing automation.

Sync Capabilities:

Kissmetrics events → HubSpot timeline
Kissmetrics properties → HubSpot contact properties
HubSpot list membership → Kissmetrics cohorts
Email engagement → Kissmetrics events

Workflow Examples:

Trigger: User performs "Trial Expired" event in Kissmetrics
Action: Enroll in HubSpot "Trial Extension Offer" workflow
Result: Send personalized email with discount code

---

Trigger: Contact added to HubSpot "SQL" list
Action: Send event to Kissmetrics
Result: Update user property "Sales Stage" = "SQL"

SendGrid Integration

Track email delivery, opens, clicks, and bounces as Kissmetrics events.

Setup:

Configure SendGrid webhook to send to Kissmetrics
Map email events to Kissmetrics event names
Include user identifier in email metadata

Events Tracked:

Event: "Email Delivered"
Event: "Email Opened"
Event: "Email Clicked"
  Properties:
    - link_url
    - email_subject
    - campaign_name

Event: "Email Bounced"
Event: "Unsubscribed"

CRM and Sales Tool Integrations

HubSpot CRM (Beyond Marketing Hub)

Full CRM integration for sales activity tracking.

Sales Events in Kissmetrics:

Deal created, updated, won, lost
Meeting scheduled, completed
Call logged
Proposal sent

Product Usage in HubSpot:

Feature usage displayed on contact timeline
Engagement score as custom property
Last active date synced
Account health score

Pipedrive Integration

Track sales pipeline activity in Kissmetrics.

What Gets Synced:

Deal stage changes
Activities logged (calls, meetings, emails)
Win/loss reasons
Deal value and expected close date

Use Cases:

Correlate product usage with deal velocity
Identify which features lead to faster sales cycles
Score leads based on product engagement
Alert sales when high-value activity occurs

API and Custom Integrations

Kissmetrics HTTP API

Track events and set properties programmatically.

API Endpoints:

Track Event:

curl "https://trk.kissmetrics.io/e" \
  -d "_k=YOUR_API_KEY" \
  -d "_p=user@example.com" \
  -d "_n=Signed%20Up" \
  -d "plan=Pro" \
  -d "source=Google%20Ads"

Set Properties:

curl "https://trk.kissmetrics.io/s" \
  -d "_k=YOUR_API_KEY" \
  -d "_p=user@example.com" \
  -d "company=Acme%20Inc" \
  -d "plan=Enterprise" \
  -d "mrr=999"

Alias (Identify User):

curl "https://trk.kissmetrics.io/a" \
  -d "_k=YOUR_API_KEY" \
  -d "_p=user@example.com" \
  -d "_n=anonymous_id_12345"

Server-Side Tracking Examples:

Node.js:

const axios = require('axios');

async function trackEvent(userId, eventName, properties) {
  await axios.post('https://trk.kissmetrics.io/e', null, {
    params: {
      _k: 'YOUR_API_KEY',
      _p: userId,
      _n: eventName,
      ...properties
    }
  });
}

// Usage
await trackEvent('user@example.com', 'Completed Purchase', {
  order_id: '12345',
  total: 99.99,
  items: 3
});

Python:

import requests

def track_event(user_id, event_name, properties=None):
    params = {
        '_k': 'YOUR_API_KEY',
        '_p': user_id,
        '_n': event_name
    }
    if properties:
        params.update(properties)

    requests.post('https://trk.kissmetrics.io/e', params=params)

# Usage
track_event('user@example.com', 'Completed Purchase', {
    'order_id': '12345',
    'total': 99.99,
    'items': 3
})

Ruby:

require 'httparty'

def track_event(user_id, event_name, properties = {})
  HTTParty.post('https://trk.kissmetrics.io/e', query: {
    _k: 'YOUR_API_KEY',
    _p: user_id,
    _n: event_name
  }.merge(properties))
end

# Usage
track_event('user@example.com', 'Completed Purchase', {
  order_id: '12345',
  total: 99.99,
  items: 3
})

Webhook Integration

Receive data from Kissmetrics when specific events occur.

Setup:

Configure webhook URL in Kissmetrics settings
Choose which events trigger webhooks
Set up authentication (optional)

Webhook Payload Example:

{
  "event": "Subscription Started",
  "person": "user@example.com",
  "timestamp": 1626300000,
  "properties": {
    "plan": "Pro",
    "mrr": 99,
    "source": "Website"
  }
}

Use Cases:

Trigger custom workflows in your application
Update internal databases with Kissmetrics data
Send notifications to other systems
Custom data transformation before storing

Tag Manager Integrations

Google Tag Manager

Deploy Kissmetrics via GTM for easier maintenance and testing.

Setup Process:

Create Custom HTML Tag:

<script>
  var _kmq = _kmq || [];
  _kmq.push(['identify', '{{User Email}}']);
  _kmq.push(['record', '{{Event Name}}', {
    'property1': '{{Property 1}}',
    'property2': '{{Property 2}}'
  }]);
</script>

Load Kissmetrics Library (separate tag, fires on all pages):

<script>
  var _kmq = _kmq || [];
  var _kmk = _kmk || 'YOUR_API_KEY';
  function _kms(u){
    setTimeout(function(){
      var d = document, f = d.getElementsByTagName('script')[0],
      s = d.createElement('script');
      s.type = 'text/javascript'; s.async = true; s.src = u;
      f.parentNode.insertBefore(s, f);
    }, 1);
  }
  _kms('//i.kissmetrics.io/i.js');
  _kms('//scripts.kissmetrics.io/' + _kmk + '.2.js');
</script>

Create Variables for dynamic values:
- User Email (from data layer or cookie)
- Event names
- Event properties
Set Up Triggers:
- All Pages (for library load)
- Custom events from data layer
- Form submissions, clicks, etc.

Advantages:

No code deployment for tracking changes
A/B test tracking implementations
Version control and rollback
Preview mode for testing

Segment via GTM

Combine GTM and Segment for maximum flexibility.

Why Use Both:

GTM for client-side flexibility
Segment for centralized data management
Send Segment events to Kissmetrics and other tools

Implementation:

Load Segment via GTM (custom HTML tag)
Use GTM triggers to fire Segment track calls
Segment forwards to Kissmetrics and other destinations

Zapier Integration

Connect Kissmetrics to 5,000+ apps via Zapier automation.

Common Zaps:

Add New Kissmetrics Users to Google Sheets:

Trigger: New user identified in Kissmetrics
Action: Add row to Google Sheets
Use Case: Manual review of new signups, export for external analysis

Create Slack Alert for High-Value Events:

Trigger: Kissmetrics event "Completed Purchase" with value > $1000
Action: Send message to Slack channel
Use Case: Real-time sales notifications

Add Kissmetrics Cohort Members to Facebook Custom Audience:

Trigger: User enters Kissmetrics cohort "High Intent"
Action: Add to Facebook Custom Audience
Use Case: Retargeting campaigns

Setup:

Connect Kissmetrics account to Zapier
Choose trigger (event or cohort membership)
Choose action (update CRM, send notification, etc.)
Map fields and test

Advanced Integration Patterns

Multi-Touch Attribution

Combine Kissmetrics with advertising platforms for attribution analysis.

Data Flow:

User clicks Google Ad (GCLID captured)
User visits site (Kissmetrics tracks page view with ad source)
User signs up (Kissmetrics records conversion with ad attribution)
User upgrades (Kissmetrics tracks revenue event)
Export data to Google Ads for ROAS optimization

Implementation:

Capture UTM parameters and ad click IDs
Store as Kissmetrics properties on user profile
Track all conversion events with attribution data
Use Kissmetrics cohorts for remarketing

Product-Led Growth Stack

Integrate Kissmetrics with PLG tools for conversion optimization.

Stack Example:

Product Analytics: Kissmetrics tracks feature usage
In-App Messaging: Intercom triggered by Kissmetrics events
Email: Mailchimp sends campaigns to Kissmetrics cohorts
Sales: Salesforce updated with product usage scores from Kissmetrics
Support: Zendesk enriched with Kissmetrics engagement data

Workflow:

User signs up → Kissmetrics identifies user
↓
User reaches activation milestone → Kissmetrics event
↓
Trigger Intercom in-app message → Encourage next step
↓
User doesn't convert in 7 days → Kissmetrics cohort
↓
Mailchimp drip campaign → Educational emails
↓
User engages heavily → Kissmetrics high-score cohort
↓
Salesforce lead score increases → Sales outreach

Integration Best Practices

1. Start with High-Value Integrations:

Focus on tools with bidirectional sync potential
Prioritize integrations that close data gaps
Consider ROI of integration (time saved vs. implementation cost)

2. Maintain Data Consistency:

Use consistent user identifiers across all platforms
Standardize event names and property naming conventions
Document all integrations and data flows

3. Monitor Integration Health:

Set up alerts for integration failures
Regularly audit data quality
Test integrations after platform updates

4. Respect Data Privacy:

Only sync necessary data to each platform
Comply with GDPR/CCPA requirements
Implement data retention policies across integrated tools

5. Version Control Integration Configurations:

Document all field mappings
Save copies of integration settings
Test changes in sandbox environments before production

Troubleshooting Common Integration Issues

Issue	Possible Cause	Solution
Events not appearing in Kissmetrics	API key incorrect	Verify API key in integration settings
Duplicate users created	Identity mapping inconsistent	Ensure email/user ID mapping is correct across integrations
Properties missing	Field mapping not configured	Check property mapping in integration settings
Integration delay	Normal processing time	Most integrations have 5-15 minute delay
Webhook not firing	URL incorrect or endpoint down	Verify webhook URL and check endpoint logs

Support Resources

Kissmetrics Help Center: https://support.kissmetrics.io/
Integration Documentation: https://support.kissmetrics.io/category/integrations
API Reference: https://support.kissmetrics.io/api/
Community Forum: https://community.kissmetrics.com/
Support Email: support@kissmetrics.io