Woopra Integrations | OpsBlu Docs

Woopra Integrations

How to connect Woopra with CRMs, marketing automation, data warehouses, and other analytics tools.

Overview

Woopra integrates with dozens of popular business tools to centralize your customer data and enable powerful workflows. Connect your CRM, marketing automation, support, and communication platforms to get a complete view of your customers.

Native Integrations

CRM Platforms

Salesforce

  • Sync customer data bidirectionally
  • Create leads and contacts from Woopra
  • View Woopra analytics in Salesforce
  • Trigger workflows based on user behavior
// Track Salesforce-related events
woopra.track('crm_contact_created', {
  contact_id: 'SF_12345',
  source: 'web_form'
});

HubSpot

  • Sync contacts and companies
  • Trigger HubSpot workflows from Woopra events
  • View user timeline in HubSpot
  • Score leads based on engagement

Pipedrive

  • Create and update deals
  • Sync contact information
  • Track sales pipeline activities

Marketing Automation

Marketo

  • Sync lead data
  • Trigger campaigns from user actions
  • Track email engagement
  • Score leads dynamically

Mailchimp

  • Sync subscriber data
  • Segment based on behavior
  • Trigger email campaigns
  • Track email performance

Campaign Monitor

  • Sync subscriber lists
  • Personalize campaigns
  • Track engagement metrics

Customer Support

Zendesk

  • View customer journey in support tickets
  • Create tickets from Woopra
  • Sync customer data
  • Track support interactions
// Track support interactions
woopra.track('support_ticket_created', {
  ticket_id: 'ZD_789',
  category: 'technical_issue',
  priority: 'high'
});

Intercom

  • Sync user data
  • Trigger messages based on behavior
  • View user timeline
  • Track conversation metrics

Help Scout

  • View customer context in conversations
  • Sync contact information
  • Track support metrics

Communication

Slack

  • Send notifications for key events
  • Alert team on high-value actions
  • Monitor user activity
// Example: Trigger Slack notification for high-value events
woopra.track('enterprise_signup', {
  company: 'Acme Corp',
  plan_value: 999,
  notify_slack: true
});

Microsoft Teams

  • Post notifications to channels
  • Alert on important user actions

Data Warehouse

Segment

  • Send Woopra data to Segment
  • Distribute to other tools
  • Centralize event tracking
// Track through both Woopra and Segment
analytics.track('purchase', { amount: 99 });  // Segment
woopra.track('purchase', { amount: 99 });     // Woopra

Google BigQuery

Amazon Redshift

  • Export analytics data
  • Combine with other data sources

API Integration

REST API

Send events and identify users via API:

# Track event
curl "https://www.woopra.com/track/ce/" \
  -X POST \
  -d "host=example.com" \
  -d "event=purchase" \
  -d "cv_email=user@example.com" \
  -d "ce_amount=99.99" \
  -d "ce_product=Pro Plan"

Identify API

# Identify user
curl "https://www.woopra.com/track/identify/" \
  -X POST \
  -d "host=example.com" \
  -d "cv_email=user@example.com" \
  -d "cv_name=John Doe" \
  -d "cv_plan=enterprise"

Python Integration

import requests

class WoopraIntegration:
    def __init__(self, domain):
        self.domain = domain
        self.base_url = "https://www.woopra.com/track"

    def track_event(self, email, event_name, properties=None):
        """Track event via API"""
        url = f"{self.base_url}/ce/"

        params = {
            'host': self.domain,
            'event': event_name,
            'cv_email': email
        }

        if properties:
            for key, value in properties.items():
                params[f'ce_{key}'] = value

        response = requests.post(url, data=params)
        return response.status_code == 200

    def identify_user(self, email, properties=None):
        """Identify user via API"""
        url = f"{self.base_url}/identify/"

        params = {
            'host': self.domain,
            'cv_email': email
        }

        if properties:
            for key, value in properties.items():
                params[f'cv_{key}'] = value

        response = requests.post(url, data=params)
        return response.status_code == 200

# Usage
woopra = WoopraIntegration('example.com')

# Identify user
woopra.identify_user('user@example.com', {
    'name': 'John Doe',
    'plan': 'enterprise'
})

# Track event
woopra.track_event('user@example.com', 'feature_used', {
    'feature': 'export',
    'format': 'csv'
})

Webhooks

Outgoing Webhooks

Trigger external actions based on user behavior:

Setup:

  1. Go to Woopra Settings → Integrations → Webhooks
  2. Add webhook URL
  3. Select trigger events
  4. Configure payload

Example Webhook Payload:

{
  "event": "purchase",
  "visitor": {
    "email": "user@example.com",
    "name": "John Doe",
    "plan": "enterprise"
  },
  "properties": {
    "amount": 99.99,
    "product": "Pro Plan",
    "timestamp": 1704067200
  }
}

Processing Webhooks:

// Node.js webhook handler
app.post('/woopra-webhook', express.json(), (req, res) => {
  const { event, visitor, properties } = req.body;

  console.log(`Received event: ${event}`);
  console.log(`User: ${visitor.email}`);
  console.log(`Properties:`, properties);

  // Process the event
  if (event === 'purchase') {
    // Update your database
    updateCustomerPurchase(visitor.email, properties);

    // Send notification
    sendSlackNotification(`New purchase: ${properties.product}`);
  }

  res.status(200).send('OK');
});

Custom Integrations

Build Your Own

Create custom integrations using Woopra's API:

# Example: Sync Woopra data to your database
import requests
from datetime import datetime

def sync_woopra_to_database():
    """Sync Woopra events to your database"""

    # Get events from Woopra API (requires API key)
    events = get_woopra_events()

    for event in events:
        # Transform data
        db_event = {
            'user_email': event['visitor']['email'],
            'event_name': event['event'],
            'event_time': datetime.fromtimestamp(event['timestamp']),
            'properties': event['properties']
        }

        # Save to database
        save_to_database(db_event)

Zapier Integration

Connect Woopra with 5,000+ apps via Zapier:

Example Zaps:

  • New Woopra event → Create Google Sheets row
  • User milestone → Send email via Gmail
  • Purchase event → Update Airtable
  • High engagement → Create Trello card

Integration Use Cases

Sales Workflows

Lead Scoring:

// Track engagement for lead scoring
woopra.track('whitepaper_download', {
  resource: 'Enterprise Guide',
  lead_score_points: 10
});

woopra.track('pricing_page_view', {
  time_on_page: 120,
  lead_score_points: 15
});

woopra.track('demo_requested', {
  company_size: '100-500',
  lead_score_points: 50
});

Trigger CRM Actions:

// High-value action triggers CRM workflow
woopra.track('enterprise_trial_started', {
  company: 'Acme Corp',
  seats: 100,
  trigger_sales_alert: true
});

Marketing Campaigns

Behavioral Segmentation:

// Segment users for targeted campaigns
woopra.identify({
  email: 'user@example.com',
  segment: 'power_user',
  feature_adoption: 0.85,
  last_active: Date.now()
});

Campaign Attribution:

// Track campaign performance
woopra.track('signup', {
  utm_source: 'google',
  utm_medium: 'cpc',
  utm_campaign: 'spring_2024',
  utm_content: 'variant_b'
});

Customer Success

Churn Prevention:

// Identify at-risk users
woopra.identify({
  email: 'user@example.com',
  days_since_login: 15,
  feature_usage: 'declining',
  churn_risk: 'high'
});

// Trigger intervention
woopra.track('churn_risk_detected', {
  send_email: true,
  assign_csm: true
});

Onboarding Tracking:

// Monitor onboarding progress
woopra.track('onboarding_step_completed', {
  step: 3,
  step_name: 'first_project_created',
  total_steps: 5,
  completion_percentage: 60
});

Data Export

CSV Export

Export Woopra data for analysis:

  1. Go to Reports → Export
  2. Select date range
  3. Choose metrics and dimensions
  4. Download CSV

API Data Export

# Export data via API
import requests

def export_woopra_data(api_key, project, start_date, end_date):
    """Export data from Woopra API"""

    url = f"https://www.woopra.com/rest/v2.6/reports/analytics"

    headers = {
        'Authorization': f'Bearer {api_key}'
    }

    params = {
        'project': project,
        'start_date': start_date,
        'end_date': end_date,
        'granularity': 'day'
    }

    response = requests.get(url, headers=headers, params=params)
    return response.json()

# Usage
data = export_woopra_data(
    api_key='your_api_key',
    project='example.com',
    start_date='2024-01-01',
    end_date='2024-01-31'
)

Best Practices

Integration Strategy

  1. Start with Core Tools: Integrate your CRM and email platform first
  2. Test Thoroughly: Verify data flows correctly before relying on integrations
  3. Monitor Data Quality: Regularly check that data is syncing properly
  4. Document Mappings: Keep track of how fields map between systems

Data Consistency

// Use consistent identifiers across all integrations
const userIdentifier = {
  id: 'user_12345',          // Your internal ID
  email: 'user@example.com'  // Email for matching
};

// Woopra
woopra.identify(userIdentifier);

// Segment
analytics.identify(userIdentifier.id, userIdentifier);

// HubSpot (via API)
updateHubSpotContact(userIdentifier.email, userData);

Error Handling

// Handle integration failures gracefully
function trackWithFallback(eventName, properties) {
  try {
    // Try Woopra
    woopra.track(eventName, properties);
  } catch (error) {
    console.error('Woopra tracking failed:', error);

    // Fallback to server-side tracking
    fetch('/api/track', {
      method: 'POST',
      body: JSON.stringify({ event: eventName, properties })
    });
  }
}

Troubleshooting Integrations

Data Not Syncing

  1. Check credentials: Verify API keys and authentication
  2. Test connection: Use integration health checks
  3. Verify permissions: Ensure proper access rights
  4. Check field mappings: Confirm fields are mapped correctly

Duplicate Data

// Prevent duplicate events in integrations
const trackedEvents = new Set();

function trackOnce(eventName, properties) {
  const eventKey = `${eventName}_${JSON.stringify(properties)}`;

  if (!trackedEvents.has(eventKey)) {
    woopra.track(eventName, properties);
    trackedEvents.add(eventKey);
  }
}

Rate Limiting

// Handle API rate limits
async function trackWithRateLimit(eventName, properties) {
  const maxRetries = 3;
  let retries = 0;

  while (retries < maxRetries) {
    try {
      await woopraApiCall(eventName, properties);
      break;
    } catch (error) {
      if (error.status === 429) {  // Rate limited
        retries++;
        await new Promise(resolve => setTimeout(resolve, 1000 * retries));
      } else {
        throw error;
      }
    }
  }
}
Nach oben