Woopra Analytics: Customer Journey Tracking and API

Technical guide to Woopra SDK installation, woopra.track()/identify(), real-time journey tracking, Triggers automation, and the HTTP Tracking API.

How Woopra Works

Woopra is a customer journey analytics platform that tracks individual users across sessions, devices, and channels. Every interaction is stored as an event tied to a visitor profile, building a real-time timeline of each customer's behavior.

The data model has three core entities:

Visitors (People) -- Identified by email or a custom unique ID. Woopra maintains a unified profile per visitor containing all properties and the complete event history. Anonymous visitors are tracked by cookie and merged when identified.
Events (Actions) -- Timestamped interactions with a name and key-value properties. Examples: pageview, signup, purchase, support_ticket_created. Events can originate from the browser SDK, server-side API, or third-party integrations.
Segments -- Dynamic groups of visitors defined by property or behavioral criteria. Segments update automatically as visitor data changes.

Woopra processes events in real time (under 10 seconds latency). The platform provides funnel analysis, retention cohorts, and journey mapping on top of the event stream.

AppConnect integrations allow Woopra to ingest events from external tools (Salesforce, Stripe, Zendesk, Mailchimp, etc.), merging them into the visitor timeline alongside browser-tracked events. This creates a cross-channel view where a single profile shows marketing emails opened, support tickets filed, payments processed, and product features used.

Triggers are Woopra's automation engine. Define conditions (visitor matches a segment, performs an event, or reaches a threshold) and Woopra executes actions: send an email, fire a webhook, post to Slack, or update a CRM record.

Installing the Tracking Script

JavaScript SDK (Browser)

Add the Woopra snippet to your site's <head>:

<script>
  (function(){
    var t,i,e,n=window,o=document,a=arguments,s="script",
    r=["config","track","identify","visit","push","call","trackForm","trackClick"],
    c=function(){var t,i=this;for(i._e=[],t=0;r.length>t;t++)
    (function(t){i[t]=function(){return i._e.push([t].concat(Array.prototype.slice.call(arguments,0))),i}})(r[t])};
    for(n._w=n._w||{},t=0;a.length>t;t++)n._w[a[t]]=n[a[t]]=n[a[t]]||new c;
    i=o.createElement(s),i.async=1,i.src="//static.woopra.com/js/w.js",
    e=o.getElementsByTagName(s)[0],e.parentNode.insertBefore(i,e)
  })("woopra");

  woopra.config({
    domain: 'example.com',
    outgoing_tracking: true,     // Track outbound link clicks
    download_tracking: true,     // Track file downloads
    click_tracking: true,        // Track all click events
    idle_timeout: 300000,        // Session timeout: 5 minutes (ms)
    cookie_domain: '.example.com', // Cross-subdomain tracking
    cookie_expire: 730           // Cookie expiration: 2 years (days)
  });

  woopra.track();  // Track the initial pageview
</script>

Configuration Options

woopra.config({
  domain: 'example.com',         // Required: your domain
  outgoing_tracking: true,       // Track outbound links
  download_tracking: true,       // Track file downloads (.pdf, .zip, etc.)
  download_extensions: 'pdf,zip,dmg,exe,doc,xls', // Extensions to track
  click_tracking: false,         // Track all clicks (generates high volume)
  idle_timeout: 300000,          // Session timeout in ms (default: 300000 = 5 min)
  ping: true,                    // Send periodic pings to update visit duration
  ping_interval: 12000,          // Ping interval in ms (default: 12000)
  cookie_name: 'wooTracker',     // Cookie name
  cookie_domain: '.example.com', // Cookie domain
  cookie_path: '/',              // Cookie path
  cookie_expire: 730,            // Cookie lifetime in days
  hide_campaign: false,          // Strip UTM params from URL after capture
  third_party_cookie: false,     // Enable third-party cookie for cross-domain
  ignore_query_url: false        // Ignore query strings when tracking URLs
});

Node.js (Server-Side SDK)

npm install woopra

const Woopra = require('woopra');

const woopra = new Woopra('example.com', {
  ssl: true
});

// Track a server-side event
woopra.track('user-email@example.com', 'subscription_renewed', {
  plan: 'pro',
  mrr: 99.00,
  renewal_type: 'auto'
});

// Identify/update visitor properties
woopra.identify('user-email@example.com', {
  name: 'Jane Doe',
  company: 'Acme Corp',
  plan: 'pro',
  lifetime_value: 2400
});

Event Tracking and Data Collection

Tracking Events

// Track a custom event with properties
woopra.track('purchase_completed', {
  product: 'Widget Pro',
  price: 149.99,
  currency: 'USD',
  quantity: 1,
  category: 'electronics'
});

// Track a signup
woopra.track('signed_up', {
  plan: 'free',
  source: 'organic',
  referral_code: 'FRIEND50'
});

// Track feature usage
woopra.track('feature_used', {
  feature_name: 'export_csv',
  module: 'reports',
  duration_seconds: 12
});

Automatic Tracking

With the default configuration, Woopra automatically captures:

Event	Trigger
`pv` (pageview)	Each `woopra.track()` call without arguments, or on page load
`outgoing`	Click on external link (when `outgoing_tracking: true`)
`download`	Click on file link matching configured extensions
`click`	Any click event (when `click_tracking: true`)

Form Tracking

Track form submissions automatically:

// Track when a form is submitted
woopra.trackForm('signup-form', {
  eventName: 'form_submitted',
  eventData: {
    form_name: 'newsletter_signup',
    page: window.location.pathname
  }
});

// First argument: form element ID or CSS selector
woopra.trackForm('#contact-form', {
  eventName: 'contact_request'
});

Click Tracking

Track clicks on specific elements:

// Track clicks on a specific button
woopra.trackClick('#cta-button', {
  eventName: 'cta_clicked',
  eventData: {
    button_text: 'Start Free Trial',
    page: window.location.pathname
  }
});

// Track clicks on a class of elements
woopra.trackClick('.pricing-plan', {
  eventName: 'pricing_plan_clicked'
});

Identity and User Tracking

Identifying Visitors

Associate the current visitor with known properties:

// Identify after login
woopra.identify({
  email: 'jane@example.com',
  name: 'Jane Doe',
  company: 'Acme Corp',
  plan: 'enterprise',
  signup_date: '2025-03-15',
  role: 'admin'
});

// Must call track() after identify() to send the data
woopra.track();

The email property is the primary identifier for merging visitor profiles. When identify() is called with an email, Woopra merges the current anonymous visitor with any existing profile matching that email.

Custom Visitor Properties

Set arbitrary properties on the visitor profile:

woopra.identify({
  email: 'user@example.com',
  custom_score: 85,
  last_feature_used: 'dashboard',
  account_type: 'premium',
  team_size: 12
});
woopra.track();

Properties persist on the visitor profile and can be used for segmentation, funnel filtering, and trigger conditions.

Visit Properties

Set properties on the current visit (session-scoped, not persistent):

woopra.visit({
  campaign: 'spring-sale',
  landing_page: '/promo',
  ab_test_variant: 'B'
});

Anonymous to Identified Transition

Before identify() is called, Woopra tracks the visitor using a cookie-based anonymous ID. When identify() provides an email, Woopra retroactively associates all prior anonymous events with the identified profile. This merge happens automatically server-side.

API and Data Export

HTTP Tracking API

Send events directly to Woopra's servers without the JavaScript SDK:

# Track an event via HTTP GET
curl "https://www.woopra.com/track/ce/?host=example.com&cookie=visitor-cookie-id&event=purchase&ce_product=Widget&ce_price=49.99&ce_currency=USD"

# Identify a visitor via HTTP GET
curl "https://www.woopra.com/track/identify/?host=example.com&cookie=visitor-cookie-id&cv_email=user@example.com&cv_name=Jane+Doe&cv_plan=pro"

Parameters:

host -- Your domain (must match Woopra project)
cookie -- Visitor identifier (the wooTracker cookie value, or any consistent ID)
event -- Event name (for /track/ce/)
ce_* -- Event properties (prefixed with ce_)
cv_* -- Visitor properties (prefixed with cv_)

Server-Side Event Tracking

For backend events (webhooks, cron jobs, API callbacks), use the HTTP API to track events that did not originate in the browser:

# Server-side: track a payment received event
curl -X GET "https://www.woopra.com/track/ce/?host=example.com&cookie=user-email@example.com&event=payment_received&ce_amount=299.00&ce_plan=enterprise&ce_payment_method=stripe"

Use the user's email as the cookie value when a browser cookie is not available. Woopra will match the event to the visitor profile by email.

Export API

Export visitor and event data programmatically:

# Export visitors matching a segment
curl -X POST "https://www.woopra.com/rest/2.4/export/people" \
  -H "Authorization: Basic BASE64_ENCODED_CREDENTIALS" \
  -H "Content-Type: application/json" \
  -d '{
    "website": "example.com",
    "segment": {
      "filters": [
        {"property": "plan", "operator": "equals", "value": "enterprise"}
      ]
    },
    "properties": ["email", "name", "company", "plan", "lifetime_value"],
    "limit": 1000
  }'

# Export events for a specific visitor
curl -X POST "https://www.woopra.com/rest/2.4/export/events" \
  -H "Authorization: Basic BASE64_ENCODED_CREDENTIALS" \
  -H "Content-Type: application/json" \
  -d '{
    "website": "example.com",
    "visitor": "user@example.com",
    "start_date": "2025-01-01",
    "end_date": "2025-03-01",
    "limit": 500
  }'

Labels and Funnels API

Query funnel completion data:

# Get funnel results
curl -X POST "https://www.woopra.com/rest/2.4/funnel" \
  -H "Authorization: Basic BASE64_ENCODED_CREDENTIALS" \
  -H "Content-Type: application/json" \
  -d '{
    "website": "example.com",
    "steps": [
      {"event": "signed_up"},
      {"event": "onboarding_completed"},
      {"event": "first_purchase"}
    ],
    "date_range": {
      "start": "2025-01-01",
      "end": "2025-03-01"
    }
  }'

Common Issues

Events Not Appearing in Dashboard

Verify the SDK loads by checking DevTools > Network for requests to www.woopra.com/track/. Common causes:

Domain mismatch: The domain in woopra.config() must match the domain configured in your Woopra project settings. A mismatch silently drops events.
Missing woopra.track() after identify(): Calling identify() alone does not send data. You must call woopra.track() after identify() to transmit the identification.
Ad blockers: Woopra's tracking endpoints are blocked by most ad blockers. The woopra.com/track/ URL is on common block lists.

Visitor Profiles Not Merging

Profile merging requires the email property in identify(). If you use a custom ID instead of an email, Woopra may create duplicate profiles for the same user across devices. Always include the email when identifying:

// Correct: include email for profile merging
woopra.identify({
  email: 'user@example.com',
  user_id: 'db-id-456'
});
woopra.track();

High Event Volume from Pings

Woopra sends ping events every 12 seconds by default to track time on page. On high-traffic sites, this can consume a significant portion of your action quota. Increase the interval or disable pings if time-on-page accuracy is not critical:

woopra.config({
  ping: false         // Disable pings entirely
  // or
  ping_interval: 60000  // Ping every 60 seconds instead of 12
});

Triggers Not Firing

Verify trigger conditions in the Woopra dashboard under Automation > Triggers. Common issues:

Segment conditions too narrow: The trigger condition may not match any visitors. Test with a broader condition first.
Integration authentication expired: Triggers that send to Slack, email, or CRM require valid OAuth tokens. Re-authenticate the integration if triggers stop firing.
Rate limiting: Triggers have execution rate limits to prevent spam. Check the trigger execution log for throttled events.

If your site uses multiple subdomains (app.example.com, www.example.com), set the cookie domain to share the visitor ID:

woopra.config({
  cookie_domain: '.example.com'
});

Without this, visitors get separate cookies per subdomain and appear as different users.

Platform-Specific Considerations

AppConnect Integrations

AppConnect brings data from external tools into Woopra visitor timelines. When you connect Stripe, for example, Woopra automatically creates events like stripe_payment_succeeded and stripe_subscription_created on the visitor profile that matches the Stripe customer email.

Supported integration categories:

CRM: Salesforce, HubSpot, Pipedrive
Payment: Stripe, PayPal, Recurly
Support: Zendesk, Freshdesk, Help Scout, Intercom
Marketing: Mailchimp, Marketo, ActiveCampaign, Klaviyo
Communication: Slack, Twilio, SendGrid

Configure integrations in Settings > Integrations. Each integration requires OAuth authentication with the external service.

Triggers (Automation)

Triggers execute actions when conditions are met:

IF visitor matches segment "Enterprise Trial Expiring in 3 Days"
AND visitor has NOT performed event "upgraded" in last 30 days
THEN send webhook to https://api.example.com/retention-alert
WITH payload: { email, company, plan, days_remaining }

Available trigger actions:

Send email (via connected email tool)
Fire webhook (HTTP POST with JSON payload)
Post to Slack channel
Update Salesforce/HubSpot record
Add to Mailchimp list

Triggers evaluate continuously as visitor data updates in real time.

Real-Time Customer Profiles

Each visitor profile in Woopra shows:

All properties (both set via SDK and imported from integrations)
Complete event timeline across all channels
Current session status (online/offline)
Segment memberships
Trigger execution history

Profiles are accessible in the dashboard under People or by searching for a specific email/visitor.

Retention Analysis

Woopra's retention reports track whether users return to perform a specified action after an initial event. Configure:

First event: The starting action (e.g., signed_up)
Return event: The action that indicates retention (e.g., logged_in)
Time window: Days/weeks/months to track
Segmentation: Break down retention by visitor properties

Action Quotas

Woopra pricing is based on tracked actions per month. Each event (including automatic pageviews and pings) counts as one action. Monitor usage in Settings > Usage. To reduce action consumption:

Disable click_tracking if not needed
Increase ping_interval or disable pings
Filter out bot traffic via server-side rules before it reaches Woopra

Nach oben