Understanding GA4 Events: A Plain-English Explainer

By Emily Redmond, Data Analyst at Emilytics · April 2026

TL;DR: Events are actions users take. GA4 has automatic events (pageview, scroll, click) and custom events you define. Each event has parameters that add context. Understanding events is the foundation of GA4 tracking.

GA4 is event-driven. Everything—every interaction, every state change—is an event. If you don't understand events, you're lost in GA4. But they're simpler than they sound. This article breaks it down in plain English.

What Is an Event?

An event is something a user does, or something that happens on your site or app. Examples:

• Landing on a page (page_view)
• Scrolling down the page (scroll)
• Clicking a button (click)
• Submitting a form (form_submit)
• Playing a video (video_play)
• Purchasing an item (purchase)
• Closing the app (app_close)

In GA4's worldview, every interaction is an event. No distinction between "important" and "unimportant"—they're all events. You decide which ones matter by marking them as conversions.

Automatic Events

GA4 automatically collects certain events without any custom setup:

These are useful, but they're only the foundation. They tell you that something happened, but not why or what.

💡 Emily's take: I once audited a GA4 setup where someone relied entirely on automatic events. They knew users were scrolling, but not what content was engaging them. Custom events with parameters changed everything—suddenly they could see "users who watched >75% of the pricing page" or "users who hovered over the product demo." That's when GA4 becomes powerful.

Custom Events

A custom event is one you create to track something specific to your business. Examples:

• search_performed: A user searched for a product
• add_to_cart: A user added an item to their cart
• feature_used: A user used a specific feature
• video_started: A user clicked play on your own (non-YouTube) video
• error: A JavaScript error occurred
• chat_opened: A user opened the chat widget

To fire a custom event, you use code or Google Tag Manager:

Via Code (JavaScript)

gtag('event', 'add_to_cart', {
  item_id: '12345',
  item_name: 'Blue Widget',
  item_price: 29.99,
  quantity: 1
});

Via Google Tag Manager

1. Create a trigger (e.g., "Click on add-to-cart button")
2. Create a GA4 event tag with the event name (add_to_cart)
3. Add parameters (item_id, item_name, etc.)
4. Publish

Parameters: The Secret Sauce

An event parameter is a key-value pair that adds context to an event. Parameters are where GA4 gets powerful.

A basic page_view event tells you a page was visited. But a page_view event with parameters tells you:

Event: page_view
Parameters:
  - page_path: /pricing
  - page_title: Pricing Page
  - page_category: pricing
  - user_segment: premium
  - experiment_id: test_v2

Now you can filter: "Show me pageviews on the pricing page for premium users in the test group." Without parameters, that's impossible.

Standard Parameters (Built-In)

GA4 includes standard parameters automatically:

• page_path: The URL path
• page_title: The page title
• page_referrer: Where the user came from
• page_location: The full URL
• event_count: How many times this event has fired in the session

Custom Parameters (You Define)

You can add up to 25 custom parameters per event:

gtag('event', 'purchase', {
  transaction_id: 'txn_12345',
  value: 99.99,
  currency: 'USD',
  items: [
    {
      item_id: 'prod_001',
      item_name: 'Widget',
      price: 99.99,
      quantity: 1
    }
  ],
  coupon_code: 'SAVE20',
  shipping_address: 'New York'
});

Each parameter should have a clear name and value. item_name: 'Widget' is good; x: 'w' is useless.

Event Naming Conventions

Name your custom events clearly. Use snake_case (underscores, not spaces or dots). Examples:

✓ Good: video_play, form_submission, add_to_cart, feature_upgrade

✗ Bad: Video Play, form.submission, addToCart, x1

GA4 lets you use up to 40 characters. Use that space to be descriptive.

Recommended Custom Events (By Use Case)

For SaaS / Service Businesses

• demo_requested: User requested a demo
• pricing_viewed: User viewed the pricing page
• free_trial_started: User started a free trial
• subscription_upgraded: User upgraded their plan
• support_ticket_opened: User opened a support ticket

For Ecommerce

• product_viewed: User viewed a product detail page
• add_to_cart: User added item to cart
• remove_from_cart: User removed item from cart
• begin_checkout: User started checkout
• purchase: User completed a purchase
• wishlist_added: User added item to wishlist

For Publishers / Content Sites

• article_read: User finished reading an article
• video_completed: User watched full video
• newsletter_signup: User signed up for newsletter
• comment_posted: User posted a comment

For Apps

• onboarding_completed: User finished onboarding
• feature_used: User used a specific feature
• app_crashed: App crashed
• push_notification_clicked: User clicked a push notification

How to Fire a Custom Event: Step-by-Step

Let's say you want to track when someone clicks your "Book a Demo" button.

Option 1: Google Tag Manager (No Code)

1. Go to your GTM container
2. Create a Trigger:
   • Trigger type: Click
   • Some Clicks
   • Filter: Click text → contains → "Book a Demo"
3. Create a Tag:
   • Tag type: Google Analytics: GA4 Event
   • Event name: demo_requested
   • Measurement ID: (your GA4 ID)
   • Triggering: Apply the trigger you created above
4. Add Parameters (optional):
   • Parameter name: button_location | Value: homepage_header
5. Save and Publish

Visit your site, click the button, check GA4 Real-Time. You should see demo_requested fire.

Option 2: Direct Code (JavaScript)

document.querySelector('.book-demo-button').addEventListener('click', function() {
  gtag('event', 'demo_requested', {
    button_location: 'homepage_header',
    timestamp: new Date().toISOString()
  });
});

Or, if you're using a framework:

handleDemoClick = () => {
  gtag('event', 'demo_requested', {
    button_location: 'pricing_page_cta'
  });
  // Redirect to booking tool
  window.location.href = '/booking';
}

Viewing Events in GA4

In Real-Time

1. Go to GA4
2. Click Real-time (under Reports)
3. You see events firing in real-time
4. Expand an event to see its parameters

In Standard Reports

1. Click Reports → Events (under Engagement)
2. Select the event name
3. See event count, unique users, etc.

In Explorations

1. Click Explore (bottom of left sidebar)
2. Create a freeform report
3. Add event_name as a dimension
4. Filter or segment by events

Event Data Storage and Limits

GA4 stores event data with timestamps, parameters, and user information. A few important limits:

• Max 25 custom parameters per event (standard parameters don't count)
• Max 25 items per event (useful for purchases with multiple line items)
• Max 40 characters for custom dimension/metric names
• Event data kept for 2 months (user-level; you can extend to 14 months or export to BigQuery for unlimited)

Frequently Asked Questions

Q: If I fire the same custom event twice in one session, do both count? A: Yes. Each event fires independently. If a user clicks "Add to Cart" twice, you'll see two add_to_cart events. GA4 counts them separately.

Q: Can I change an event name after I've been collecting it? A: Not retroactively. If you realize you named an event signin when you meant sign_in, you can't rename the old data. Going forward, you fire the new event name. It's a fresh start for that event.

Q: What's the difference between event parameters and user properties? A: Event parameters are attached to a single event (that user's action right now). User properties are attached to the user (that user's account tier, location, etc.). Use parameters for action-specific data; use user properties for user-specific data.

Q: Can I fire events from my app and my website to the same property? A: Yes, if you use the same Measurement ID or Measurement Protocol. But best practice is to use the same property with separate data streams (one web, one app). This lets you segment by platform.

Q: How often can I fire the same event? A: As often as you want. No limits on frequency. If a user clicks a button 100 times, you'll see 100 events (though GA4 might sample them at massive scale).

The Bottom Line

Events are the language of GA4. Automatic events get you started; custom events make you powerful. Parameters turn events from "something happened" into "something specific happened to this user in this context."

Spend time thinking about which custom events matter to your business. Then implement them deliberately. The data you collect now determines the insights you can extract later.

Ready to track conversions? See How to Set Up GA4 Conversion Tracking (Step-by-Step).

Emily Redmond is a data analyst at Emilytics — the AI analytics agent that watches your GA4, Search Console, and Bing data around the clock so you never miss what matters. 8 years of experience helping founders and growth teams turn data noise into clear decisions. Say hi →