Chartbeat Integrations

Integration Inventory

Native Integrations

Chartbeat provides native integrations with various platforms to enhance real-time content analytics and audience engagement tracking:

Content Management Systems

• WordPress - Official plugin for automatic tracking implementation
• Drupal - Module for seamless integration with Drupal sites
• Ghost - Native support through custom code injection
• Medium - Partner integration for publication analytics

Publishing Platforms

• Parse.ly - Content analytics platform integration
• Brightcove - Video analytics and engagement tracking
• Ooyala - Video player performance monitoring
• JW Player - Video engagement metrics

Social Media & Distribution

• Facebook Instant Articles - Real-time article performance
• Apple News - Publication metrics and reader engagement
• Google AMP - Accelerated Mobile Pages tracking
• Flipboard - Magazine-style content distribution analytics

Data Warehouses & Business Intelligence

• Google BigQuery - Export real-time metrics for long-term analysis
• Amazon Redshift - Data warehouse integration for historical reporting
• Snowflake - Cloud data platform connectivity
• Tableau - Dashboard and visualization integration
• Looker - Business intelligence platform connectivity

API Access

Chartbeat provides comprehensive API access for custom integrations and data extraction:

Real-time API - Access to live metrics and concurrent visitor data Historical API - Query past performance data and trends Snapshots API - Periodic data snapshots for analysis Publishing API - Content metadata and publication information

Licensing Requirements

Integration availability varies by Chartbeat plan tier:

• Basic - Core tracking, limited API access (500 calls/day)
• Professional - Full API access, native CMS integrations
• Enterprise - Unlimited API calls, custom integrations, dedicated support
• Publishing - Specialized newsroom tools, editorial dashboards

Implementation Playbooks

WordPress Integration Setup

The WordPress plugin simplifies Chartbeat implementation for WordPress-powered sites:

Installation Steps

1. Navigate to WordPress Admin > Plugins > Add New
2. Search for "Chartbeat" and install the official plugin
3. Activate the plugin and navigate to Settings > Chartbeat
4. Enter your Chartbeat Account ID and API Key
5. Configure optional settings (domain, sections, authors)
6. Save settings and verify tracking

Configuration Options

// Programmatic configuration in wp-config.php
define('CHARTBEAT_ACCOUNT_ID', '12345');
define('CHARTBEAT_API_KEY', 'your_api_key_here');

// Custom section mapping
add_filter('chartbeat_sections', function($sections, $post) {
    $categories = get_the_category($post->ID);
    return array_map(function($cat) {
        return $cat->slug;
    }, $categories);
}, 10, 2);

// Author attribution
add_filter('chartbeat_author', function($author, $post) {
    $author_name = get_the_author_meta('display_name', $post->post_author);
    return sanitize_title($author_name);
}, 10, 2);

Verification

1. Install Chartbeat browser extension
2. Navigate to a published post
3. Verify tracking beacon fires in Network tab
4. Check real-time dashboard for visitor activity
5. Validate section and author attribution

Google BigQuery Export

Export Chartbeat data to BigQuery for long-term analysis and custom reporting:

Setup Process

1. Create Google Cloud Platform project
2. Enable BigQuery API
3. Create service account with BigQuery Data Editor role
4. Download service account JSON key
5. In Chartbeat dashboard, navigate to Integrations > BigQuery
6. Upload service account key
7. Configure export schedule (hourly, daily)
8. Select metrics and dimensions to export

Schema Configuration

-- Example BigQuery table schema for Chartbeat exports
CREATE TABLE chartbeat_exports.page_metrics (
  timestamp TIMESTAMP,
  path STRING,
  title STRING,
  sections ARRAY<STRING>,
  authors ARRAY<STRING>,
  concurrent_visitors INT64,
  engaged_time INT64,
  recirculation_rate FLOAT64,
  social_referrals INT64,
  search_referrals INT64,
  direct_traffic INT64
)
PARTITION BY DATE(timestamp)
CLUSTER BY path, sections;

-- Query for top performing content by engaged time
SELECT
  path,
  title,
  SUM(engaged_time) as total_engaged_time,
  AVG(concurrent_visitors) as avg_concurrent,
  MAX(concurrent_visitors) as peak_concurrent
FROM chartbeat_exports.page_metrics
WHERE DATE(timestamp) >= DATE_SUB(CURRENT_DATE(), INTERVAL 7 DAY)
GROUP BY path, title
ORDER BY total_engaged_time DESC
LIMIT 20;

QA Validation

• Verify export job runs on schedule (check Chartbeat audit log)
• Compare row counts between Chartbeat dashboard and BigQuery
• Validate timestamp accuracy (account for timezone conversions)
• Test data freshness (check latest timestamp in BigQuery)
• Monitor BigQuery storage costs and set up budget alerts

Parse.ly Integration

Combine Chartbeat real-time data with Parse.ly content analytics:

Implementation

1. Both Chartbeat and Parse.ly tracking codes must be present
2. Use consistent content metadata (sections, authors, tags)
3. Implement unified taxonomy across both platforms
4. Coordinate tracking parameters for content classification

Data Synchronization

// Unified content tracking configuration
window.parsely = window.parsely || {};
window.parsely.data = {
  type: 'post',
  title: document.title,
  link: window.location.href,
  section: 'technology',
  authors: ['jane-smith'],
  tags: ['artificial-intelligence', 'machine-learning']
};

// Chartbeat configuration matching Parse.ly metadata
var _cbq = _cbq || [];
_cbq.push(['_acct', 'chartbeat-account-id']);
_cbq.push(['_sections', 'technology']);
_cbq.push(['_authors', 'jane-smith']);

Data Activation

Real-time Audience Insights

Chartbeat real-time metrics enable immediate content optimization and editorial decision-making:

Homepage Optimization

• Monitor concurrent visitors on homepage vs. article pages
• Identify trending content to feature prominently
• Track click-through rates from homepage modules
• Optimize content placement based on engagement patterns

Breaking News Response

• Alert editorial team when traffic spikes occur
• Identify content driving unexpected engagement
• Coordinate social media promotion for trending articles
• Adjust homepage layout to capitalize on viral content

Recirculation Strategy

• Track internal referral patterns
• Identify high-performing related content links
• Optimize recommendation engine based on engagement data
• Measure impact of different content discovery features

Editorial Dashboard Integration

Custom dashboards combine Chartbeat data with editorial workflows:

Slack Integration

// Webhook notification when article reaches engagement threshold
const sendSlackNotification = async (articleData) => {
  const webhook_url = 'https://hooks.slack.com/services/YOUR/WEBHOOK/URL';

  const message = {
    text: `:fire: Article trending now!`,
    attachments: [{
      color: '#36a64f',
      title: articleData.title,
      title_link: articleData.url,
      fields: [
        {
          title: 'Concurrent Visitors',
          value: articleData.concurrent,
          short: true
        },
        {
          title: 'Engaged Time (avg)',
          value: `${articleData.engaged_time}s`,
          short: true
        },
        {
          title: 'Top Referrer',
          value: articleData.top_referrer,
          short: true
        }
      ]
    }]
  };

  await fetch(webhook_url, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(message)
  });
};

Refresh Cadences & Ownership

Data Synchronization Schedule

• Real-time API: Updates every 15 seconds
• Historical API: Available with 5-minute delay
• BigQuery exports: Configurable (hourly, daily, weekly)
• Dashboard updates: Real-time via WebSocket connection

Team Responsibilities

• Editorial Team - Monitor real-time dashboard, optimize content placement
• Analytics Team - Configure exports, build custom reports, train users
• Engineering Team - Maintain API integrations, troubleshoot tracking issues
• Product Team - Define KPIs, dashboard requirements, integration priorities

Common Integration Failure Modes

Missing Data in Exports

• Verify API credentials are valid and not expired
• Check export schedule configuration
• Confirm BigQuery dataset permissions
• Review Chartbeat audit log for error messages

Tracking Discrepancies

• Validate tracking code placement (must be in <head>)
• Check for ad blockers affecting data collection
• Verify domain configuration in Chartbeat settings
• Test in incognito mode to rule out browser extensions

API Rate Limiting

• Monitor API usage against plan limits
• Implement exponential backoff for retries
• Cache responses when appropriate
• Consider upgrading plan for higher limits

Compliance & Security

Data Processing Agreements

All Chartbeat integrations require appropriate data processing agreements:

Required Documentation

• Data Processing Addendum (DPA) with Chartbeat
• Vendor security assessment and risk scoring
• Privacy policy updates reflecting data sharing
• Cookie consent management for GDPR compliance

Integration-Specific Reviews

• BigQuery export: Review Google Cloud DPA and BAA requirements
• Third-party plugins: Assess plugin security and update practices
• API integrations: Validate credential storage and encryption
• Webhook endpoints: Ensure secure HTTPS endpoints with authentication

Access Control & Credentials

API Key Management

• Store API keys in secure credential management system (e.g., AWS Secrets Manager, HashiCorp Vault)
• Rotate keys quarterly or after team member departures
• Use separate keys for production vs. development environments
• Implement least-privilege access (read-only where possible)

Service Account Best Practices

• Create dedicated service accounts for each integration
• Document service account owners and purpose
• Review and audit access permissions quarterly
• Revoke unused service accounts promptly

Monitoring & Alerting

Integration Health Checks

• Monitor API response times and error rates
• Alert on export job failures or data delays
• Track BigQuery storage costs and query performance
• Set up uptime monitoring for webhook endpoints

Compliance Monitoring

• Regular audits of data sharing and export logs
• Automated checks for PII in exported data
• Monitoring consent management integration status
• Alerts for compliance policy violations

Backlog & Opportunities

Requested Integrations

High Priority

• Snowflake Direct Export - Bypass BigQuery for Snowflake-native organizations (Engineering: 3 weeks, High impact)
• Salesforce Marketing Cloud - Sync audience segments for email targeting (Engineering: 5 weeks, Medium impact)
• Adobe Analytics - Unified view of real-time and historical analytics (Engineering: 4 weeks, High impact)

Medium Priority

• Amplitude - Product analytics integration for user behavior analysis (Engineering: 3 weeks, Medium impact)
• HubSpot - Lead scoring based on content engagement (Engineering: 2 weeks, Medium impact)
• Slack App - Enhanced notifications with interactive components (Engineering: 2 weeks, Low impact)

Exploration Phase

• Customer Data Platforms - Segment, mParticle integration for unified customer view
• Programmatic Advertising - Audience creation based on engagement patterns
• Content Recommendations - AI-powered content suggestions using engagement data

Technical Debt & Improvements

Infrastructure

• Migrate legacy webhook integrations to event-driven architecture
• Implement retry logic and dead letter queues for failed exports
• Create unified integration monitoring dashboard
• Standardize error handling and logging across integrations

Documentation

• Create video tutorials for common integration setup procedures
• Build integration testing framework for QA automation
• Develop troubleshooting decision trees for support team
• Publish API client libraries for popular languages (Python, JavaScript, Ruby)

Client Feature Requests

Track and prioritize integration requests from clients and internal stakeholders: