Integrating with Site Analytics

By Optimizely Education
Published: Feb 26, 2026
Rating 1 star 2 stars 3 stars 4 stars 5 stars

Average rating: 0 No reviews

Outline

At a glance:

Core idea: CMS repositories query CMS content; analytics platforms query analytics data.
What "integration" means: instrument templates and pass content metadata into tracking tools.
Where CMS helps: store analytics-related settings on content, and audit those settings programmatically.
Where CMS doesn't help: you can't pull pageviews, sessions, or conversions from IContentLoader.

1. Introduction

In digital experience work, content quality matters - but content performance matters too. Analytics helps you understand how people interact with pages, blocks, CTAs, forms, and journeys. For CMS 12 developers, the tricky part is connecting "this content item" to "that performance record."

Note: IContentRepository and IContentLoader are for querying and managing CMS content, not querying raw analytics data. Analytics data lives in specialized platforms such as GA4 and ODP. Integration means connecting systems - not expecting one repository to speak the other system's language.

In practice, integration usually looks like:

Instrumenting templates with tracking scripts
Passing content metadata (IDs, categories, template type, campaign tags) into analytics events
Using analytics outputs to influence delivery via personalization or experimentation
Auditing analytics configuration stored inside CMS content

2. Understanding Analytics Data Sources

Analytics platforms are built for high-volume event collection, aggregation, segmentation, and reporting. They store metrics like pageviews, sessions, bounce rate/engagement, conversions, and audience cohorts.

Common analytics sources you'll see alongside CMS 12:

Google Analytics (GA4): tracks and reports website traffic and events.
Optimizely Data Platform (ODP): a CDP for unifying customer data and powering real-time audiences and personalization.
Custom analytics: internal pipelines for product-specific KPIs and attribution models.

Each platform exposes its own APIs - for example, GA4's data API or ODP's APIs - for querying analytics datasets. CMS repositories are not a substitute for those APIs.

3. Connecting CMS Content to Analytics

Bridging content and analytics starts with instrumentation: your rendered pages must send events that include enough identifiers to tie an event back to a content item. This is where CMS content can help - by storing analytics-related settings or identifiers that your templates output.

Reading a tracking ID property from a page

A common pattern is a custom property on a page type, such as a GA measurement ID override, content group, campaign tag, or "exclude from tracking" flag. You read the property via IContentLoader and then pass it to your rendering logic.

using EPiServer.Core;
using System;

// Assume StandardPage has a custom property 'GoogleAnalyticsId'
// public class StandardPage : PageData { public virtual string GoogleAnalyticsId { get; set; } }

public class AnalyticsIntegrationService
{
    private readonly IContentLoader _contentLoader;

    public AnalyticsIntegrationService(IContentLoader contentLoader)
    {
        _contentLoader = contentLoader;
    }

    public string GetPageAnalyticsId(ContentReference pageLink)
    {
        try
        {
            StandardPage page = _contentLoader.Get<StandardPage>(pageLink);

            if (!string.IsNullOrEmpty(page.GoogleAnalyticsId))
            {
                Console.WriteLine($"Page '{page.PageName}' has Google Analytics ID: {page.GoogleAnalyticsId}");
                return page.GoogleAnalyticsId;
            }

            Console.WriteLine($"Page '{page.PageName}' does not have a specific Google Analytics ID.");
            return null;
        }
        catch (ContentNotFoundException)
        {
            Console.WriteLine($"Page at {pageLink.ID} not found.");
            return null;
        }
        catch (TypeMismatchException)
        {
            Console.WriteLine($"Content at {pageLink.ID} is not a StandardPage.");
            return null;
        }
    }
}

Pro tip: The repository call retrieves CMS data (your custom property). What you do with that value - embedding it into markup, a script block, a data layer, or a tracking library - is the integration part.

Sending custom events with AnalyticsInteraction helpers (Google Analytics add-on)

If you're using Optimizely's Google Analytics add-on, helper APIs can let you push custom events tied to CMS content. In many implementations, that means placing event definitions on the request context and letting the page's tracking script render them.

using EPiServer.GoogleAnalytics.Helpers;
using EPiServer.GoogleAnalytics.Helpers.Events;
using Microsoft.AspNetCore.Http;
using System;

public class CustomAnalyticsEventService
{
    // Typically called from a controller, view component, or middleware in a web request.
    public void TrackCustomContentEvent(
        HttpContext httpContext,
        ContentReference contentLink,
        string eventName,
        string eventCategory)
    {
        if (httpContext == null)
        {
            Console.WriteLine("HttpContext is null, cannot track event.");
            return;
        }

        httpContext.AddAnalyticsCustom(new AnalyticsEvent
        {
            EventName = eventName,
            EventCategory = eventCategory,
            EventAction = "ContentInteraction",
            EventLabel = contentLink.ID.ToString()
        });

        Console.WriteLine($"Custom analytics event '{eventName}' tracked for content ID: {contentLink.ID}");
    }
}

Note: You're not "querying analytics" here - you're emitting analytics events. The content link (or a stable content identifier) becomes your bridge between CMS content and analytics reporting.

4. Using Analytics to Influence CMS Delivery

Analytics isn't just for dashboards. It can influence what content users see - through personalization and experimentation. In Optimizely ecosystems, that often shows up as segments and audiences driving conditional content.

ODP and real-time audiences

ODP integrates with CMS to enable real-time personalization based on audiences. In CMS terms, editors typically work with audiences and visitor group logic in the UI, while developers ensure the integration is enabled and that templates support targeted rendering.

HTML

@* Conceptual example (Razor pseudo-code) *@
@* Editors target content using audiences (visitor groups / real-time audiences). *@
@* Developers wire up rendering so different blocks/partials are served based on audience evaluation. *@

@if (Model.Audience?.IsInSegment("HighValueCustomers") == true)
{
    @Html.Partial("PersonalizedPromoBlock", Model.HighValuePromo)
}
else
{
    @Html.Partial("DefaultPromoBlock", Model.DefaultPromo)
}

Note: Querying "who is in which audience right now" is done via the platform integration (ODP APIs/integration layer), not through CMS repositories. CMS repositories remain focused on content.

5. Querying CMS Content Related to Analytics

Even though CMS repositories can't fetch pageviews or conversions, they can absolutely help you audit analytics-related settings stored in CMS content. That's often a real operational need: "Which pages still use the old measurement ID?" or "Which content is excluded from tracking?"

Finding pages with a specific measurement ID

If your StandardPage has a GoogleAnalyticsId property, you can locate matching content under a subtree. This is useful for audits, migrations, and keeping instrumentation consistent.

using EPiServer.Core;
using System;
using System.Collections.Generic;
using System.Linq;

public class AnalyticsContentQueryService
{
    private readonly IContentLoader _contentLoader;

    public AnalyticsContentQueryService(IContentLoader contentLoader)
    {
        _contentLoader = contentLoader;
    }

    public IEnumerable<StandardPage> FindPagesWithSpecificAnalyticsId(
        ContentReference rootLink,
        string targetAnalyticsId)
    {
        Console.WriteLine($"Finding pages with Google Analytics ID '{targetAnalyticsId}' under ID: {rootLink.ID}");

        IEnumerable<StandardPage> allStandardPages = _contentLoader.GetDescendants<StandardPage>(rootLink);

        var matchingPages = allStandardPages
            .Where(page => !string.IsNullOrWhiteSpace(page.GoogleAnalyticsId)
                && page.GoogleAnalyticsId.Equals(targetAnalyticsId, StringComparison.OrdinalIgnoreCase))
            .ToList();

        if (matchingPages.Any())
        {
            Console.WriteLine($"Found {matchingPages.Count} pages:");
            foreach (var page in matchingPages)
            {
                Console.WriteLine($"- '{page.PageName}' (ID: {page.ContentLink.ID})");
            }
        }
        else
        {
            Console.WriteLine("No pages found with the specified Google Analytics ID.");
        }

        return matchingPages;
    }
}

Pro tip: This is a CMS query over CMS data (your custom property). The output helps you manage instrumentation, but it does not provide analytics metrics. Use it for audits and migrations, not for performance reporting.

6. Limits of CMS Repositories for Analytics

It's worth restating the boundary clearly, because this misunderstanding causes many "why is the repository empty?" moments.

What CMS repositories cannot do

Select a topic to expand and read the details.

No raw analytics data ▼

IContentRepository and IContentLoader cannot query pageviews, sessions, bounce rate, conversions, or audience membership. Analytics data lives in the analytics platform, not in the CMS database.

No real-time performance metrics ▼

Repositories don't expose "how is this content performing?" You must use the analytics platform's APIs for that - GA4's data API, ODP's APIs, or whichever platform stores the metrics you need.

If you need performance numbers, use the platform that stores them. If you need content configuration, use CMS repositories. Different jobs, different toolboxes.

7. Best Practices for Analytics Integration

Consistent instrumentation: ensure templates consistently output tracking scripts and content metadata.
Privacy and consent: implement consent handling and comply with relevant regulations.
Use ODP when appropriate: for segmentation and personalization, a CDP can unlock more than pageview reports.
Audit regularly: query CMS content for analytics-related configuration drift such as IDs, flags, and exclusions.
Model analytics metadata explicitly: prefer named properties like AnalyticsTrackingId and ExcludeFromAnalytics over mystery logic buried in templates.

Conclusion

Integrating Optimizely CMS 12 with analytics platforms is essential for building data-driven experiences. The key is understanding the boundary: CMS repositories manage content, and analytics platforms manage behavior and performance data.

Once that boundary is clear, the integration path becomes straightforward: store analytics metadata in CMS, emit consistent tracking events from templates, use analytics outputs for personalization, and audit your configuration with normal CMS querying patterns.

End-user eLearning

Upcoming events

Certification

Partner training

Community

All Topics