Web Analytics with Google Analytics 4The GA4 data model · Lesson 4 of 20
Events, parameters and user properties
Video lecture
Events, parameters and user properties
The narrated lecture is in production
Every chapter is scripted and ready. Browse the chapters and read the full transcript now — the video will appear here when it’s published.
Chapters
Transcript of the narration, chapter by chapter.
0:00 Events, parameters, user properties
If you learned web analytics years ago, you might still think in page views, sessions and bounce rate. G A four thinks differently. Everything is an event: a page view, a scroll, a purchase, even the start of a session. Sessions and users still exist, but they're built from events. In this lecture you'll learn the event model properly: event names, parameters, user properties, the four families of events, how engagement is defined, and what the same event looks like in the raw BigQuery export.
0:37 Why the model matters
Why does the model matter? Because every report, exploration and export you'll ever use is built from it. If you understand that a purchase is an event with parameters like value, currency and items, you'll know why revenue breaks when currency is missing. If you understand that user properties describe the person, you'll segment correctly. And when a stakeholder asks for a new report, you'll know whether it's a new event, a new parameter, or just a new view of data you already collect.
1:14 The receipt analogy
Here's the core idea with an analogy. Think of a receipt from a coffee shop. The event name is what happened: purchase. The parameters are the lines on the receipt: the items, the price, the currency, the branch. And the user properties are on the loyalty card: gold member, prefers oat milk. The receipt describes one moment. The loyalty card describes the person across every visit. Ask yourself one question every time: does this describe the action, or the person?
1:49 Four families, in priority order
Events come in four families, and there's a priority order. Automatically collected events are sent by the Google tag by default, like first visit, session start and user engagement. Enhanced measurement events are toggled on in the web stream, like page view, scroll, outbound click, file download and site search. Recommended events are ones you implement using Google's predefined names, like sign up, generate lead and purchase. And custom events are your own names for things nothing else covers. Rely on automatic, enable useful enhanced measurement, use recommended wherever it fits, then fill gaps with custom.
2:31 Parameters
Parameters are where the insight lives. An event name alone tells you that something happened. Parameters tell you what, where and how much. On a freight quote calculator, you might send product line, origin country, destination country and a quote band, like one thousand to five thousand, rather than the exact amount, to keep the number of unique values low. And remember: most custom parameters must be registered as custom dimensions before they appear in reports. Collection and reporting are two separate steps.
3:07 Engagement definitions
Now engagement, which replaced the old bounce rate thinking. A session starts with session start and ends after thirty minutes of inactivity by default. An engaged session lasted longer than ten seconds, had a key event, or had at least two page or screen views. Engagement rate is engaged sessions divided by sessions, and G A four's bounce rate is simply the inverse. That's more meaningful than the old single-page bounce. A reader who spends three minutes on one article and leaves is engaged.
3:44 Identity
And identity, briefly. G A four can recognize users with a user id you provide for logged-in users, with device identifiers like the first-party cookie on the web, and with modeled data where consent is denied, depending on your reporting identity setting. So user counts will never exactly match other systems. Explain that to stakeholders early. Chasing perfect reconciliation wastes time. Aim for consistent, directionally reliable data, and document how users are counted.
4:16 Example 1: recipe publisher
First example, a simple one. A recipe publisher sees healthy page views but flat newsletter sign-ups. With the event model, they check three things. Scroll events by page: do readers reach the sign-up box near the bottom? A custom event when the sign-up box enters the viewport, compared with sign ups: is the problem visibility or persuasion? And the method parameter on sign up: do inline forms beat pop-ups? Illustratively, if few readers ever see the box, moving it higher is a better first test than rewriting its copy.
4:55 Example 2: Gulf freight portal
Second example, a business case. A freight portal serving the UAE, Saudi Arabia and Pakistan tracks one calculate quote event with origin, destination, product line and quote band, plus a customer type user property: new, returning or contract. One exploration now answers three questions that used to need three separate custom events. Which lanes are most requested? Which quote bands convert to bookings? And do contract customers behave differently from new ones? Good parameters replaced event sprawl.
5:28 Watch me do it, part 1
Watch me send that event. With the Google tag on the page, I call gtag event, calculate quote, and pass an object with product line freight, origin a e, destination p k, and quote band one thousand to five thousand. I call it after the calculator returns a result, not on the button click. When the user logs in, I set a user property, membership tier pro. And for logged-in users, I pass my own internal, non-personal user id in the config, subject to consent and my privacy notice. Then I open DebugView and confirm the event arrives once with all four parameters.
6:13 Watch me do it, part 2
Now the same event in the raw BigQuery export. Parameters live in a repeated field called event params, a list of key and value pairs. So to read one, I use a small subquery: select the string value from unnest event params where the key equals product line. I count quotes by product line for one day's table and sort them. Seeing that raw structure once makes the model click: every event is a row, and its parameters are a list attached to it.
6:50 Common mistakes
Common mistakes. Treating G A four like its predecessor and looking for category, action and label. That model is gone; use meaningful names and parameters. High-cardinality parameters, like full timestamps, unique ids or free-text search terms in general dimensions, which bloat reports and trigger the other row. Setting user properties once and never updating them. And sending value on non-revenue events, then summing revenue that never happened.
7:19 Quick reference
Here's a quick reference you can keep. Describe the action with the event name, verb then object. Describe the context with event parameters. Describe the person with a user property. Identify a logged-in user with your own internal, non-personal user id. If you remember nothing else from this lecture, remember that four-line map. It answers most design questions in seconds.
7:45 Recap
Recap. G A four collects everything as events, and sessions and users are derived. Use the four families in priority order. Parameters carry the insight, and most need registering before they appear in reports. User properties describe the person. Engagement is defined by time, key events or views. User counts won't match other tools exactly, and that's fine if it's consistent and explained.
8:12 Try this now
Try this now. Pick three events on a site you know. For each, write the event name, three useful parameters and one user property that would help segment the analysis. Then check whether any of your parameters would have high cardinality, and band them if so.
Everything is an event
GA4 is built on an event-based data model. A page view is an event (page_view). A scroll is an event. A purchase is an event. Sessions and users still exist, but they are derived from events rather than being the core unit of collection.
Each event carries:
- An event name — what happened (
add_to_cart). - Event parameters — context about that occurrence (
currency,value,items,page_location). - User properties — attributes of the user that persist across events (
membership_tier,preferred_language). - Automatically attached data — device, geography (derived at collection time), traffic source, timestamps and identifiers.
The four families of events
| Family | How it is collected | Examples |
|---|---|---|
| Automatically collected | Sent by the Google tag or SDK by default | first_visit, session_start, user_engagement |
| Enhanced measurement | Toggled in the web data stream | page_view, scroll, click (outbound), file_download, view_search_results |
| Recommended | You implement, using Google's predefined names | sign_up, generate_lead, purchase |
| Custom | You implement with your own names | calculate_quote, select_plan |
Think of the families as a priority order: rely on what is automatic, switch on useful enhanced measurement, use recommended events wherever they fit, and fill gaps with custom events.
Parameters: where the insight lives
An event name alone tells you that something happened. Parameters tell you what, where and how much. Consider a quote calculator on an insurance or logistics site:
event: calculate_quote
params:
product_line: freight
origin_country: ae
destination_country: pk
quote_band: 1000_5000 (banded, not the exact amount, to keep cardinality low)
value: 0 (not revenue; omit or set carefully)Most custom parameters must be registered as custom dimensions or metrics before they appear in standard reports and explorations (covered later in this module). Collection and reporting are two separate steps — a frequent source of confusion.
User properties versus event parameters
Ask: does this describe the action, or the person?
- The plan a user selected in this click is an event parameter.
- The plan the user is currently subscribed to is a user property — it describes them across all events until it changes.
User properties are powerful for segmentation (for example, comparing behavior of free versus paid users) but should never contain personal data. A user_id can be set to your own internal, non-personal identifier to help GA4 recognize logged-in users across devices, subject to your privacy notice and consent requirements.
How GA4 derives sessions and engagement
A session begins with session_start and ends after a period of inactivity (30 minutes by default, adjustable). GA4 defines an engaged session as one that lasted longer than 10 seconds (adjustable), had a key event, or had at least two page or screen views. Engagement rate is engaged sessions divided by sessions; bounce rate in GA4 is simply its inverse. That definition is more meaningful than the old "single page" bounce: a visitor who reads an article for three minutes and leaves is now engaged.
Identity: how users are counted
GA4 can use several identity signals depending on your reporting identity setting — a user ID you provide, device IDs (the first-party cookie on the web), and modeled data where consent is denied. Counts of users will therefore never exactly match other systems. Explain this to stakeholders early; chasing perfect reconciliation wastes time. Aim for consistent and directionally reliable data instead.
Worked example: diagnosing a content site
A recipe publisher sees healthy page views but flat newsletter sign-ups. With the event model they can check:
scrollevents by page — do readers reach the sign-up box near the bottom?- A custom
view_signup_boxevent (fired when the box enters the viewport) versussign_up— is the problem visibility or persuasion? - The
sign_upevent'smethodparameter — do inline forms outperform pop-ups?
Illustratively, if only a small share of readers ever sees the box, moving it higher is a better first test than rewriting its copy.
Hands-on: sending an event with parameters and a user property
With the Google tag (gtag.js) already on the page, a custom event with parameters and a user property looks like this. In Google Tag Manager you would push the same information to the data layer instead (module 3).
// After the quote calculator returns a result (not on button click)
gtag('event', 'calculate_quote', {
product_line: 'freight',
origin_country: 'ae',
destination_country: 'pk',
quote_band: '1000_5000' // banded to keep cardinality low
});
// When the user's subscription state is known (e.g., after login)
gtag('set', 'user_properties', { membership_tier: 'pro' });
// Logged-in users: your own internal, non-personal ID (subject to consent and your privacy notice)
gtag('config', 'G-XXXXXXX', { user_id: 'u_83f2a9' });Verify in DebugView that calculate_quote arrives once with all four parameters, then register the parameters you want in reports as custom dimensions.
The same event in the BigQuery export
In the raw export, parameters live in a repeated event_params field, so you "unnest" them. This query counts quotes by product line for one day:
SELECT
(SELECT value.string_value FROM UNNEST(event_params) WHERE key = 'product_line') AS product_line,
COUNT(*) AS quotes
FROM `my-project.analytics_123456789.events_20260915`
WHERE event_name = 'calculate_quote'
GROUP BY product_line
ORDER BY quotes DESC;Seeing the raw structure once makes the "event plus parameters" model concrete. Module 7 covers the export in depth.
Second worked example: a Gulf logistics portal
A freight portal serving the UAE, Saudi Arabia and Pakistan tracks one calculate_quote event with origin, destination, product line and a quote band, plus a customer_type user property (new, returning, contract). One exploration then answers three questions that used to need three custom events: which lanes are most requested, which quote bands convert to bookings, and whether contract customers behave differently from new ones.
Common mistakes
- Treating GA4 like its predecessor and looking for "event category / action / label" — that model is gone; use meaningful names and parameters.
- High-cardinality parameters such as full timestamps, unique IDs in general dimensions, or free-text search terms stored as user properties. They bloat reports and trigger the "(other)" row.
- Setting user properties once and never updating them when the user's state changes.
- Using
valueon non-revenue events and then summing "revenue" that never happened.
Quick reference
Describe the action -> event name (verb_object)
Describe the context -> event parameter
Describe the person -> user property
Identify a logged-in user -> user_id (internal, non-personal)Key takeaways
- GA4 collects everything as events; sessions and users are derived.
- Use automatic, then enhanced, then recommended, then custom events — in that order.
- Parameters describe the action; user properties describe the person.
- An engaged session lasts over 10 seconds, has a key event, or has 2+ page views.
Check your understanding
Quick questions to lock in the lesson. They don’t count towards your certificate.
Put it into practice
Pick three events on a site you know and write, for each, the event name, three useful parameters and one user property that would help segment the analysis.
Enrol for free to save your progress
Reading is always free. Enrol to keep your place, take the final assessment and earn a verifiable certificate.