Pendo Integrations

Pendo provides extensive integration capabilities for connecting product analytics to CRMs, marketing automation platforms, customer support tools, and data warehouses. This guide covers native integrations, API access, webhooks, and custom implementation patterns.

Native Integrations

Pendo offers pre-built integrations with popular business tools, enabling seamless data synchronization and workflow automation.

CRM Integrations

Salesforce:

Sync Pendo product usage data to Salesforce records:

1. Navigate to Settings → Integrations → Salesforce
2. Click "Connect to Salesforce"
3. Authenticate with Salesforce credentials
4. Map Pendo visitor metadata to Salesforce fields
5. Configure sync frequency (real-time, hourly, daily)

Data Flow:

• Pendo → Salesforce: Product usage scores, feature adoption, guide engagement
• Salesforce → Pendo: Account attributes, user roles, subscription data

Use Cases:

• Enrich account records with product engagement scores
• Trigger sales alerts for high-value feature adoption
• Identify expansion opportunities based on usage patterns
• Flag at-risk accounts with declining engagement

HubSpot:

Integrate product analytics with marketing automation:

1. Settings → Integrations → HubSpot
2. Connect HubSpot account
3. Map visitor properties to HubSpot contacts
4. Configure automated workflows

Capabilities:

• Create HubSpot lists based on Pendo segments
• Trigger marketing emails based on product behavior
• Score leads using product usage data
• Track product-led growth metrics

Customer Support Integrations

Zendesk:

Connect product usage to support tickets:

1. Settings → Integrations → Zendesk
2. Authenticate with Zendesk
3. Enable Pendo widget in Zendesk interface
4. Configure data syncing

Features:

• View user's product journey in ticket sidebar
• Identify support needs based on feature usage
• Deliver contextual in-app support
• Track support ticket impact on product adoption

Intercom:

Combine product analytics with customer messaging:

1. Settings → Integrations → Intercom
2. Connect Intercom account
3. Map Pendo segments to Intercom users
4. Configure message triggers

Workflow:

• Send targeted messages based on Pendo events
• Display Pendo guides within Intercom messenger
• Segment Intercom users by product usage
• Track message effectiveness in Pendo

Collaboration Tools

Slack:

Receive Pendo notifications in Slack channels:

1. Settings → Integrations → Slack
2. Add to Slack workspace
3. Select notification types
4. Configure channel routing

Notification Types:

• Guide analytics summaries
• NPS survey responses
• Feature adoption milestones
• Segment threshold alerts

Configuration Example:

{
  "channel": "#product-insights",
  "notifications": {
    "nps_response": true,
    "guide_analytics": "daily",
    "segment_alerts": true
  }
}

Analytics & CDP Integrations

Segment:

Route Pendo events through Segment's CDP:

1. Settings → Integrations → Segment
2. Enter Segment write key
3. Configure event forwarding
4. Map event properties

Events Sent to Segment:

• Guide views and interactions
• Track events (custom and automatic)
• Page views
• Feature clicks
• Poll and NPS responses

Segment Configuration:

// Events appear in Segment as:
{
  "event": "Pendo Guide Viewed",
  "properties": {
    "guide_id": "ABC123",
    "guide_name": "Onboarding Checklist",
    "visitor_id": "user_123",
    "account_id": "account_456"
  }
}

Amplitude:

Sync product analytics between platforms:

1. Settings → Integrations → Amplitude
2. Enter Amplitude API key
3. Configure two-way data sync
4. Map user properties

Data Synchronization:

• Pendo → Amplitude: Guide engagement, poll responses
• Amplitude → Pendo: User cohorts, behavioral segments

Product Management Tools

Jira:

Link feature requests to development:

1. Settings → Integrations → Jira
2. Connect Jira instance
3. Configure issue creation triggers
4. Map feedback to Jira fields

Capabilities:

• Create Jira tickets from Pendo feedback
• Track feature request volume in Pendo
• Link guides to Jira epics
• Monitor feature delivery impact

ProductBoard:

Centralize product feedback:

1. Settings → Integrations → ProductBoard
2. Authenticate with ProductBoard
3. Configure feedback forwarding
4. Map Pendo segments to user personas

API Integration

Authentication

Pendo API uses integration keys for authentication.

Generate Integration Key:

1. Settings → Integrations → Integration Keys
2. Click "Create Integration Key"
3. Name the key (e.g., "Analytics Export")
4. Select permissions
5. Copy and securely store the key

API Request Format:

curl "https://app.pendo.io/api/v1/aggregation" \
  -H "x-pendo-integration-key: YOUR_INTEGRATION_KEY" \
  -H "Content-Type: application/json"

Aggregation API

Retrieve Product Usage Data:

curl -X POST "https://app.pendo.io/api/v1/aggregation" \
  -H "x-pendo-integration-key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "response": {
      "mimeType": "application/json"
    },
    "request": {
      "pipeline": [
        {
          "source": {
            "events": {},
            "timeSeries": {
              "period": "dayRange",
              "first": "2024-01-01",
              "count": 30
            }
          }
        },
        {
          "aggregate": {
            "eventCount": {
              "distinct": "visitorId"
            }
          }
        }
      ],
      "requestId": "unique-request-id"
    }
  }'

Response:

{
  "results": [
    {
      "data": [
        {"count": 1523, "day": "2024-01-01"},
        {"count": 1687, "day": "2024-01-02"}
      ]
    }
  ]
}

Metadata API

Retrieve Visitor Metadata:

curl "https://app.pendo.io/api/v1/visitor/USER_ID" \
  -H "x-pendo-integration-key: YOUR_KEY"

Update Visitor Metadata:

curl -X PUT "https://app.pendo.io/api/v1/visitor/USER_ID" \
  -H "x-pendo-integration-key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "metadata": {
      "auto": {
        "account_plan": "enterprise",
        "role": "admin",
        "signup_date": "2024-01-15"
      }
    }
  }'

Guide API

Retrieve Guide Analytics:

curl "https://app.pendo.io/api/v1/guide/GUIDE_ID/analytics" \
  -H "x-pendo-integration-key: YOUR_KEY"

Update Guide Status:

curl -X PUT "https://app.pendo.io/api/v1/guide/GUIDE_ID" \
  -H "x-pendo-integration-key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "state": "public"
  }'

Track Events API

Send Custom Events:

curl -X POST "https://app.pendo.io/data/track" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "track",
    "event": "custom_feature_used",
    "visitorId": "user_123",
    "accountId": "account_456",
    "properties": {
      "feature_name": "advanced_reporting",
      "usage_count": 5
    },
    "timestamp": 1640995200000
  }'

Webhooks

Configure webhooks to receive real-time notifications for Pendo events.

Webhook Setup

1. Settings → Integrations → Webhooks
2. Click "Add Webhook"
3. Enter endpoint URL (must be HTTPS)
4. Select event types
5. Add signing secret for verification
6. Save configuration

Supported Events

Guide Events:

• guide.viewed - User viewed a guide
• guide.advanced - User progressed through guide
• guide.dismissed - User dismissed guide
• guide.completed - User completed guide

Poll Events:

• poll.response - User submitted poll response

NPS Events:

• nps.response - User submitted NPS score

Track Events:

• track.event - Custom track event fired

Webhook Payload

Example: Guide Viewed Event

{
  "event_type": "guide.viewed",
  "timestamp": "2024-01-15T14:30:00Z",
  "data": {
    "guide_id": "ABC123",
    "guide_name": "Feature Announcement",
    "visitor_id": "user_123",
    "account_id": "account_456",
    "metadata": {
      "browser": "Chrome",
      "platform": "web"
    }
  }
}

Signature Verification

Verify webhook authenticity using HMAC signature.

Node.js Example:

const crypto = require('crypto');

function verifyPendoWebhook(payload, signature, secret) {
  const hmac = crypto.createHmac('sha256', secret);
  const digest = hmac.update(JSON.stringify(payload)).digest('hex');
  return signature === `sha256=${digest}`;
}

app.post('/webhook/pendo', (req, res) => {
  const signature = req.headers['x-pendo-signature'];
  const isValid = verifyPendoWebhook(req.body, signature, WEBHOOK_SECRET);

  if (!isValid) {
    return res.status(401).send('Invalid signature');
  }

  // Process webhook
  console.log('Guide viewed:', req.body.data.guide_name);
  res.sendStatus(200);
});

Data Export

CSV Export

Export Usage Data:

1. Navigate to Data → Export
2. Select date range
3. Choose data type (events, visitors, accounts)
4. Configure columns
5. Click "Export to CSV"

Automated Exports:

Configure scheduled exports:

1. Settings → Data → Scheduled Exports
2. Create new export schedule
3. Select frequency (daily, weekly, monthly)
4. Configure destination (email, SFTP, S3)
5. Map data fields

Data Warehouse Integration

Snowflake:

Export Pendo data to Snowflake:

1. Settings → Integrations → Snowflake
2. Enter Snowflake connection details
3. Configure sync schedule
4. Map tables and schemas

BigQuery:

# Python script for Pendo → BigQuery export
import requests
from google.cloud import bigquery

PENDO_API_KEY = 'your_key'
BQ_PROJECT = 'your-project'
BQ_DATASET = 'pendo_data'

# Fetch from Pendo
response = requests.post(
    'https://app.pendo.io/api/v1/aggregation',
    headers={
        'x-pendo-integration-key': PENDO_API_KEY,
        'Content-Type': 'application/json'
    },
    json={
        'request': {
            'pipeline': [
                {
                    'source': {
                        'events': {},
                        'timeSeries': {
                            'period': 'dayRange',
                            'first': '2024-01-01',
                            'count': 30
                        }
                    }
                }
            ]
        }
    }
)

data = response.json()

# Load to BigQuery
client = bigquery.Client()
table_id = f'{BQ_PROJECT}.{BQ_DATASET}.pendo_events'
job = client.load_table_from_json(data['results'], table_id)
job.result()

Custom Integration Patterns

Visitor Identification

JavaScript Implementation:

// Initialize Pendo with visitor and account data
pendo.initialize({
  visitor: {
    id: 'user_123',
    email: 'user@example.com',
    role: 'admin',
    signup_date: '2024-01-15'
  },
  account: {
    id: 'account_456',
    name: 'Acme Corp',
    plan: 'enterprise',
    mrr: 5000
  }
});

Custom Event Tracking

Track Feature Usage:

// Track custom events
pendo.track('feature_used', {
  feature_name: 'advanced_reporting',
  usage_type: 'export',
  file_format: 'pdf'
});

// Track with metadata
pendo.track('purchase_completed', {
  amount: 99.99,
  currency: 'USD',
  product_id: 'PROD-123'
});

Dynamic Segmentation

Update Visitor Metadata:

// Update visitor properties dynamically
pendo.updateOptions({
  visitor: {
    id: 'user_123',
    license_tier: 'premium', // Updated value
    feature_flags: ['new_dashboard', 'beta_features']
  }
});

Third-Party Tool Integrations

Google Analytics

Forward Pendo Events to GA:

// Listen for Pendo guide events
pendo.events.guideViewed(function(guideData) {
  gtag('event', 'guide_viewed', {
    'guide_id': guideData.guideId,
    'guide_name': guideData.guideName
  });
});

pendo.events.guideCompleted(function(guideData) {
  gtag('event', 'guide_completed', {
    'guide_id': guideData.guideId,
    'guide_name': guideData.guideName
  });
});

Mixpanel

Sync Events to Mixpanel:

// Forward Pendo track events
pendo.events.track(function(eventData) {
  mixpanel.track(eventData.eventName, {
    visitor_id: eventData.visitorId,
    account_id: eventData.accountId,
    properties: eventData.properties
  });
});

Custom Dashboards

Embed Pendo Data in Internal Tools:

// Fetch Pendo metrics for custom dashboard
async function getPendoMetrics() {
  const response = await fetch('https://app.pendo.io/api/v1/aggregation', {
    method: 'POST',
    headers: {
      'x-pendo-integration-key': PENDO_API_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      request: {
        pipeline: [
          {
            source: {
              guides: {},
              timeSeries: {
                period: 'dayRange',
                first: '2024-01-01',
                count: 7
              }
            }
          },
          {
            aggregate: {
              viewCount: {},
              completionRate: {}
            }
          }
        ]
      }
    })
  });

  return await response.json();
}

Mobile App Integration

iOS (Swift)

Initialize Pendo:

import Pendo

PendoManager.shared().setup("YOUR_API_KEY")

// Identify visitor
PendoManager.shared().startSession(
    visitorId: "user_123",
    accountId: "account_456",
    visitorData: [
        "email": "user@example.com",
        "role": "admin"
    ],
    accountData: [
        "name": "Acme Corp",
        "plan": "enterprise"
    ]
)

// Track events
PendoManager.shared().track("feature_used", properties: [
    "feature_name": "mobile_dashboard"
])

Android (Kotlin)

Setup Pendo:

import io.pendo.sdk.Pendo

Pendo.setup(this, "YOUR_API_KEY", null, null)

// Start session
Pendo.startSession(
    "user_123",
    "account_456",
    hashMapOf(
        "email" to "user@example.com",
        "role" to "admin"
    ),
    hashMapOf(
        "name" to "Acme Corp",
        "plan" to "enterprise"
    )
)

// Track custom events
Pendo.track("feature_used", hashMapOf(
    "feature_name" to "mobile_dashboard"
))

Best Practices

API Usage:

• Cache frequently accessed data to minimize API calls
• Implement retry logic with exponential backoff
• Monitor rate limits and adjust request frequency
• Use batch operations when available
• Store integration keys securely

Visitor Identification:

• Use consistent visitor IDs across platforms
• Include meaningful metadata for segmentation
• Update visitor properties as they change
• Validate data types and formats
• Avoid PII in metadata when possible

Event Tracking:

• Use descriptive event names
• Structure metadata consistently
• Track only actionable events
• Document custom events for team reference
• Test events before production deployment

Webhook Handling:

• Always verify webhook signatures
• Implement idempotency for duplicate events
• Use async processing for webhook payloads
• Log webhook failures for debugging
• Monitor webhook delivery success rate

Support Resources

• Pendo Developer Documentation
• Integration Marketplace
• API Reference
• Support Portal
• Community Forum