Tracking lesson

GA4 Event Tracking: How the Event Model Actually Works

Nathan Hollis Nathan Hollis · · 10 min read
GA4 Event Tracking: How the Event Model Actually Works

GA4 event tracking works completely differently from Universal Analytics. There’s no Category, no Action, no Label. Every user interaction — a pageview, a scroll, a purchase — is just an event with a name and a set of parameters you attach to it. That single shift changes everything about how you instrument a site.

I’ve spent years migrating clients from UA to GA4, and the one thing that consistently trips people up isn’t the interface. It’s not understanding which type of event to reach for and when. Once that clicks, the whole model makes sense.

How GA4 Event Tracking Differs from Universal Analytics

Universal Analytics had six distinct hit types: pageviews, events, transactions, social, timing, and exceptions. Each had its own data model. Events specifically required you to fill in Category, Action, and optional Label and Value — a rigid structure that seemed logical until your team had ten people inventing their own conventions.

GA4 collapses all of that into one thing: events. A pageview is an event called page_view. A purchase is an event called purchase. A custom CTA click is whatever name you give it. Every event can carry up to 25 parameters providing context. That’s it.

Feature Universal Analytics GA4
Hit types 6 (pageview, event, transaction, etc.) Events only
Event structure Category / Action / Label / Value Event name + up to 25 parameters
Pageview tracking Separate hit type page_view event
E-commerce Separate module with fixed schema Built-in recommended events (purchase, add_to_cart, etc.)
Free-form metadata None (fixed fields only) Up to 25 custom parameters per event

The practical upside: you describe what actually happened rather than forcing it into arbitrary boxes. The practical downside: more flexibility means more rope to hang yourself with if you don’t establish naming conventions early.

The Four Categories of GA4 Events

GA4 organises events into four types based on how they’re created. Knowing which category to reach for first will save you hours of unnecessary custom work.

Type How they fire Examples Configuration needed?
Automatically collected Immediately on tag install first_visit, session_start, page_view, user_engagement None
Enhanced measurement Toggle in Data Stream settings scroll, click, file_download, video_start Toggle on/off per stream
Recommended events You send them; predefined schema add_to_cart, purchase, generate_lead, sign_up Must implement via gtag or GTM
Custom events You define name and all parameters cta_click, sidebar_expand, quote_request Full implementation required

The hierarchy here matters. Always check whether an automatically collected or enhanced measurement event already covers what you need before reaching for a custom implementation. In my experience, businesses often build elaborate GTM setups to track scroll depth — which enhanced measurement already handles out of the box.

Automatically Collected Events

These fire the moment your GA4 tag loads. first_visit triggers when someone visits your property for the first time. session_start fires at the beginning of each session. page_view runs on every page load (and on SPA virtual page changes if your tag is configured for it). You get this data with zero additional setup.

Enhanced Measurement Events

Enhanced measurement sits under Admin > Data Streams > your stream > Enhanced measurement. Toggle each option independently. Here’s exactly what each one tracks:

  • Scrolls — fires scroll when a user reaches 90% page depth. One threshold only; if you need 25%/50%/75%, you’ll need GTM.
  • Outbound clicks — fires click with link_url and outbound: true when users leave your domain.
  • Site search — fires view_search_results with the search_term parameter when GA4 detects a query string.
  • Video engagement — fires video_start, video_progress (at 10/25/50/75%), and video_complete for embedded YouTube videos with JS API support enabled.
  • File downloads — fires file_download when users click links to PDF, CSV, XLS, DOCX, ZIP, and other common document types.
  • Form interactions — fires form_start and form_submit. Reliability varies depending on how your forms are built; test before relying on this for conversion data.

For a full list of what enhanced measurement fires and the parameters it attaches, see Google’s enhanced measurement documentation.

Before building any custom tracking, spend five minutes in Admin > Data Streams > Enhanced Measurement. Tick everything applicable to your site, then check DebugView. You may already have what you need.

Recommended Events

Google publishes a recommended events list with predefined names and parameter schemas. Use them when they fit. purchase, add_to_cart, and begin_checkout unlock GA4’s e-commerce reports. generate_lead and sign_up feed predictive audiences. Custom event names don’t get those benefits.

Custom Events

Use custom events only when the recommended list genuinely doesn’t cover your use case. They’re fully flexible — you define the name, you define the parameters — but they don’t trigger any special reports in GA4. More on implementing them below.

Sending Events via gtag.js

If you’re using the GA4 tag directly (not through GTM), you send events with the gtag('event', ...) command. The syntax is straightforward:

// Basic custom event
gtag('event', 'cta_click', {
  button_text: 'Start free trial',
  button_location: 'hero_section'
});

// Recommended e-commerce event (add to cart)
gtag('event', 'add_to_cart', {
  currency: 'USD',
  value: 29.99,
  items: [{
    item_id: 'plan_pro',
    item_name: 'Pro Plan',
    price: 29.99,
    quantity: 1
  }]
});

The first argument is always the string 'event'. The second is your event name. The third is an object of parameters — key-value pairs that describe what happened. For recommended events, the parameter names are fixed by Google’s schema. For custom events, you choose them yourself.

The full gtag event reference is at developers.google.com/tag-platform/gtagjs/reference/events. Check it before naming parameters on recommended events — wrong parameter names mean the data lands but doesn’t feed the right reports.

Implementing GA4 Event Tracking via GTM

Google Tag Manager is the most practical way to implement custom GA4 events for most teams. It keeps code off your site, lets non-developers adjust triggers, and gives you a version history for every change.

The basic setup in GTM for a GA4 event tag:

  1. Create a new Tag with tag type Google Analytics: GA4 Event.
  2. Select your GA4 configuration tag (or enter the Measurement ID directly).
  3. Enter the event name — for example, cta_click.
  4. Add event parameters as rows: parameter name on the left, value or variable on the right.
  5. Assign a Trigger — a Click trigger on a specific element, a Scroll Depth trigger, a Custom Event trigger from a dataLayer.push(), etc.
  6. Use Preview to test before publishing.

A GTM dataLayer push for a custom event looks like this:

// Push from your site code when a specific action happens
window.dataLayer = window.dataLayer || [];
window.dataLayer.push({
  'event': 'cta_click',
  'button_text': 'Start free trial',
  'button_location': 'hero_section',
  'page_section': 'pricing'
});

In GTM, you’d then create a Custom Event trigger listening for cta_click, and a GA4 Event tag that fires on it — mapping the dataLayer variables to event parameters. This keeps your tracking logic decoupled from your site’s code.

If the data layer concept is new to you, the guide on what the data layer is and how it works explains the mechanics in plain language. Understanding it is fundamental to reliable GTM-based tracking.

Event Parameters and Custom Dimensions

Parameters are where GA4 gets genuinely powerful. Every event can carry up to 25 parameters that add context to what happened. For a cta_click event, you might send:

  • button_text: “Start free trial”
  • button_location: “hero_section”
  • page_path: “/pricing”

However, there’s a catch most people discover the hard way. Parameters only appear in Realtime and DebugView by default. To use them in explorations, standard reports, or audiences, you must first register them as custom dimensions.

To register a custom dimension:

  1. Go to Admin > Custom Definitions > Create Custom Dimension.
  2. Enter a display name (how it appears in reports).
  3. Set the scope to Event for event-level parameters, or User for user-level data.
  4. Enter the exact parameter name you’re sending in your events.
  5. Save.

Standard GA4 properties support up to 50 event-scoped custom dimensions and 25 user-scoped custom dimensions. That sounds like a lot, but teams that track aggressively hit those limits. Plan your parameters before implementing — wasted slots can’t be recovered without deleting existing dimensions.

For the full custom dimensions documentation, see GA4 custom dimensions and metrics.

Debugging with DebugView

DebugView is GA4’s real-time event inspector. It shows every event firing from a debug-enabled device as it happens, with all parameters expanded. Use it to verify your implementation before going live.

To enable debug mode:

  • GTM: Use Preview mode — it automatically adds the debug parameter.
  • Tag Assistant: Connect your site at tagassistant.google.com. It turns on debug mode for your own browser.
  • gtag.js directly: Add debug_mode: true to your event call during testing, then remove it before shipping.

DebugView is under Admin > DebugView. You’ll see events appear on a timeline as they fire. Click any event to expand its parameters. If a parameter is missing, it either wasn’t sent correctly or wasn’t registered as a custom dimension yet.

GTM Preview and DebugView are two different verification steps — GTM Preview confirms that a tag fired, but only DebugView confirms that GA4 actually received and processed the data. Both matter. The full documentation for DebugView is at support.google.com/analytics/answer/7201382.

Event Naming Conventions Worth Keeping

Naming is the thing that makes or breaks event tracking at scale. Inconsistent naming produces fragmented reports that nobody trusts. These are the rules I enforce on every implementation:

Rule Good example Bad example
snake_case always form_submit FormSubmit, form-submit
verb_noun format download_pdf, play_video pdf, video_was_played
Descriptive but concise newsletter_signup ns, user_signed_up_for_newsletter_from_homepage
No special characters add_to_cart add-to-cart!
Under 40 characters video_play user_clicked_play_button_on_video_player

Also maintain a tracking plan — a spreadsheet that lists every event, its parameters, the trigger condition, the business question it answers, and who requested it. I’ve watched more tracking implementations fail from poor documentation than from technical mistakes. The code is the easy part.

Build the tracking plan before the tags. One row per event, one column per parameter. It takes an hour and saves weeks of cleanup later.

What Belongs Here vs. What Belongs in Key Events

GA4 event tracking covers the full picture of what happens on your site: which events fire, what parameters they carry, how the event model works, and how to implement it. That’s this article.

Marking an event as a key event (what older docs called a “conversion”) is a separate step — you do it in Admin > Events by toggling an event as a key event. That designation affects how GA4 attributes value in reports and how conversions appear in your data. The specifics of that process, including which events to mark as key events and why, are covered in the guide to GA4 key events and setting up conversions.

Don’t confuse the two. An event fires data. A key event tells GA4 that this event represents a business goal. You need both, but they’re distinct concepts with distinct configuration steps.

Common Mistakes That Cost You Data Quality

After helping dozens of businesses with GA4 event tracking, the same problems come up repeatedly.

Building custom events before checking enhanced measurement

Enhanced measurement already handles scroll depth, outbound clicks, file downloads, site search, and YouTube video engagement. If you’re configuring GTM to replicate any of those, you’re doing double work and potentially producing duplicate events.

Forgetting to register parameters as custom dimensions

This is the most common one. You push button_location on every CTA click, then look for it in Explore and it’s not there. Parameters need to be registered in Admin > Custom Definitions before they surface outside Realtime and DebugView.

Inconsistent naming across team members or implementations

One developer writes button_click; marketing’s GTM container sends buttonClick; the agency adds btn_clicked. Now you have three events for the same interaction. Agree on a naming convention before anyone opens GTM.

Skipping DebugView verification

GTM Preview shows that a tag fired. It does not confirm that GA4 received the event with correct parameters. Always open DebugView and confirm the event appears there with the right parameter values before publishing a container.

GA4 Event Tracking: Putting It Together

GA4 event tracking replaces the rigid Category/Action/Label model with something genuinely more flexible. Every interaction is an event with a name and parameters. The four event types — automatically collected, enhanced measurement, recommended, and custom — form a hierarchy you should work through in order, from the least to the most implementation effort.

Here’s a practical starting sequence:

  1. Enable enhanced measurement in your Data Stream settings and verify what fires in DebugView.
  2. Check the recommended events list before naming any custom events — using Google’s predefined names unlocks built-in report integrations.
  3. Build a tracking plan documenting every custom event, its parameters, and its trigger condition before touching GTM.
  4. Implement via gtag or GTM, then verify in DebugView that parameters arrive correctly.
  5. Register custom dimensions for every parameter you need in reports.
  6. Mark business-critical events as key events following the process in the key events guide.

If you’re starting from scratch with GA4, the GA4 setup guide from zero to first report covers the full property configuration before you get to event tracking. And if you’re using GTM for implementation, the data layer guide is worth reading first — it explains the communication layer between your site and GTM that custom events depend on.

Start with what you have. Enhanced measurement covers more than most teams realise. Build from there only when you have a specific business question an existing event can’t answer.

First published . Last updated .

Nathan Hollis

Nathan Hollis

Analytics tutor · GA4 & GTM

Web analytics consultant with 15+ years of experience helping businesses turn raw data into actionable insights. Former analytics lead at digital agencies across the US, now focused on privacy-first tracking strategies.

More about me →