GA4 Engagement: Track User Action in 2026

When it comes to building meaningful connections with your audience, simply broadcasting messages isn’t enough; true success in marketing hinges on actively engaging them, transforming passive viewers into active participants who feel seen and heard. But how do you move beyond likes and shares to genuine interaction that builds loyalty and drives action? It’s simpler than you think to get started.

We’ve all seen the vanity metrics — the millions of impressions, the thousands of likes. Pretty numbers, sure, but do they move the needle? Not usually. My philosophy, honed over a decade in digital marketing, is that engagement is the true currency of digital success. It’s not about how many people see your content, but how many people connect with it. For this guide, I’m going to walk you through setting up robust engagement tracking using Google Analytics 4 (GA4) and Google Tag Manager (GTM), the undisputed champions for this kind of work in 2026. This isn’t just about tracking; it’s about understanding and then optimizing.

Step 1: Setting Up Your GA4 Property for Engagement Tracking

Before we even touch GTM, we need to ensure your GA4 property is ready to receive the rich engagement data we’re about to send its way. This is foundational. Without this, all your GTM efforts are just shouting into the void.

1.1 Create a New GA4 Property (If You Haven’t Already)

If you’re still clinging to Universal Analytics, stop. Seriously. GA4 is the future, and its event-driven model is inherently better for tracking nuanced user behavior.

1. Log into your Google Ads account.
2. Click Admin (the gear icon) in the bottom-left corner.
3. Under the “Property” column, click Create Property.
4. Enter a “Property name” (e.g., “My Business Website GA4”).
5. Select your “Reporting time zone” and “Currency.”
6. Click Next.
7. Fill in your business information (industry, size). This helps Google tailor some default reports.
8. Click Create.

Pro Tip: Immediately after creation, navigate to Data Streams, click on your new web stream, and ensure “Enhanced measurement” is turned on. This automatically tracks page views, scrolls, outbound clicks, site search, video engagement, and file downloads – a fantastic starting point for basic engagement data. You’ll see a toggle switch next to “Enhanced measurement” – make sure it’s blue.

1.2 Define Custom Engagement Events as Conversions

GA4 automatically tracks some engagement, like `user_engagement`. But we want more specific, actionable insights. We’ll define key engagement metrics as conversions to highlight them in our reports.

1. In GA4, go to Admin.
2. Under the “Data Display” column, click Conversions.
3. Click the New conversion event button.
4. Type in the exact event name you plan to track. For instance, if you want to track users who scroll 75% down a page, you might name it `scroll_75_percent`. If you want to track users who spend 60 seconds on a page, name it `time_on_page_60s`. We’ll create these events in GTM later.
5. Click Save.

Common Mistake: Not defining these as conversions. If you don’t, they’ll just be regular events, harder to spot in reports, and won’t contribute to your conversion metrics. I learned this the hard way with a client last year who was tracking “form_view” but not “form_submit” as a conversion – their conversion rate looked abysmal because the critical action wasn’t being prioritized.

Expected Outcome: You’ll see a list of your custom event names marked as conversions, ready for data to flow in.

Step 2: Implementing Scroll Depth Tracking with Google Tag Manager

Scroll depth is a fantastic indicator of content engagement. Someone who scrolls 75% down your blog post is clearly more engaged than someone who bails after 25%. This is a non-negotiable metric for any serious content marketer.

2.1 Enable the Built-in Scroll Depth Variable

GTM makes this surprisingly easy.

1. Log into your Google Tag Manager container.
2. In the left-hand navigation, click Variables.
3. Under “Built-In Variables,” click Configure.
4. Scroll down to the “Scrolling” section and check the boxes next to:
   • Scroll Depth Threshold
   • Scroll Depth Units
   • Scroll Direction

Pro Tip: Activating these variables now means they’ll be available for use in your tags and triggers later, saving you a headache.

2.2 Create a Scroll Depth Trigger

This trigger will fire our GA4 event when a user reaches specific scroll points.

1. In GTM, click Triggers in the left-hand navigation.
2. Click New.
3. Click Trigger Configuration and choose Scroll Depth under “User Engagement.”
4. Select Vertical Scroll Depths.
5. For “Thresholds,” enter `25,50,75,100` (comma-separated, no spaces). This means the trigger will fire at each of these percentages.
6. Choose Percentages for “Units.”
7. Select All Pages for “Enable this trigger on.”
8. Name your trigger (e.g., “Scroll Depth Trigger”) and click Save.

2.3 Create the GA4 Event Tag for Scroll Depth

Now we connect the trigger to a GA4 event.

1. In GTM, click Tags in the left-hand navigation.
2. Click New.
3. Click Tag Configuration and choose Google Analytics: GA4 Event.
4. For “Measurement ID,” select your GA4 Configuration Tag (you should have one already set up pointing to your GA4 property, usually named “GA4 Configuration”). If not, create one now by choosing “Google Analytics: GA4 Configuration” and entering your “G-” Measurement ID from GA4 Admin > Data Streams.
5. For “Event Name,” enter `scroll_depth_percent`. This is a generic name that we’ll refine with parameters.
6. Under “Event Parameters,” click Add Row.
   • For “Parameter Name,” enter `scroll_percent`.
   • For “Value,” click the brick icon and select the built-in variable {{Scroll Depth Threshold}}.
7. Click Triggering and select the “Scroll Depth Trigger” you just created.
8. Name your tag (e.g., “GA4 Event – Scroll Depth”) and click Save.

Expected Outcome: Your GA4 real-time reports will start showing `scroll_depth_percent` events with `scroll_percent` parameters as users scroll your pages. This gives you granular data on how far down your content people are actually going. We use `scroll_depth_percent` as the event name and `scroll_percent` as the parameter to keep the data structured and easy to analyze in GA4.

Step 3: Implementing Time on Page Tracking with Google Tag Manager

Beyond scrolling, how long a user actively spends on a page is a critical engagement metric. A quick bounce doesn’t tell you much, but 60 seconds? That’s attention.

3.1 Create a Custom HTML Tag for Time on Page

This requires a small snippet of JavaScript. Don’t worry, it’s straightforward.

1. In GTM, click Tags.
2. Click New.
3. Click Tag Configuration and choose Custom HTML.
4. Paste the following JavaScript into the HTML box. This script will push a GTM dataLayer event after specific time intervals.

<script>
  function sendTimeOnPageEvent(time) {
    window.dataLayer.push({
      'event': 'time_on_page_event',
      'event_category': 'Engagement',
      'event_action': 'Time on Page',
      'event_label': time + ' seconds'
    });
  }

  setTimeout(function() { sendTimeOnPageEvent(30); }, 30000);
  setTimeout(function() { sendTimeOnPageEvent(60); }, 60000);
  setTimeout(function() { sendTimeOnPageEvent(90); }, 90000);
</script>

5. Click Triggering and select the built-in All Pages trigger.
6. Name your tag (e.g., “Custom HTML – Time on Page Trigger”) and click Save.

Editorial Aside: I’ve seen countless marketers get hung up on complex JavaScript for this. This simple `setTimeout` method is robust and effective. Don’t overcomplicate it! The goal is actionable data, not an elegant script.

3.2 Create Custom Event Triggers for Time on Page

Now we create triggers that fire when our custom HTML tag pushes events to the dataLayer.

1. In GTM, click Triggers.
2. Click New.
3. Click Trigger Configuration and choose Custom Event.
4. For “Event name,” enter `time_on_page_event`. This must exactly match the `event` value in the JavaScript.
5. Select All Custom Events.
6. Name your trigger (e.g., “Custom Event – Time on Page”) and click Save.

Pro Tip: We’re creating one generic custom event trigger here that fires for any `time_on_page_event`. We’ll use event parameters in the GA4 tag to differentiate between 30, 60, and 90 seconds.

3.3 Create the GA4 Event Tag for Time on Page

This tag sends the time-on-page data to GA4.

1. In GTM, click Tags.
2. Click New.
3. Click Tag Configuration and choose Google Analytics: GA4 Event.
4. For “Measurement ID,” select your “GA4 Configuration” tag.
5. For “Event Name,” enter `time_on_page`.
6. Under “Event Parameters,” click Add Row.
   • For “Parameter Name,” enter `time_spent_seconds`.
   • For “Value,” click the brick icon. Here, we need to create a new Data Layer Variable.
     1. Click the + button in the top right of the variable picker.
     2. Choose Data Layer Variable for “Variable Type.”
     3. For “Data Layer Variable Name,” enter `event_label`. This will pull the ’30 seconds’, ’60 seconds’, etc., from our JavaScript.
     4. Name your Data Layer Variable (e.g., “DLV – Event Label”) and click Save.
     5. Select this newly created Data Layer Variable.
7. Click Triggering and select the “Custom Event – Time on Page” trigger you created.
8. Name your tag (e.g., “GA4 Event – Time on Page”) and click Save.

Expected Outcome: GA4 will now receive `time_on_page` events, each with a `time_spent_seconds` parameter indicating 30, 60, or 90 seconds. This is immensely powerful for understanding contentstickiness. We used this exact setup for a B2B SaaS client in Atlanta last year. By tracking time on page for their “How-To” articles, we discovered that articles with embedded video tutorials had an average time on page 45% higher than text-only articles, directly informing their content strategy for the next quarter.

Step 4: Publishing Your GTM Container and Verifying Data

All that setup is useless if you don’t publish and verify.

4.1 Publish Your GTM Container

1. In GTM, click the blue Submit button in the top right corner.
2. Add a “Version Name” (e.g., “Added Scroll and Time on Page Tracking”) and a brief “Version Description.”
3. Click Publish.

Common Mistake: Forgetting to publish! Your changes won’t go live until you do.

4.2 Verify Data in GA4 DebugView and Realtime Reports

This is where the rubber meets the road.

1. In GA4, go to Admin.
2. Under the “Data Display” column, click DebugView.
3. Open your website in a new browser tab where you have the Google Tag Assistant Chrome Extension enabled.
4. Browse your site, scroll down, and spend some time on pages.
5. Watch DebugView in GA4. You should see `scroll_depth_percent` and `time_on_page` events firing as you interact with the site. Look for the parameters you set up (`scroll_percent`, `time_spent_seconds`).
6. Additionally, check Reports > Realtime in GA4 to see a live stream of events.

Expected Outcome: A steady stream of your custom engagement events appearing in DebugView and Realtime reports, confirming your setup is correct. If you don’t see them, double-check your GTM tags, triggers, and GA4 configuration for typos or misconfigurations. I once spent an hour troubleshooting only to find a single missing comma in a JavaScript snippet – a frustrating but common error.

Step 5: Analyzing Your Engagement Data in GA4 Reports

Collecting data is only half the battle; interpreting it is where the magic happens.

5.1 Engagement Overview Report

This report provides a high-level view of user interaction.

1. In GA4, go to Reports > Engagement > Overview.
2. Look at metrics like “Engaged sessions,” “Average engagement time,” and “Event count by event name.”
3. You’ll see your `scroll_depth_percent` and `time_on_page` events here. Click on them to drill down.

5.2 Events Report

This report gives you granular detail on each event.

1. In GA4, go to Reports > Engagement > Events.
2. Find your `scroll_depth_percent` event. Click on it.
3. You’ll see “Event count” and “Total users.” Scroll down to “Event count by event name” and you’ll see a breakdown of `scroll_percent` values (25, 50, 75, 100). This immediately tells you how many users reached each depth.
4. Do the same for your `time_on_page` event, examining the `time_spent_seconds` parameter breakdown.

Pro Tip: Use the “Add comparison” feature in GA4 to compare engagement metrics across different audience segments (e.g., mobile vs. desktop users, organic vs. paid traffic). This often reveals surprising insights about where your engagement efforts are most effective, or where they’re falling short.

5.3 Pages and Screens Report

This report shows engagement by content.

1. In GA4, go to Reports > Engagement > Pages and screens.
2. Look at “Views,” “Users,” and “Average engagement time” for each page.
3. You can customize this report to include your custom event metrics. Click the Edit comparisons button (the pencil icon in the top right), then Metrics, and search for your `scroll_depth_percent` or `time_on_page` event counts. This allows you to see which pages are generating the most deep scrolls or long engagement times.

These reports are your compass. They tell you which content is truly resonating, allowing you to double down on what works and rethink what doesn’t. Remember, this isn’t a set-it-and-forget-it deal; consistent analysis and adaptation are key to truly engaging audiences. For more on effective marketing, you might find our article on 2026 campaign success and failure lessons insightful, or explore how to boost 2026 conversions.