Heap Analytics Integrations

Integration Inventory

Native Integration Partners

Heap provides native integrations optimized for automatic event capture and behavioral analytics:

Marketing & Advertising

• Google Ads - Conversion tracking and audience sync
• Facebook Ads - Custom audience creation and optimization
• Marketo - Lead scoring and campaign attribution
• Salesforce Marketing Cloud - Journey orchestration
• Iterable - Behavioral email triggers
• Braze - Multi-channel engagement campaigns

CRM & Sales

• Salesforce - Lead qualification and opportunity tracking
• HubSpot - Contact enrichment and lifecycle stages
• Pipedrive - Deal tracking and sales attribution
• Zendesk - Customer support correlation
• Intercom - In-app messaging triggers

Data Warehouses

• Amazon Redshift - SQL-based analysis and reporting
• Google BigQuery - Cloud data warehouse integration
• Snowflake - Enterprise data platform connectivity
• Azure Synapse - Microsoft cloud analytics

Product & Analytics Tools

• Amplitude - Cross-platform behavioral analysis
• Mixpanel - Combined product analytics insights
• Segment - Customer data infrastructure
• mParticle - Data orchestration platform
• Optimizely - A/B testing and experimentation

Business Intelligence

• Looker - Custom dashboards and reporting
• Tableau - Data visualization and analysis
• Mode Analytics - SQL-based business intelligence
• Metabase - Self-service analytics platform

Heap Connect SQL

Direct SQL access to your Heap data for custom analysis and integration:

Supported Connections

• PostgreSQL-compatible drivers
• JDBC/ODBC connectivity
• Python, R, and JavaScript clients
• BI tool connectors (Tableau, Looker, Mode)

Query Capabilities

• Event-level data access
• User property filtering
• Session analysis
• Funnel queries
• Cohort definitions

API Access

Events API

• Server-side event tracking
• Offline event import
• Custom event properties
• User identity management

Connect API

• Programmatic data export
• Custom integration building
• Automated reporting workflows
• Data pipeline orchestration

Label API

• Automated event definition
• Tag management at scale
• Cross-environment synchronization

Licensing Requirements

Integration access varies by Heap plan tier:

Implementation Playbooks

Salesforce Integration Setup

Connect Heap with Salesforce for closed-loop attribution and lead enrichment:

Prerequisites

• Salesforce Administrator access
• Heap Admin or Owner role
• Heap identified users (via heap.identify())

Setup Steps

1. In Heap, navigate to Integrations > Salesforce
2. Click "Connect to Salesforce"
3. Authorize Heap to access your Salesforce org
4. Configure sync settings:
   • Select Salesforce objects (Leads, Contacts, Opportunities)
   • Map Heap user properties to Salesforce fields
   • Set sync direction (Heap → Salesforce, bidirectional)
5. Enable sync and verify connection

User Identity Mapping

// Identify users in Heap to enable Salesforce sync
heap.identify('user_12345');

heap.addUserProperties({
  'Email': 'user@example.com',
  'Company': 'Acme Corp',
  'Account_Type': 'Enterprise',
  'MRR': 5000,
  'Plan_Level': 'Pro'
});

// These properties will sync to Salesforce Lead/Contact fields

Automated Lead Enrichment

Configure Heap to automatically enrich Salesforce Leads with behavioral data:

// Track product engagement for lead scoring
heap.track('Feature Used', {
  feature_name: 'Advanced Analytics',
  usage_count: 15,
  last_used: '2025-12-26'
});

// Heap syncs engagement score to Salesforce custom field
// Lead_Score__c updates automatically based on activity

Sync Configuration

Map Heap properties to Salesforce fields:

QA Verification

1. Identify test user in Heap with known email
2. Trigger tracked events (feature usage, page views)
3. Wait for sync cycle (typically 15 minutes)
4. Verify Salesforce Lead/Contact updates
5. Check sync logs in Heap for any errors
6. Validate field mapping accuracy

BigQuery Export Setup

Export Heap data to BigQuery for advanced analysis and long-term storage:

Setup Process

1. Create Google Cloud Platform project
2. Enable BigQuery API and create dataset
3. Create service account with BigQuery Data Editor role
4. Download service account JSON key
5. In Heap, navigate to Data > BigQuery Export
6. Upload service account credentials
7. Select dataset and configure export schedule
8. Choose events and properties to export

Schema Design

Heap exports data in a denormalized format optimized for analysis:

-- Heap events table schema
CREATE TABLE heap_export.events (
  event_id STRING,
  session_id STRING,
  user_id STRING,
  time TIMESTAMP,
  event_type STRING,
  event_properties JSON,
  user_properties JSON,
  page_url STRING,
  page_title STRING,
  referrer STRING,
  device_type STRING,
  browser STRING,
  platform STRING,
  country STRING,
  region STRING,
  city STRING
);

-- Query: Feature adoption analysis
SELECT
  user_properties.plan_level,
  event_type,
  COUNT(DISTINCT user_id) as users,
  COUNT(*) as total_events,
  COUNT(*) / COUNT(DISTINCT user_id) as avg_events_per_user
FROM
  heap_export.events
WHERE
  DATE(time) >= DATE_SUB(CURRENT_DATE(), INTERVAL 30 DAY)
  AND event_type LIKE 'Feature:%'
GROUP BY
  user_properties.plan_level,
  event_type
ORDER BY
  total_events DESC;

-- Query: Conversion funnel with drop-off analysis
WITH funnel_steps AS (
  SELECT
    session_id,
    MAX(IF(event_type = 'Signup Started', 1, 0)) as started,
    MAX(IF(event_type = 'Email Verified', 1, 0)) as verified,
    MAX(IF(event_type = 'Profile Completed', 1, 0)) as completed,
    MAX(IF(event_type = 'First Purchase', 1, 0)) as purchased
  FROM
    heap_export.events
  WHERE
    DATE(time) >= DATE_SUB(CURRENT_DATE(), INTERVAL 7 DAY)
  GROUP BY
    session_id
)
SELECT
  SUM(started) as step1_signup_started,
  SUM(verified) as step2_email_verified,
  SUM(completed) as step3_profile_completed,
  SUM(purchased) as step4_first_purchase,
  ROUND(SUM(verified) / SUM(started) * 100, 2) as started_to_verified,
  ROUND(SUM(completed) / SUM(verified) * 100, 2) as verified_to_completed,
  ROUND(SUM(purchased) / SUM(completed) * 100, 2) as completed_to_purchased
FROM
  funnel_steps
WHERE
  started = 1;

Export Scheduling

• Daily sync - Full historical export once per day
• Incremental sync - New events since last export
• Real-time streaming (Premier plan) - Events appear within minutes

Google Ads Integration

Sync Heap audiences to Google Ads for targeted remarketing:

Setup Steps

1. In Heap, navigate to Integrations > Google Ads
2. Authenticate with Google account
3. Select Google Ads account to connect
4. Create audiences in Heap based on user behavior
5. Enable audience sync to Google Ads
6. Wait 24-48 hours for initial population

Audience Creation Examples

// Define audiences in Heap UI or via API
// Example 1: High-value cart abandoners
{
  "name": "High-Value Cart Abandoners",
  "definition": {
    "events": [
      {
        "type": "Add to Cart",
        "properties": {
          "cart_value": { "gt": 100 }
        },
        "within_days": 7
      }
    ],
    "exclude_events": [
      {
        "type": "Purchase",
        "within_days": 7
      }
    ]
  }
}

// Example 2: Power users for upsell campaigns
{
  "name": "Power Users - Upsell Ready",
  "definition": {
    "user_properties": {
      "plan_type": "free",
      "monthly_active_days": { "gte": 20 }
    },
    "events": [
      {
        "type": "Feature Used",
        "count": { "gte": 50 },
        "within_days": 30
      }
    ]
  }
}

Conversion Tracking

// Track Google Ads conversions in Heap
heap.track('Google Ads Conversion', {
  campaign_id: '123456789',
  campaign_name: 'Q4 Promotion',
  ad_group: 'Product Features',
  conversion_value: 129.99,
  gclid: getUrlParameter('gclid')
});

// Helper function to extract gclid
function getUrlParameter(name) {
  name = name.replace(/[\[]/, '\\[').replace(/[\]]/, '\\]');
  var regex = new RegExp('[\\?&]' + name + '=([^&#]*)');
  var results = regex.exec(location.search);
  return results === null ? '' : decodeURIComponent(results[1].replace(/\+/g, ' '));
}

Data Activation

Behavioral Segmentation

Heap's automatic event capture enables sophisticated behavioral segmentation:

Engagement Scoring

-- Calculate engagement score using Heap Connect SQL
SELECT
  user_id,
  COUNT(DISTINCT DATE(time)) as active_days,
  COUNT(DISTINCT session_id) as total_sessions,
  COUNT(*) as total_events,
  COUNT(DISTINCT event_type) as unique_event_types,
  -- Engagement score formula
  (COUNT(DISTINCT DATE(time)) * 5) +
  (COUNT(DISTINCT session_id) * 2) +
  (COUNT(DISTINCT event_type) * 10) as engagement_score
FROM
  events
WHERE
  time >= DATE_SUB(CURRENT_DATE(), INTERVAL 30 DAY)
GROUP BY
  user_id
ORDER BY
  engagement_score DESC
LIMIT 1000;

Lifecycle Stage Assignment

Automatically categorize users based on behavior patterns:

Personalization & Targeting

Intercom Integration for In-App Messaging

// Sync Heap user properties to Intercom
heap.addUserProperties({
  'Product_Stage': 'Onboarding',
  'Features_Adopted': 3,
  'Trial_Days_Remaining': 12,
  'Has_Invited_Team': false
});

// Intercom receives these properties automatically
// Create targeted messages based on Heap data

Custom Recommendations

Use Heap data to power product recommendations:

# Fetch user behavior from Heap Connect API
import requests

def get_user_recommendations(user_id):
    # Query Heap for user's recent activity
    query = f"""
    SELECT event_type, COUNT(*) as frequency
    FROM events
    WHERE user_id = '{user_id}'
    AND time >= DATE_SUB(CURRENT_DATE(), INTERVAL 30 DAY)
    GROUP BY event_type
    ORDER BY frequency DESC
    LIMIT 10
    """

    response = requests.post(
        'https://heapanalytics.com/api/connect/query',
        headers={'Authorization': f'Bearer {API_KEY}'},
        json={'query': query}
    )

    # Generate recommendations based on behavior
    events = response.json()
    return generate_recommendations(events)

Marketing Automation

Automated Campaign Triggers

Sync Heap events to marketing platforms for behavioral triggers:

// Trigger email campaigns based on user actions
heap.track('Trial Expiring Soon', {
  user_email: 'user@example.com',
  trial_end_date: '2025-12-31',
  features_used: 8,
  plan_recommended: 'Pro'
});

// Iterable/Braze receives event and triggers:
// - Day 3: Feature education emails
// - Day 5: Success story case study
// - Day 7: Pricing and upgrade CTA

Conversion Path Analysis

Identify optimal touchpoints for campaign optimization:

-- Analyze successful conversion paths
WITH conversion_paths AS (
  SELECT
    user_id,
    ARRAY_AGG(event_type ORDER BY time) as event_sequence
  FROM
    events
  WHERE
    session_id IN (
      SELECT DISTINCT session_id
      FROM events
      WHERE event_type = 'Purchase'
    )
  GROUP BY
    user_id
)
SELECT
  event_sequence,
  COUNT(*) as path_frequency,
  COUNT(*) * 100.0 / SUM(COUNT(*)) OVER() as path_percentage
FROM
  conversion_paths
GROUP BY
  event_sequence
ORDER BY
  path_frequency DESC
LIMIT 20;

Refresh Cadences & Ownership

Data Sync Schedules

Team Responsibilities

• Product Team - Define events, create segments, build funnels
• Marketing Team - Audience creation, campaign targeting, A/B testing
• Data Team - BigQuery setup, SQL analysis, data modeling
• Engineering Team - Custom integrations, API implementation, technical troubleshooting
• RevOps Team - Salesforce sync, lead scoring, attribution models

Compliance & Security

Data Governance

PII Management

Heap automatically captures user interactions but requires careful PII handling:

// Recommended: Use opaque identifiers
heap.identify('user_8a7d9f23');

// Add properties without PII
heap.addUserProperties({
  'Account_Type': 'Enterprise',
  'Industry': 'Technology',
  'Company_Size': '500-1000',
  'Region': 'North America'
});

// AVOID: Capturing PII in event properties
// DON'T DO THIS:
heap.track('Form Submitted', {
  'email': 'user@example.com',  // PII - don't track
  'ssn': '123-45-6789',          // Sensitive - never track
  'credit_card': '4111-1111'     // Highly sensitive - never track
});

Data Masking

Configure Heap to automatically mask sensitive data:

1. Navigate to Heap Settings > Data Masking
2. Add CSS selectors for sensitive form fields
3. Enable automatic masking for common PII patterns
4. Test masking in Heap debugger

Data Retention Policies

• Event data: Configurable retention (2-7 years based on plan)
• User data: Retained until deletion request
• Session replays: 90 days default, configurable up to 1 year

Privacy Compliance

GDPR Compliance

// Implement consent management
if (userConsent.analytics) {
  heap.load('YOUR-ENV-ID');
} else {
  // Don't load Heap until consent granted
  console.log('Analytics consent not provided');
}

// Handle data deletion requests
function deleteUserData(userId) {
  // Contact Heap support or use deletion API
  fetch('https://heapanalytics.com/api/user/delete', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      user_id: userId
    })
  });
}

CCPA & Regional Compliance

• Enable opt-out mechanisms
• Provide data export capabilities
• Document data sharing with third parties
• Maintain data processing agreements

Integration Security

API Key Management

• Store API keys in environment variables or secret managers
• Use separate keys for production, staging, and development
• Rotate keys quarterly
• Implement least-privilege access

Service Account Best Practices

# For BigQuery integration
# Create dedicated service account
gcloud iam service-accounts create heap-bigquery-export \
    --display-name="Heap BigQuery Export"

# Grant minimal required permissions
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member="serviceAccount:heap-bigquery-export@PROJECT_ID.iam.gserviceaccount.com" \
    --role="roles/bigquery.dataEditor"

# Create key with expiration monitoring
gcloud iam service-accounts keys create heap-bq-key.json \
    --iam-account=heap-bigquery-export@PROJECT_ID.iam.gserviceaccount.com

Advanced Integration Opportunities

Warehouse Sync: Heap's managed data pipeline exports raw event data daily to BigQuery, Snowflake, or Redshift. Use this for custom attribution models, joining behavioral data with transaction records, or feeding ML pipelines.

Reverse ETL: Use Census or Hightouch to push Heap segments and user properties back to operational tools (CRM, email, support ticketing). This enables product-led workflows triggered by Heap behavioral data.

Session Replay Integrations: Heap's session replay data can be linked to support tickets in Zendesk or Intercom, giving support teams visual context for user-reported issues. Configure in Heap's integration settings.