Reading time: 11 minutes
Scroll depth in GA4 shows how far down the page a reader went. By default, however, GA4 records a single point: the scroll event, at 90% of the page. To see 25%, 50%, 75% and 100% of the text, send your own events with gtag or Tag Manager. Then read the count by page.
In short
- The default GA4 scroll depth is one event only. It fires once per page, when 90% of it becomes visible. So it can’t tell who stopped at 30% or at 60%.
- To find where readers give up, send events at 25%, 50%, 75% and 100% of the text, through Tag Manager or a gtag snippet.
- Read each event by page in a GA4 exploration and divide the count by the page’s views.
- The data only exists after you deploy, and your own traffic has to stay out.
What does the GA4 scroll event measure?
The GA4 scroll event measures whether the reader got near the end of the page, and nothing more. According to the Google Analytics Help, it fires the first time a user reaches the bottom of each page. That happens when a 90% vertical depth becomes visible. In other words, the event fires once per page, and it is the only scroll depth measure in default GA4.
The event is part of enhanced measurement, which you turn on in Admin, Data collection and modification, Data streams. It also fills the Percent scrolled dimension. If the page scrolled at least 90%, the value 90 appears. Otherwise, the dimension stays blank, according to the GA4 dimensions list.
WordPress users with Site Kit see the same behavior, because the 90% rule comes from Google. What Site Kit does, such as installing the tag and turning on enhanced measurement, is in its documentation. But the documentation describes no option to change that limit. That doesn’t prove the plugin offers none. It is what we saw in the GA4 of our blog while Site Kit installed it, until October 28, 2026: the default scroll was the only scroll signal.

Why isn’t the 90% GA4 scroll event enough?
The scroll event answers a single question: did the reader get near the end? Someone who quit at 20% and someone who stopped at 80% look the same, because neither fires the event. Therefore, the default GA4 scroll depth doesn’t show where the text lost the reader.
There are two other limits. The first is the target: the 90% applies to the page, not to the article. Comments, related posts and the footer count too. That reading is ours, based on Google’s definition. So the 90% point can fall before the end of the text or after it.
The second limit is attention, which concentrates at the top. In an eye-tracking study with 120 participants, Nielsen Norman Group measured about 57% of viewing time above the fold. In the first two screenfuls, the share reached 74%. The 2018 study used 1920 by 1080 screens and pages from several sectors, including blogs. For that reason, a marker only at the end ignores the part where attention changes most.
| Measure | Answers | Doesn’t answer |
|---|---|---|
| Scroll event (90%) | How many got near the end | Where the others left |
| Events from 25 to 100% | In which quarter of the text reading drops | Whether the reader actually read |
How do you create 25, 50, 75 and 100% scroll events in GA4?
To measure scroll depth in GA4 at 25, 50, 75 and 100%, there are two paths. One is the Scroll Depth trigger in Google Tag Manager, with no code. The other is a gtag snippet that measures only the text block. The trigger measures the whole page, while the snippet measures the article. In both cases, you get one event for each mark.
Option 1: the Tag Manager trigger
In Tag Manager, create a trigger of the Scroll Depth type, choose Vertical Scroll Depths, select Percentages and enter 25, 50, 75, 100, separated by commas. According to the Tag Manager Help, the tag fires once at each mark reached. Also, the Scroll Depth Threshold variable holds the value of the mark, which you can use to build the event name.
There is a catch. If the depth is already visible in the window when the page loads, the trigger fires even without scrolling. Therefore, on short pages, the first marks show up for free. Site Kit doesn’t create this event on its own. According to the Site Kit event documentation, event tracking can’t be set up only in Site Kit. It points to Tag Manager or the GA4 interface.
Option 2: a gtag snippet for the article text
The snippet below measures the text block, not the page. It is a simplified version of the one we first used on our blog. Swap the selector for your theme’s text block and paste the code after the Google tag. This matters because the gtag documentation warns that Google doesn’t process events placed above it.
<script>
(function () {
// Block that holds only the article text (adjust to your theme)
var textBlock = document.querySelector('.entry-content');
if (!textBlock || typeof gtag !== 'function') return;
var marks = [25, 50, 75, 100];
var sent = {};
function check() {
var box = textBlock.getBoundingClientRect();
if (box.height <= 0) return;
// How much of the block has entered the window, from 0 to 100
var seen = (window.innerHeight - box.top) / box.height * 100;
marks.forEach(function (mark) {
// Small margin on the last mark, to absorb rounding
var target = mark === 100 ? 97 : mark;
if (!sent[mark] && seen >= target) {
sent[mark] = true;
gtag('event', 'text_scroll_' + mark);
}
});
}
window.addEventListener('scroll', check, { passive: true });
check();
})();
</script>
The code calculates the share of the block that has passed the bottom edge of the window. When that share reaches a mark, it sends the event once per page load. It also checks the position on load. So a mark that is already visible fires without scrolling, as with the Tag Manager trigger. The name has to follow the GA4 rules: start with a letter, use only letters, numbers and underscores, and avoid reserved names and prefixes. For that reason, the name scroll doesn’t work, and the example uses the prefix text_scroll_.
One event per mark needs no extra setup. If you prefer a single event with the mark as a parameter, however, first create an event-scoped custom dimension. According to the GA4 Help, reports can use the dimension only 24 to 48 hours later.
How to check that the events fire
Open the article in an incognito window, without a WordPress login, scroll to the end and check the GA4 Realtime report. When you are logged in, Site Kit excludes your visits. The four events should show up. Also, DebugView shows each event right away, but it needs extra setup, according to the gtag documentation. Finally, check the event names, because GA4 treats uppercase and lowercase as different.
How do you see scroll depth by page in GA4?
To read scroll depth by page in GA4, use a free-form exploration. Put the page path in the rows, the event name in the columns and the event count in the values. Then divide each mark by the page’s views.
- Create the exploration. In Explore, choose the Free form template.
- Import the variables. Use the dimensions Page path and screen class and Event name, and the metric Event count.
- Build the table. Next, drag the page path to the rows, the event to the columns and the count to the values.
- Filter. Then apply a filter on Event name that keeps only page_view and the text_scroll_ events. Because the filter conditions combine with AND, a regular expression such as
page_view|text_scroll_.*does it in one go, if your interface offers that condition. - Calculate. Finally, divide the count of each mark by the page_view count, on the same row.
Choose the page path, not the path with the query string, so visits with UTM don’t become separate rows. To look only at assistant traffic, also apply the source filter from the guide to AI traffic in GA4.
This walkthrough follows Google’s Help. However, we didn’t build this exploration in a GA4 account, and the menu names can vary in your interface. There is also a limit: new events exist only from the day the code goes live, and GA4 doesn’t recreate the past. So wait for visits to pile up before comparing articles. Also compare only texts of similar length.
How do you read depth together with time and conversion?
Treat GA4 scroll depth as a drop-off signal, not as proof of reading. Someone who scrolls fast reaches the end without reading. So cross each mark with engagement time and with the page’s conversion before you change the text.
Average engagement time measures how long the site was in focus in the browser, according to the GA4 metrics list. It doesn’t measure reading itself. Here are some patterns. They are hypotheses to test, not diagnoses:
| Pattern | Hypothesis |
|---|---|
| Sharp drop by 25% | The opening doesn’t deliver on the promise of the title |
| Reaches 75%, with little time | The reader skims the text |
| Reaches 100%, no conversion | The end of the text has no clear invitation |
| Little depth, with conversion | The short answer already solved it |
Don’t mark the scroll events as key events. In GA4’s definition of an engaged session, a session with one or more conversion events, now called key events, counts as engaged. That way, you would inflate the engagement rate and mix reading with conversion.
Next, link the reading to the return. To choose the indicators, see the digital marketing KPIs. To prove the blog’s results, see the content marketing ROI. When the lead says they came through AI, the question How did you hear about us? closes the loop.
How do you avoid counting internal traffic?
Exclude your traffic with one of three methods, which add up: the Site Kit exclusion of logged-in users, an IP filter in GA4 and a signal stored in the browser. Without them, GA4 scroll depth includes your tests, and the rates of the first days come out inflated.
- Site Kit: the Exclude Analytics option, in the Analytics settings, excludes logged-in users. According to the Site Kit documentation, that is already the default setting. However, anyone who tests while logged out still counts.
- IP filter: GA4 tags the traffic with the traffic_type parameter and applies a data filter. According to the GA4 Help, an active filter has a permanent effect. So start with the Testing state, which takes 24 to 36 hours to show values.
- Browser signal: Google documents the
ga-disableproperty with the measurement ID. When it is true, the Google tag doesn’t send data, according to the Google privacy page. You must set it before any gtag call, which, with Site Kit, means placing it before the tag that Site Kit adds.
An IP filter helps little when the IP changes, as on home networks. For that reason, we use the third method. The snippet below stores a signal in the browser and turns the property on in later visits. Open a page with ?internal=1 once in each browser. To undo it, use ?internal=0.
<script>
// Place before the Google tag. Replace G-XXXXXXXXXX with your measurement ID.
(function () {
try {
var p = new URLSearchParams(location.search).get('internal');
if (p === '1') localStorage.setItem('internal', '1');
if (p === '0') localStorage.removeItem('internal');
if (localStorage.getItem('internal') === '1') {
window['ga-disable-G-XXXXXXXXXX'] = true;
}
} catch (e) {}
})();
</script>
What we did on our blog, and what we can’t say yet
On the NotHuman blog, GA4 first came from Site Kit and only had the default scroll event. So on October 27, 2026, we added four events of our own, from nh_scroll_25 to nh_scroll_100. Each one fired once per visit, when 25%, 50%, 75% or 100% of the post’s text block reached the window. In a browser test, the four events fired at the right marks.
Since October 28, 2026, GA4 on the blog goes out through Google Tag Manager. The same four marks now go as a single scroll_depth event, with the mark as a parameter, which is the second approach described above. To stay out of the count, a first-party cookie flags our browsers, and Tag Manager blocks the tags when it is set. WordPress sets the cookie for anyone who logs in, and a URL parameter sets it in browsers where nobody logs in. The snippet above is a simpler version of the same idea.
We don’t have results yet for scroll depth in GA4. After all, the data starts in late October 2026, and this guide has no reading numbers from our blog. To decide whether to keep a blog, see when a blog still pays off.
Main sources
- Google Analytics, enhanced measurement events.
- Google Analytics, GA4 dimensions and metrics.
- Google for Developers, event setup with gtag.
- Google Tag Manager, Scroll Depth trigger.
- Google Analytics, internal traffic filter.
- Google for Developers, privacy and turning off Analytics.
- Site Kit, Analytics module documentation.
- Nielsen Norman Group, scrolling and attention (2018).



