Matomo Integrations

Integration Inventory

Native Integrations & Plugins

Matomo offers extensive plugin ecosystem for connecting with various platforms:

Content Management Systems

• WordPress - Official plugin for seamless integration
• Drupal - Module for Drupal 8, 9, and 10
• Joomla - Extension for tracking and analytics
• TYPO3 - Native extension support
• Magento - E-commerce tracking integration
• Shopify - App store integration available

Marketing & Advertising

• Google Ads - Campaign tracking and ROI measurement
• Facebook Ads - Conversion tracking integration
• Microsoft Advertising - Bing Ads integration
• Email Marketing - Newsletter tracking plugins
• Marketing Automation - Campaign attribution

E-commerce Platforms

• WooCommerce - Enhanced e-commerce tracking
• PrestaShop - Shopping cart analytics
• OpenCart - Sales and conversion tracking
• Shopware - Product performance analytics

CRM & Business Tools

• Salesforce - Customer journey tracking (via custom integration)
• HubSpot - Marketing attribution (third-party)
• Zendesk - Support ticket correlation
• Slack - Real-time notification plugin

Data Export & Warehousing

Direct Database Access

• MySQL/MariaDB - Native database format
• PostgreSQL - Via migration tools
• Direct SQL queries for custom reporting

API-Based Export

• Reporting API - HTTP API for data extraction
• Tracking API - Server-side event submission
• Analytics API - Programmatic access to reports

Data Warehouse Connectors

• BigQuery - Via custom ETL pipelines
• Snowflake - Third-party integration tools
• Amazon Redshift - ETL connector solutions
• Azure Synapse - Custom data pipelines

Business Intelligence Tools

Native Connectors

• Tableau - Matomo connector plugin
• Power BI - Custom connector available
• Looker - API-based integration
• Metabase - Direct database connection

Data Visualization

• Grafana - Matomo data source plugin
• Google Data Studio - Custom connector
• Kibana - Log analysis integration

Tag Management

Matomo Tag Manager (Built-in)

• Client-side and server-side tagging
• Custom trigger configuration
• Third-party tag support
• Privacy-compliant tag deployment

Third-Party Tag Managers

• Google Tag Manager - Matomo tracking template
• Adobe Launch - Custom extension
• Tealium - Tag configuration support

Licensing & Feature Availability

Matomo Cloud vs. On-Premise

Plan Tiers (Cloud)

• Starter - Basic integrations, limited API calls
• Business - All standard plugins, higher API limits
• Enterprise - Custom plugins, dedicated support, SLA

Implementation Playbooks

WordPress Integration Setup

Install and configure Matomo for WordPress sites:

Installation via Plugin

1. In WordPress admin, navigate to Plugins > Add New
2. Search for "Matomo Analytics"
3. Install and activate the official Matomo plugin
4. Choose integration method:
   • Cloud - Connect to existing Matomo Cloud account
   • On-Premise - Self-hosted Matomo installation
   • WP Embedded - Run Matomo directly in WordPress

Embedded Matomo Configuration

// wp-config.php customization for embedded Matomo
define('MATOMO_ANALYTICS_FILE', WP_CONTENT_DIR . '/uploads/matomo/config/config.ini.php');

// Exclude admin users from tracking
add_filter('matomo_tracking_code_script', function($script) {
    if (current_user_can('administrator')) {
        return '';
    }
    return $script;
});

// Custom tracking configuration
add_filter('matomo_tracking_code', function($code) {
    // Enable download tracking
    $code .= "_paq.push(['enableLinkTracking']);\n";
    // Set custom dimensions
    $code .= "_paq.push(['setCustomDimension', 1, '" . get_post_type() . "']);\n";
    $code .= "_paq.push(['setCustomDimension', 2, '" . (is_user_logged_in() ? 'logged-in' : 'guest') . "']);\n";
    return $code;
});

E-commerce Tracking (WooCommerce)

// Track WooCommerce purchase events
add_action('woocommerce_thankyou', 'matomo_track_order', 10, 1);

function matomo_track_order($order_id) {
    if (!$order_id) return;

    $order = wc_get_order($order_id);
    $items = $order->get_items();

    ?>
    <script>
    var _paq = window._paq = window._paq || [];

    <?php foreach ($items as $item):
        $product = $item->get_product();
    ?>
    _paq.push(['addEcommerceItem',
        '<?php echo $product->get_sku(); ?>',
        '<?php echo $product->get_name(); ?>',
        <?php echo json_encode($product->get_category_ids()); ?>,
        <?php echo $item->get_total(); ?>,
        <?php echo $item->get_quantity(); ?>
    ]);
    <?php endforeach; ?>

    _paq.push(['trackEcommerceOrder',
        '<?php echo $order->get_order_number(); ?>',
        <?php echo $order->get_total(); ?>,
        <?php echo $order->get_subtotal(); ?>,
        <?php echo $order->get_total_tax(); ?>,
        <?php echo $order->get_shipping_total(); ?>,
        <?php echo $order->get_total_discount(); ?>
    ]);
    </script>
    <?php
}

API Data Export Configuration

Extract Matomo data programmatically for custom integrations:

Reporting API Examples

# Python script to fetch Matomo analytics data
import requests
import pandas as pd
from datetime import datetime, timedelta

class MatomoAPI:
    def __init__(self, url, site_id, token_auth):
        self.url = url
        self.site_id = site_id
        self.token_auth = token_auth
        self.base_params = {
            'module': 'API',
            'idSite': site_id,
            'token_auth': token_auth,
            'format': 'JSON'
        }

    def get_visits_summary(self, start_date, end_date):
        """Fetch visit summary metrics"""
        params = {
            **self.base_params,
            'method': 'VisitsSummary.get',
            'period': 'day',
            'date': f'{start_date},{end_date}'
        }
        response = requests.get(self.url, params=params)
        return response.json()

    def get_page_urls(self, date, limit=100):
        """Fetch top page URLs"""
        params = {
            **self.base_params,
            'method': 'Actions.getPageUrls',
            'period': 'day',
            'date': date,
            'filter_limit': limit,
            'expanded': 1
        }
        response = requests.get(self.url, params=params)
        return response.json()

    def get_referrers(self, date):
        """Fetch traffic source breakdown"""
        params = {
            **self.base_params,
            'method': 'Referrers.getReferrerType',
            'period': 'day',
            'date': date
        }
        response = requests.get(self.url, params=params)
        return response.json()

    def get_ecommerce_conversions(self, start_date, end_date):
        """Fetch e-commerce conversion data"""
        params = {
            **self.base_params,
            'method': 'Goals.get',
            'period': 'day',
            'date': f'{start_date},{end_date}',
            'idGoal': 'ecommerceOrder'
        }
        response = requests.get(self.url, params=params)
        return response.json()

# Usage example
matomo = MatomoAPI(
    url='https://your-matomo.com/',
    site_id='1',
    token_auth='your_token_here'
)

# Fetch last 30 days of data
end_date = datetime.now().strftime('%Y-%m-%d')
start_date = (datetime.now() - timedelta(days=30)).strftime('%Y-%m-%d')

visits = matomo.get_visits_summary(start_date, end_date)
print(f"Total visits: {sum([day.get('nb_visits', 0) for day in visits.values()])}")

# Convert to pandas DataFrame for analysis
df = pd.DataFrame.from_dict(visits, orient='index')
df.to_csv('matomo_visits.csv')

Server-Side Event Tracking

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

class MatomoTracker {
    constructor(siteId, trackerUrl, tokenAuth) {
        this.siteId = siteId;
        this.trackerUrl = trackerUrl;
        this.tokenAuth = tokenAuth;
    }

    async track(params) {
        const baseParams = {
            idsite: this.siteId,
            rec: 1,
            token_auth: this.tokenAuth,
            apiv: 1
        };

        const trackingParams = { ...baseParams, ...params };

        try {
            await axios.get(this.trackerUrl, { params: trackingParams });
            return true;
        } catch (error) {
            console.error('Matomo tracking error:', error);
            return false;
        }
    }

    async trackPageView(userId, url, title, referrer = '') {
        return this.track({
            uid: userId,
            url: url,
            action_name: title,
            urlref: referrer,
            rand: Math.random().toString(36).substring(7)
        });
    }

    async trackEvent(userId, category, action, name = '', value = null) {
        const params = {
            uid: userId,
            e_c: category,
            e_a: action,
            rand: Math.random().toString(36).substring(7)
        };

        if (name) params.e_n = name;
        if (value !== null) params.e_v = value;

        return this.track(params);
    }

    async trackEcommerceOrder(userId, orderId, revenue, subTotal, tax, shipping, discount) {
        return this.track({
            uid: userId,
            idgoal: 0,
            revenue: revenue,
            ec_id: orderId,
            ec_st: subTotal,
            ec_tx: tax,
            ec_sh: shipping,
            ec_dt: discount,
            rand: Math.random().toString(36).substring(7)
        });
    }
}

// Usage
const tracker = new MatomoTracker(1, 'https://your-matomo.com/matomo.php', 'your_token');

// Track server-side page view
await tracker.trackPageView(
    'user123',
    'https://example.com/product/123',
    'Product Page - Widget Pro'
);

// Track custom event
await tracker.trackEvent('user123', 'Video', 'Play', 'Product Demo', 45);

BigQuery Integration via ETL

Export Matomo data to BigQuery for advanced analysis:

Database Export Script

# Export Matomo MySQL data to BigQuery
from google.cloud import bigquery
import mysql.connector
from datetime import datetime

def export_matomo_to_bigquery():
    # Connect to Matomo database
    matomo_db = mysql.connector.connect(
        host='localhost',
        user='matomo',
        password='password',
        database='matomo'
    )

    # Initialize BigQuery client
    bq_client = bigquery.Client()
    table_id = 'project.dataset.matomo_visits'

    # Query Matomo visit log
    query = """
    SELECT
        idvisit,
        idsite,
        visitor_localtime,
        location_country,
        location_city,
        referer_type,
        referer_name,
        referer_url,
        config_os,
        config_browser_name,
        visit_total_actions,
        visit_total_time,
        visit_goal_converted,
        visit_total_events
    FROM matomo_log_visit
    WHERE visit_last_action_time >= DATE_SUB(NOW(), INTERVAL 1 DAY)
    """

    cursor = matomo_db.cursor(dictionary=True)
    cursor.execute(query)

    # Prepare rows for BigQuery
    rows_to_insert = []
    for row in cursor:
        rows_to_insert.append(row)

    # Insert into BigQuery
    errors = bq_client.insert_rows_json(table_id, rows_to_insert)

    if errors:
        print(f'Errors occurred: {errors}')
    else:
        print(f'Inserted {len(rows_to_insert)} rows into BigQuery')

    cursor.close()
    matomo_db.close()

# Run export
export_matomo_to_bigquery()

Data Activation

Audience Segmentation

Create advanced segments using Matomo data:

Custom Segments via API

// Create custom segment for high-value users
$segmentDefinition = array(
    'name' => 'High Value Customers',
    'definition' => 'visitEcommerceStatus==ordered;revenueOrder>100',
    'enable_all_users' => true,
    'auto_archive' => true
);

// Apply segment to reports
$segment = 'visitEcommerceStatus==ordered;revenueOrder>100;visitCount>=5';

// Fetch segment data
$params = array(
    'module' => 'API',
    'method' => 'Live.getLastVisitsDetails',
    'idSite' => 1,
    'period' => 'month',
    'date' => 'today',
    'segment' => $segment,
    'format' => 'JSON',
    'token_auth' => 'your_token'
);

Behavioral Targeting

Marketing Attribution

Campaign Tracking

<!-- UTM parameter tracking -->
<a href="https://example.com?utm_source=newsletter&utm_medium=email&utm_campaign=summer_sale">
    Shop Summer Sale
</a>

<!-- Matomo automatically tracks these parameters -->
<script>
// Access campaign parameters in JavaScript
var _paq = window._paq = window._paq || [];
_paq.push(['setCampaignNameKey', 'utm_campaign']);
_paq.push(['setCampaignKeywordKey', 'utm_term']);
</script>

Multi-Touch Attribution Analysis

-- SQL query for attribution modeling (direct database access)
SELECT
    referrer_name,
    COUNT(DISTINCT idvisitor) as unique_visitors,
    SUM(visit_total_actions) as total_actions,
    SUM(CASE WHEN visit_goal_converted > 0 THEN 1 ELSE 0 END) as conversions,
    SUM(revenue) as total_revenue,
    SUM(revenue) / COUNT(DISTINCT idvisitor) as revenue_per_visitor
FROM matomo_log_visit
WHERE visit_first_action_time >= DATE_SUB(NOW(), INTERVAL 30 DAY)
GROUP BY referrer_name
ORDER BY total_revenue DESC;

Real-Time Alerts & Notifications

Slack Integration

# Python script to send Matomo alerts to Slack
import requests
import schedule
import time

def check_matomo_traffic():
    # Fetch real-time visitors
    matomo_url = 'https://your-matomo.com/'
    params = {
        'module': 'API',
        'method': 'Live.getCounters',
        'idSite': '1',
        'lastMinutes': '30',
        'format': 'JSON',
        'token_auth': 'your_token'
    }

    response = requests.get(matomo_url, params=params)
    data = response.json()

    visitors = data[0].get('visitors', 0)

    # Alert if traffic spike detected
    if visitors > 100:  # Threshold
        send_slack_alert(f"⚠️ Traffic spike detected: {visitors} visitors in last 30 minutes!")

def send_slack_alert(message):
    webhook_url = 'https://hooks.slack.com/services/YOUR/WEBHOOK/URL'
    payload = {'text': message}
    requests.post(webhook_url, json=payload)

# Schedule checks every 5 minutes
schedule.every(5).minutes.do(check_matomo_traffic)

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

Data Sync Schedules

Integration Refresh Cadences

Team Ownership

• Marketing Team - Campaign tracking, UTM management, conversion goals
• Analytics Team - Report creation, segment definitions, API integrations
• Engineering Team - Plugin customization, server-side tracking, database management
• DevOps Team - Matomo infrastructure, backup strategy, performance optimization

Compliance & Security

Privacy-First Analytics

GDPR Compliance Features

// Respect Do Not Track
var _paq = window._paq = window._paq || [];
_paq.push(['setDoNotTrack', true]);

// Anonymize IP addresses (automatic in Matomo)
_paq.push(['setIpAddress', '0.0.0.0']);  // Managed by Matomo automatically

// Respect user consent
if (getCookieConsent()) {
    _paq.push(['rememberConsentGiven']);
} else {
    _paq.push(['requireConsent']);
}

// Cookie-less tracking option
_paq.push(['disableCookies']);  // Use fingerprinting instead

Data Anonymization

Configure in Matomo Admin:

1. Privacy > Anonymize Data
2. Enable IP anonymization (mask 2-3 bytes)
3. Set data retention periods
4. Configure user ID anonymization
5. Enable automatic log deletion

User Rights Management

// Handle GDPR data deletion requests
function delete_matomo_user_data($visitor_id) {
    $matomo_url = 'https://your-matomo.com/';
    $params = array(
        'module' => 'API',
        'method' => 'PrivacyManager.deleteDataSubjects',
        'idSite' => 1,
        'visits' => $visitor_id,
        'format' => 'JSON',
        'token_auth' => 'your_admin_token'
    );

    $response = file_get_contents($matomo_url . '?' . http_build_query($params));
    return json_decode($response);
}

Access Control

Role-Based Permissions

• Super User - Full system access, plugin management
• Admin - Site configuration, user management for specific sites
• Write - Configure reports, goals, and segments
• View - Read-only access to reports

API Token Management

# Generate API token via CLI (Matomo on-premise)
./console user:create --login=api_user --password=secure_password --email=api@example.com

# Assign minimum required permissions
./console user:grant --login=api_user --access=view --idsite=1

# Rotate tokens regularly
./console user:token:generate api_user

Integration Security Best Practices

Credential Management

• Store API tokens in environment variables
• Use separate tokens for each integration
• Implement token rotation every 90 days
• Audit token usage via Matomo logs

Database Security

-- Create read-only database user for BI tools
CREATE USER 'matomo_readonly'@'localhost' IDENTIFIED BY 'secure_password';
GRANT SELECT ON matomo.* TO 'matomo_readonly'@'localhost';
FLUSH PRIVILEGES;

-- Restrict access to specific tables
GRANT SELECT ON matomo.matomo_log_visit TO 'matomo_readonly'@'localhost';
GRANT SELECT ON matomo.matomo_log_action TO 'matomo_readonly'@'localhost';

Backlog & Opportunities

Requested Integrations

High Priority

• Native Snowflake Connector - Direct data sync without ETL (Engineering: 4 weeks, High impact)
• Enhanced Salesforce Integration - Bidirectional lead data sync (Engineering: 5 weeks, High impact)
• Microsoft Teams Notifications - Real-time alerts and reports (Engineering: 2 weeks, Medium impact)

Medium Priority

• Zapier Integration - No-code workflow automation (Engineering: 3 weeks, Medium impact)
• Airtable Connector - Lightweight data sync (Engineering: 2 weeks, Low impact)
• Discord Webhooks - Community engagement tracking (Engineering: 1 week, Low impact)

Exploration Phase

• Customer Data Platforms - mParticle, Segment integration
• Marketing Automation - ActiveCampaign, Mailchimp deep integration
• Business Intelligence - Enhanced Tableau/Power BI connectors

Technical Improvements

Performance Optimization

• Implement Redis caching for API responses
• Optimize database queries for large datasets
• Build materialized views for common reports
• Add query result pagination

API Enhancements

• GraphQL API for flexible querying
• Webhooks for real-time event streaming
• Bulk data export endpoints
• Rate limit increase options

Feature Requests