Plausible Integrations

Integration Inventory

Native Integrations

Plausible emphasizes simplicity and privacy-first analytics with select native integrations:

Content Management Systems

• WordPress - Official plugin for easy implementation
• Ghost - Built-in integration support
• Hugo - Static site generator integration
• Jekyll - Static site compatibility
• Next.js - React framework integration
• Gatsby - JAMstack platform support

Communication & Alerts

• Slack - Real-time traffic spike notifications
• Email Reports - Automated weekly/monthly reports
• Webhooks - Custom integration endpoints
• Telegram - Instant messaging alerts

Website Platforms

• Webflow - Visual website builder integration
• Carrd - Simple site builder compatibility
• Wix - App marketplace integration
• Squarespace - Code injection method

API Access

Stats API

• RESTful API for data extraction
• Site-wide metrics and breakdowns
• Real-time visitor data
• Custom date range queries
• Goal conversion tracking
• Page-level analytics

Events API

• Server-side event tracking
• Custom event properties
• Goal completion tracking
• Revenue attribution

Licensing & Access

Plausible Plan Tiers

Implementation Playbooks

WordPress Integration

Install and configure Plausible for WordPress sites:

Plugin Installation

1. Log in to WordPress admin dashboard
2. Navigate to Plugins > Add New
3. Search for "Plausible Analytics"
4. Install and activate the official plugin
5. Go to Settings > Plausible Analytics
6. Enter your Plausible domain
7. Configure tracking options

Manual Tracking Code

<!-- Add to theme header.php or via plugin -->
<script defer data-domain="yourdomain.com" src="https://plausible.io/js/script.js"></script>

<!-- Track custom events -->
<script>
window.plausible = window.plausible || function() {
  (window.plausible.q = window.plausible.q || []).push(arguments)
};

// Track custom goal
function trackSignup() {
  plausible('Signup');
}

// Track with properties
function trackPurchase(amount) {
  plausible('Purchase', {
    props: {
      amount: amount,
      currency: 'USD'
    }
  });
}
</script>

Goal Tracking Configuration

// E-commerce conversion tracking
document.getElementById('checkout-button').addEventListener('click', function() {
  plausible('Purchase', {
    props: {
      product: 'Premium Plan',
      price: 99,
      method: 'Credit Card'
    }
  });
});

// Newsletter signup
document.getElementById('newsletter-form').addEventListener('submit', function(e) {
  plausible('Newsletter Signup');
});

// Download tracking
document.querySelectorAll('a[download]').forEach(function(link) {
  link.addEventListener('click', function() {
    plausible('File Download', {
      props: {
        file: this.getAttribute('href')
      }
    });
  });
});

API Data Export

Extract analytics data programmatically:

Stats API Examples

# Python script to fetch Plausible stats
import requests
from datetime import datetime, timedelta

class PlausibleAPI:
    def __init__(self, site_id, api_key):
        self.site_id = site_id
        self.api_key = api_key
        self.base_url = 'https://plausible.io/api/v1/stats'
        self.headers = {
            'Authorization': f'Bearer {api_key}'
        }

    def get_aggregate(self, period='30d', metrics='visitors,pageviews,bounce_rate,visit_duration'):
        """Fetch aggregate statistics"""
        url = f'{self.base_url}/aggregate'
        params = {
            'site_id': self.site_id,
            'period': period,
            'metrics': metrics
        }
        response = requests.get(url, headers=self.headers, params=params)
        return response.json()

    def get_timeseries(self, period='30d', metrics='visitors,pageviews'):
        """Fetch time series data"""
        url = f'{self.base_url}/timeseries'
        params = {
            'site_id': self.site_id,
            'period': period,
            'metrics': metrics
        }
        response = requests.get(url, headers=self.headers, params=params)
        return response.json()

    def get_breakdown(self, property, period='30d', metrics='visitors', limit=100):
        """Fetch breakdown by property (source, page, country, etc.)"""
        url = f'{self.base_url}/breakdown'
        params = {
            'site_id': self.site_id,
            'period': period,
            'property': property,
            'metrics': metrics,
            'limit': limit
        }
        response = requests.get(url, headers=self.headers, params=params)
        return response.json()

# Usage
plausible = PlausibleAPI('yourdomain.com', 'your_api_key_here')

# Get overall stats
stats = plausible.get_aggregate(period='7d')
print(f"Visitors: {stats['results']['visitors']['value']}")
print(f"Pageviews: {stats['results']['pageviews']['value']}")
print(f"Bounce Rate: {stats['results']['bounce_rate']['value']}%")

# Get top pages
top_pages = plausible.get_breakdown(property='event:page', period='30d', limit=10)
for page in top_pages['results']:
    print(f"{page['page']}: {page['visitors']} visitors")

# Get traffic sources
sources = plausible.get_breakdown(property='visit:source', period='30d')
for source in sources['results']:
    print(f"{source['source']}: {source['visitors']} visitors")

Server-Side Event Tracking

// Node.js server-side event tracking
const axios = require('axios');

async function trackPlausibleEvent(domain, eventName, url, props = {}) {
  const payload = {
    name: eventName,
    url: url,
    domain: domain,
    props: props
  };

  try {
    await axios.post('https://plausible.io/api/event', payload, {
      headers: {
        'User-Agent': 'Mozilla/5.0 (compatible; Server-Side-Tracking/1.0)',
        'Content-Type': 'application/json'
      }
    });
    console.log(`Event tracked: ${eventName}`);
  } catch (error) {
    console.error('Plausible tracking error:', error.message);
  }
}

// Track server-side events
trackPlausibleEvent(
  'yourdomain.com',
  'API Request',
  'https://yourdomain.com/api/process',
  {
    endpoint: '/api/process',
    method: 'POST',
    status: 200
  }
);

trackPlausibleEvent(
  'yourdomain.com',
  'Email Sent',
  'https://yourdomain.com/emails/confirmation',
  {
    type: 'Order Confirmation',
    recipient_count: 1
  }
);

Slack Integration

Configure real-time traffic alerts:

Setup Steps

1. In Plausible dashboard, go to Site Settings
2. Navigate to Integrations section
3. Click "Add Slack Integration"
4. Authorize Plausible to access your Slack workspace
5. Select channel for notifications
6. Configure spike threshold (e.g., notify when current visitors > 10)
7. Save configuration

Custom Slack Webhooks

# Python script for custom Plausible + Slack integration
import requests
import schedule
import time

def check_traffic_and_alert():
    # Fetch current visitors from Plausible
    plausible_url = 'https://plausible.io/api/v1/stats/realtime/visitors'
    headers = {'Authorization': 'Bearer YOUR_API_KEY'}
    params = {'site_id': 'yourdomain.com'}

    response = requests.get(plausible_url, headers=headers, params=params)
    current_visitors = response.json()

    # Alert if spike detected
    if current_visitors > 50:
        send_slack_alert(f"Traffic spike alert! Currently {current_visitors} visitors online.")

    # Check goal completions
    goals_response = requests.get(
        'https://plausible.io/api/v1/stats/aggregate',
        headers=headers,
        params={
            'site_id': 'yourdomain.com',
            'period': 'day',
            'metrics': 'events',
            'filters': 'event:goal==Purchase'
        }
    )

    purchase_count = goals_response.json()['results']['events']['value']
    if purchase_count > 10:
        send_slack_alert(f"Sales milestone! {purchase_count} purchases today.")

def send_slack_alert(message):
    webhook_url = 'https://hooks.slack.com/services/YOUR/WEBHOOK/URL'
    payload = {
        'text': message,
        'channel': '#analytics',
        'username': 'Plausible Bot',
        'icon_emoji': ':chart_with_upwards_trend:'
    }
    requests.post(webhook_url, json=payload)

# Run checks every 5 minutes
schedule.every(5).minutes.do(check_traffic_and_alert)

while True:
    schedule.run_pending()
    time.sleep(60)

Data Activation

Goal Tracking & Conversion Optimization

Define and track conversion goals:

Custom Goal Configuration

// Track multiple conversion points
// Signup flow
plausible('Signup - Step 1 Completed');
plausible('Signup - Step 2 Completed');
plausible('Signup - Completed');

// Purchase funnel
plausible('Add to Cart');
plausible('Checkout Started');
plausible('Purchase', {
  props: {
    value: 149.99,
    items: 3,
    category: 'Electronics'
  }
});

// Content engagement
plausible('Video Played', {props: {title: 'Product Demo'}});
plausible('Video Completed', {props: {title: 'Product Demo'}});

// Lead generation
plausible('Lead Form Submitted', {
  props: {
    source: 'Landing Page',
    campaign: 'Summer 2025'
  }
});

Revenue Attribution

Track monetary value with custom events:

// E-commerce revenue tracking
function trackRevenue(orderId, amount, items) {
  plausible('Purchase', {
    props: {
      order_id: orderId,
      revenue: amount,
      currency: 'USD',
      items: items,
      payment_method: 'Credit Card'
    }
  });
}

// Usage
trackRevenue('ORD-12345', 299.99, 2);

// Subscription revenue
plausible('Subscription Started', {
  props: {
    plan: 'Pro',
    billing: 'annual',
    mrr: 99
  }
});

// Upsell tracking
plausible('Upgrade Completed', {
  props: {
    from_plan: 'Basic',
    to_plan: 'Pro',
    additional_revenue: 50
  }
});

UTM Campaign Tracking

Plausible automatically captures UTM parameters:

<!-- Campaign links automatically tracked -->
<a href="https://yourdomain.com?utm_source=newsletter&utm_medium=email&utm_campaign=launch">
  View Product Launch
</a>

<!-- Plausible tracks these in Source > UTM Source/Medium/Campaign reports -->

Data Sync Schedules

API Access Patterns

Team Responsibilities

• Marketing Team - Campaign tracking, goal definition, UTM management
• Product Team - Event tracking, conversion funnels, user flows
• Engineering Team - API integrations, server-side tracking, data exports
• Analytics Team - Report analysis, data visualization, insights

Compliance & Security

Privacy-First Architecture

Plausible's core privacy features:

GDPR & CCPA Compliance

• No cookies or persistent identifiers
• No cross-site or cross-device tracking
• No personal data collection
• EU-owned and hosted infrastructure (optional)
• Full data ownership

Data Processing

// Plausible automatically anonymizes all data
// No consent banner required in most cases

// Optional: Add consent management anyway
if (userConsent.analytics) {
  // Load Plausible script dynamically
  const script = document.createElement('script');
  script.defer = true;
  script.dataset.domain = 'yourdomain.com';
  script.src = 'https://plausible.io/js/script.js';
  document.head.appendChild(script);
}

Data Retention

• Paid plans: Forever (until account deleted)
• Free trial: 30 days
• User can delete all data at any time
• No data sold or shared with third parties

API Security

Token Management

# Store API tokens securely
export PLAUSIBLE_API_KEY="your_api_key_here"

# Use environment-specific tokens
# Development
export PLAUSIBLE_API_KEY_DEV="dev_key"

# Production
export PLAUSIBLE_API_KEY_PROD="prod_key"

# Rotate keys quarterly via Plausible settings

Access Control

Plausible offers role-based access:

• Owner - Full access, billing, settings
• Admin - View stats, manage goals, configure integrations
• Viewer - Read-only access to statistics

Advanced Integration Opportunities

Stats API: Use the Plausible Stats API to build custom dashboards, embed analytics in admin panels, or feed data into operational tools. The API provides real-time and historical data with filtering by any dimension.

Goal-Based Automation: Combine Plausible goals with webhook services (Zapier, Make, n8n) to trigger actions when conversion goals are hit — send Slack alerts on lead submissions, update CRM records on purchases, or trigger email sequences.

Shared Dashboards: Create public shared links for clients or stakeholders who don't need Plausible accounts. Configure in Site Settings → Visibility → Shared Links. Password-protect shared links for sensitive data.