“Pages per Session” Conversion in Google Analytics 4

Updated: October 4th, 2022

Even though I receive many guest post requests every day, 99.9999% of them are just pure trash. And I guess many website owners will relate to this. Some guest posters even offered to write “high quality” articles about cryptocurrencies or dishwashers. But Jude Nwachukwu contacted me with a unique idea tailored to the readers of this blog post. So why not?

You can learn more about Jude and his website DumbData at the end of this blog post. The rest of the text here is Jude’s.

====

It’s no longer news that GA4 will replace Universal Analytics. If you have Pages per Session goal set up in GA3 and would love to migrate it to your Google Analytics 4 property, then keep reading as you’ll learn two methods of setting this up in GA4.

 

Table of Contents

– Hide table of contents –

• What is the “Pages per session” goal?
• But how do you set this up in GA4?
• Method 1: Inside the GA4 user interface
  • How to create a Page Per Session event
  • Creating The Conversion in GA4
  • How would you test this?
  • What Are The Trade-Offs With This Method?
• Method 2: Using GTM + JavaScript
  • Sending The Event To GA4
  • Creating a conversion in GA4 + debugging
• Final words

 

What is the “Pages per session” goal?

If you are familiar with setting up goals in Universal Analytics, then the Pages/Screens per session goal type shouldn’t be a new term for you.

It is one of the signals used to identify that a user is engaged with the content on the website, just like how YouTube uses the number of videos you consume on their platform as one of the ways of measuring how sticky their platform is.

In GA3, it’s easy to set up this type of conversion.

All you’ll do is select the Pages/Screens per session goal type and then put in a number.

Then every time a user views a specific number of pages or screens (for example, 4), then that is counted as a conversion/goal.

 

But how do you set this up in GA4?

There are two methods you can configure Pages/Screens per session goal in Google Analytics 4:

1. Doing everything in the GA4 UI (this has some trades-off)
2. Using the JavaScript + GTM (don’t get code phobia, it’s easy)

 

Method 1: Inside the GA4 user interface

To do this, you’ll have to leverage one of the GA4 event tracking features called Audience Triggers. Does this ring a bell?

Here is how Google defined audience triggers in their documentation.

 

How to create a Pages Per Session event

You can have this setup in less than 30 seconds.

In this example, we want to count sessions with three or more page views as a conversion, and here is how to do it;

#1. Navigate to the configure tab, and select audiences

#2. Click the New Audience button.

#3. Select Create a custom audience.

#4. Add a title, select the human icon beside the timer icon and change the sequence scoping to within the same session.

#5. Under the condition select page_view event, click Add parameter. Under other, select the Event Count parameter.

#6. For the condition, I’ll leave it as greater than two. Then click Apply.

#7. Change the membership duration to 1 day.

#8. Click Create New under the Audience trigger

#9. Add your desired event name. In this example, au_visited_3_pages will be the event name.

#10. Click Log an additional event when audience membership refreshes and click Save.

Boom, now you’ve created your page depth event. The next step will be to set this up as conversion in GA4.

 

Creating The Conversion in GA4

Navigate to conversions in the configure tab and click the New Conversion Event button

Enter the event name that you want to treat as a conversion

In this case, it was au_visited_3_pages.

Yay!! We’ve now set up our page depth conversion for sessions with three or more page views.

 

How would you test this?

One of the ways you can verify this is by going to GTM preview mode. Then visit 3 pages, and you should see the au_visited_3_pages event, represented with a green flag, to symbolize that it is a conversion.

If debug view is not working properly, please refer to this guide.

 

What Are The Trade-Offs With This Method?

1. You are using the 100 audiences limit in GA4
2. The membership duration is one day. If a user has two sessions in a day (and both sessions contain 3 or more pageviews), GA4 will track just one conversion instead of two.
3. The conversion doesn’t count unique page views, only total page views, meaning if the user reloads the same page 3 times, GA4 will count this as a conversion

How can you make GA4 count unique pageviews, not use your audience slots and include all sessions with this conversion? That is where GTM and the power of JavaScript come in handy.

 

Method 2: Using GTM + JavaScript

The first thing we’ll do is to create a Google Tag Manager custom Javascript variable (our variable name is CJS – Page Load Type).

Here is the code to use:

function() {
  try {
    var pageLoadType = performance.navigation.type;
    if (pageLoadType == 1 || pageLoadType == 2) {
      return "viewed before"
    }
    else {
      return "unique"
    }
   }
  catch (e) {
    return "unique"
  }
}

You’ll have to add extra configuration to the variable by clicking the format value and setting undefined and null to “unique” (without quotation marks).

This code leverages a browser API called PerformanceNavigation, and its type property (performance.navigation.type).

performance.navigation.type returns a value representing how a page load happened in the user browser.

• 0 – Represents direct URL entry, clicking a link, and other forms of the normal browser navigation.
• 1 – The page was refreshed or reloaded.
• 2 – The page was loaded using the back and forward buttons.
• 255 – Another navigation method.

We then wrap the browser API in an if-else statement that returns “unique” for all page loads and “viewed before” for refreshes/reloads or pageviews through the backward or forward button.

The next step is to create a page view trigger (“PV – Unique Pageview”) with a trigger, “CJS – Page Load Type”, which equals to “unique”.

To track the number of pages the user has viewed in a session, you need to create a custom HTML tag where the code below will be pasted, and the “PV – Unique Pageview” trigger will be attached to the tag.

<script>
function gtm_getCookie(name) {
  var cookies = decodeURIComponent(document.cookie);
  var cookiesArray = cookies.split(';');
  var cookie = cookiesArray.find(function (item) {
    return name == item.trim().substring(0, name.length);
  });
  return cookie;
}

window.onload = function() {
  var cookieName = "gtm_page_view";
  var l = cookieName.length;
  var cookie = gtm_getCookie(cookieName);
  var visitCount = 0;

  // If cookie exists, set visitCount to value
  if (cookie) visitCount = cookie.trim().slice(l + 1);
  visitCount = parseInt(visitCount) + 1;

  var cookieExpiry = new Date();
  // Set expiry time of 30 mins (in milliseconds)
  cookieExpiry.setTime(cookieExpiry.getTime() + 30 * 60 * 1000);
  var expires = "expires=" + cookieExpiry.toUTCString();

  // Set cookie
  document.cookie = cookieName + "=" + visitCount + ";" + expires + ";path=/";
};
</script>

The HTML tag name can be called cHTML – Pageview Count (Unique Only).

This code counts the number of pages the user has visited and then store the value in the cookie with the name gtm_page_view.

The page view count is stored in a cookie that expires in 30 minutes, and its duration is extended to 30 minutes every time a page loads.

The page_view ( “cHTML – Pageview Count (Unique Only)”) count script will only fire on all page loads except for reloads/refreshes making sure we are only counting uniques and not using total.

To get the number of pages the user has seen in that session, you’ll have to create two variables; a 1st-Party Cookie and a Custom JavaScript variable with the name CJS – Page View Number.

For the 1st-Party Cookie, set the cookie name to gtm_page_view, and the variable name must be 1PC gtm_page_view (without any dashes, ignore the dash in the screenshot).

The next step is to create the custom JavaScript variable using this code;

function() {
  var pageviewnumber = '{{1PC gtm_page_view}}';
  return parseInt(pageviewnumber);
}

The variable helps retrieve the number of pages viewed by that user in that session.

The code accesses the gtm_page_view cookie and returns the value of the number of pages the user viewed in a session as a number data type.

 

Sending The Event To GA4

Since GA4 is an event-based analytics platform, we’ll have to send this conversion first as an event before marking it as a conversion.

To send the event data to GA4, you’ll have to create a GA4 event tag in Google Tag Manager and add the event name.

I’ll use visited_3_pages since we count sessions with three or more page views as a conversion.

After creating the tag, the next step is adding a trigger.

Click on Triggering and then plus sign to add a trigger. Select the Window Loaded trigger and then add a condition where the variable CJS – Page View Number equals 3.

It means that once the user hits the mark, visiting the third page, this event will fire in GTM with the event data sent to Google Analytics.

 

Creating a conversion in GA4 + debugging

From the Conversions screen in the Configure tab, click the New Conversion Event button. Enter visited_3_pages as the conversion event.

Hurray!! We’ve now set up our page depth conversion for sessions with three or more page views.

Testing this is easy in GTM preview mode.

Try to visit three pages, but while on the second page, reload the page to check if the GA4 event fired in GTM (it should not because it’s still the second unique page view).

Now visit the third page. The GA4 event should fire in GTM and GA4 debug view, and you should see the visited_3_pages event (with a green flag because it’s marked as a conversion).

The beautiful thing about this approach is that it’s reusable for conversion tracking across other ad platforms like Facebook, Google Ads (if you don’t want to do a GA4 import), TikTok pixel, etc.

 

Pages per session goal in GA4: Final words

Now you’ve seen two different methodologies you can explore when migrating or configuring your Pages/Screens per session goal in your Google Analytics 4 implementation.

Be aware of the trade-offs when implementing inside your GA4 user interface. Now, let me know in the comment what method you’ll be using if you’re to configure yours.

This article was written by Jude Nwachukwu, who is the co-founder of DumbData and an analytics specialist with years of industry experience helping startups, small, and enterprise businesses in different parts of the globe (Africa, US, Europe) crush their measurement goals.