Event

A GA4 event is the atomic unit of measurement in Google Analytics 4 — a single recorded user interaction (page view, click, scroll, video play, purchase) carrying a name and up to 25 parameters. Unlike Universal Analytics, where pageviews were the primary hit type and events were a secondary category, GA4 reframes everything as an event: even page_view is just one event among many. This guide covers the four event types, parameter scoping, the 25-parameter limit, custom event setup, the line between an event and a conversion, and the most-asked questions about GA4 event tracking.

What Is an Event in GA4?

In GA4, an event is a structured data point representing one user action. Every event has a name (a verb-like label such as purchase or scroll) and an optional set of parameters that describe the interaction in more detail. GA4 collects events from web streams via the data layer and gtag.js, from app streams via Firebase SDK, and from server-to-server systems via the Measurement Protocol. Each event is tied to a client_id, a session, and a timestamp — the three values that let GA4 stitch interactions into user journeys.

The shift from Universal Analytics matters because the old model imposed a rigid category/action/label schema. GA4 throws that out. An event can describe anything you want it to describe, as long as you stay within reserved-name limits and parameter quotas. That flexibility is also the trap: without a naming convention, your event taxonomy becomes a graveyard of buttonClick, BUTTON_CLICK, and btn-click within six months.

The 4 Event Types — Automatic, Enhanced Measurement, Recommended, Custom

GA4 organizes events into four categories distinguished by who names them and who triggers them:

The hierarchy matters when you decide what to build. Automatic events cover account lifecycle. Enhanced measurement covers common engagement signals — toggle six switches in Admin → Data Streams → your stream → Enhanced measurement and GA4 starts collecting scrolls, outbound clicks, file downloads, video engagement, and form interactions for free. Recommended events cover industry use cases (ecommerce, lead gen, gaming) — Google publishes their parameter schemas in the recommended events reference, and using exact names unlocks ecommerce reports plus Google Ads bidding integrations. Custom events fill everything else.

The mistake to avoid: re-implementing a recommended event under a custom name. Naming your purchase event order_complete instead of purchase means GA4’s ecommerce reports stay empty and Google Ads can’t import the conversion. Always check the recommended events catalog before inventing a new name.

Event Parameters: User-Scoped vs Event-Scoped vs Item-Scoped

Parameters are the metadata attached to each event. GA4 has three parameter scopes, and choosing the wrong one is the most common source of broken reports:

• Event-scoped parameters attach to a single event instance — value, currency, page_location, video_percent. They describe the event itself.
• User-scoped parameters describe the user across all sessions — user_role, customer_tier, logged_in. Set them once and they persist. Implemented via gtag('set', 'user_properties', {...}) or the user_properties object in dataLayer.
• Item-scoped parameters live inside the items[] array on ecommerce events — item_id, item_name, item_category, price, quantity. Each cart line is a separate item object.

Why this matters: only event-scoped parameters can be registered as custom dimensions at the event level. User-scoped parameters need to be registered separately under user-scoped custom dimensions. Forgetting to register the dimension means the data flows into GA4 but never appears in reports — a silent failure that often goes unnoticed for weeks.

How to Create a Custom Event in GA4

You have three implementation paths, ordered from highest control to lowest setup cost:

1. Direct dataLayer push (best practice). Push the event server-side or from your app code immediately after the user action. The data layer is the source of truth — GTM and GA4 both read from it.

   dataLayer.push({
     event: 'demo_request',
     form_id: 'sidebar-cta',
     plan: 'pro',
     value: 0
   });

2. GTM tag with a custom event trigger. Configure a GA4 Event tag (Tag type → Google Analytics: GA4 Event), set the event name to demo_request, map dataLayer variables into event parameters, and trigger on Custom Event matching demo_request.
3. Modify event in GA4 UI (no-code, last resort). Under Admin → Events → Create event, you can derive a new event from existing ones (e.g., create contact_us when page_view matches a thank-you URL). Useful for quick wins, but harder to maintain than dataLayer-driven events.

After firing the event, register any parameters you want to see in reports as custom dimensions (Admin → Custom definitions → Create custom dimension). Without registration, parameters reach GA4 but cannot be used in Explore or standard reports.

Event vs Conversion — When to Mark an Event

Every conversion is an event, but not every event is a conversion. A conversion (called a key event in the GA4 UI as of 2024) is an event you have explicitly designated as a high-value business outcome by toggling Mark as key event under Admin → Events. The toggle is what unlocks attribution reports and Google Ads bidding integration.

The decision rule is simple: keep 3 to 5 key events tied to revenue or qualified leads (purchase for ecommerce, generate_lead for B2B, sign_up for SaaS), and keep everything else as regular events for diagnostics. Marking too many events as conversions waters down attribution, inflates Google Ads bid signals, and makes channel-performance reports unreadable. The split between high-value macro conversion goals and engagement-level micro conversion signals belongs in your reporting layer, not your conversion list.

The 25-Parameter Limit and How to Stay Within It

GA4 caps registered event parameters at 50 event-scoped custom dimensions and 25 user-scoped custom dimensions per property. Each event can carry up to 25 parameters, plus the standard parameters Google reserves (page_location, page_referrer, session_id, etc.). Exceed the cap, and the additional parameters are silently dropped.

Five rules to stay within budget:

1. Don’t register everything. Only register parameters you’ll actually use in reports. If cta_color never appears in an Explore, leave it unregistered.
2. Reuse parameter names across events. One form_id dimension works for form_start, form_submit, and form_error — it counts as one slot, not three.
3. Use user properties for stable traits. user_role belongs in user properties (set once), not in every event.
4. Audit registered dimensions quarterly. Admin → Custom definitions shows usage. Archive what nobody queries.
5. Reserve 5 slots for ad-hoc debugging. When you need to track a one-off campaign parameter, you’ll thank yourself.

Event Tracking Implementation: dataLayer / GTM / Measurement Protocol

Pick the path that matches your stack:

• dataLayer push (Shopify, WooCommerce, custom CMS). The cleanest pattern. Your application pushes events directly. GTM (or gtag.js) consumes them and forwards to GA4. Source of truth is your code, not the analytics UI.
• GTM tag (marketing-led setups). Triggers fire based on URL patterns, click classes, or form submissions. Useful when developers can’t deploy. Less robust than dataLayer because triggers can break when site markup changes.
• Measurement Protocol (server-side). Send events directly from your backend to GA4 via HTTPS POST. Required for offline conversions, cross-device stitching, and payment redirects where the user never reaches a thank-you page. See the Measurement Protocol reference for the request format.
• gtag.js direct (no GTM). Call gtag('event', 'event_name', {...}) from page scripts. Fastest to ship, hardest to maintain at scale.

For most non-trivial sites, the right answer is “dataLayer + GTM” — the application code stays clean, the analytics team controls what fires when, and your data stream stays consistent across web and app.

Common Custom Events — Recipes

Three custom events worth implementing on almost any content site:

1. Form submit (when not auto-captured by Enhanced Measurement):

// On successful AJAX form response
dataLayer.push({
  event: 'form_submit',
  form_id: 'contact-sidebar',
  form_destination: 'sales',
  value: 25
});

2. Video play (for self-hosted players, since Enhanced Measurement only catches embedded YouTube):

videoElement.addEventListener('play', () => {
  dataLayer.push({
    event: 'video_play',
    video_title: 'product-tour',
    video_duration: 184
  });
});

3. Scroll depth at custom thresholds (Enhanced Measurement only fires at 90%):

// Fire on 25, 50, 75, 100 percent
dataLayer.push({
  event: 'scroll_depth',
  scroll_percent: 75,
  page_path: window.location.pathname
});

For the deeper pattern — why custom thresholds beat the default and how to wire them into engagement reports — see the scroll-depth tracking playbook. The add to cart event follows the same recipe pattern with the recommended ecommerce schema, and the purchase event closes the funnel. For a wider catalog of patterns, see custom events.

Frequently Asked Questions

Related Terms

• Conversion — events explicitly marked as key business outcomes
• Purchase event — the canonical ecommerce conversion event
• Add to cart event — mid-funnel ecommerce engagement signal
• Custom events — your own event names for site-specific actions
• Data layer — the structured object that feeds events to GA4 and GTM
• Measurement Protocol — server-to-server event delivery for offline and backend tracking
• Data stream — the GA4 collection endpoint for web, iOS, or Android
• Macro conversion — high-value primary key events
• Micro conversion — engagement-level signals that feed macro funnels
• Scroll-depth tracking — custom event recipe for engagement beyond the 90% default