Web Analytics with Google Analytics 4The GA4 data model · Lesson 4 of 20

Events, parameters and user properties

Article · 11 min · 8 min lecture

Video lecture

Events, parameters and user properties

15 chapters · about 8 min · full transcript

Coming soon

Chapter 1 of 15

Events, parameters, user properties

  • Everything is an event
  • Parameters versus user properties
  • Four families of events
  • Engagement definitions
  • A peek at the raw export

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

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

FamilyHow it is collectedExamples
Automatically collectedSent by the Google tag or SDK by defaultfirst_visit, session_start, user_engagement
Enhanced measurementToggled in the web data streampage_view, scroll, click (outbound), file_download, view_search_results
RecommendedYou implement, using Google's predefined namessign_up, generate_lead, purchase
CustomYou implement with your own namescalculate_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:

  1. scroll events by page — do readers reach the sign-up box near the bottom?
  2. A custom view_signup_box event (fired when the box enters the viewport) versus sign_up — is the problem visibility or persuasion?
  3. The sign_up event's method parameter — 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 value on 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.

  1. A user selects the 'Pro' plan on the pricing page. They are currently on the free plan. How should each fact be stored?
  2. In GA4, what is bounce rate?
  3. A developer sends a custom parameter, but it does not appear in explorations. What is the most likely reason?

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.