GA4 Custom Events: A Practical Guide to Tracking Key Actions on Your Website

Why Default GA4 Events Are Not Enough

Google Analytics 4 ships with a generous set of automatically collected and enhanced measurement events. Page views, scrolls, outbound clicks, file downloads—these are tracked out of the box the moment you install the GA4 tag. So why bother creating custom events at all?

Because every business is different.

If you run an e-commerce store, you probably need to know when a visitor uses your size-guide tool, applies a coupon code, or switches between product image galleries. If you manage a SaaS platform, you might want to track when someone copies an API key, toggles between pricing tiers, or opens the live-chat widget. None of these interactions are covered by GA4’s default events.

Custom events fill the gap between generic analytics data and the specific behavioral insights that drive revenue.

According to a 2024 survey by Databox, companies that track at least five custom events in GA4 report a 27% higher confidence level in their marketing decisions compared to those relying solely on default events. The reason is simple: when you measure what matters to your business, you make better choices.

In this guide, we walk through everything you need to know about GA4 custom events—from planning and naming conventions to implementation with real code and best-practice reporting.

Understanding the GA4 Event Model

Before diving into custom events, it helps to understand how GA4 organizes data. Unlike Universal Analytics, which relied on a hierarchy of hits (pageviews, events, transactions), GA4 uses a flat, event-based model. Everything is an event—including page views.

The Four Event Categories in GA4

Category	Description	Examples	Can You Modify?
Automatically collected	Tracked with no configuration	first_visit, session_start, user_engagement	No
Enhanced measurement	Toggled on/off in the GA4 interface	scroll, click (outbound), file_download, video_start	Toggle only
Recommended	Predefined names Google suggests you implement	login, sign_up, purchase, add_to_cart	Yes (parameters)
Custom	Events you create from scratch	coupon_applied, size_guide_opened, pricing_toggle	Full control

Custom events sit at the top of the flexibility spectrum. You choose the event name, define the parameters, and decide when and how the event fires.

Key Limits to Keep in Mind

• 500 distinct event names per property
• 25 parameters per event
• 50 custom dimensions and 50 custom metrics available for reporting
• Event names are case-sensitive (Add_To_Cart ≠ add_to_cart)
• Parameter values are truncated at 100 characters

These limits are generous for most websites, but they also mean you should plan carefully rather than track everything impulsively.

Planning Your Custom Event Strategy

The biggest mistake we see at Lueur Externe when auditing GA4 implementations is event sprawl—dozens of poorly named, overlapping events that clutter reports and confuse teams.

Before writing a single line of code, sit down and answer three questions:

1. What business outcomes matter most? (e.g., leads, sales, engagement)
2. What user actions directly influence those outcomes? (e.g., form submissions, add-to-cart clicks, video completions)
3. Which of those actions are NOT already covered by default or recommended events?

Only the actions that survive question three deserve a custom event.

Naming Conventions That Scale

GA4 event names must:

• Start with a letter
• Contain only letters, numbers, and underscores
• Be no longer than 40 characters

A proven naming pattern is object_action:

• coupon_applied
• size_guide_opened
• newsletter_subscribed
• chat_widget_clicked
• pricing_tier_toggled

This convention reads naturally in reports and scales well. Avoid vague names like click or event1—future-you will not remember what they mean.

Documenting Your Event Taxonomy

Create a simple spreadsheet (or Notion table) that records:

• Event name
• Description
• Parameters and expected values
• Trigger conditions
• Owner (who is responsible for this event)
• Date added

This living document becomes your single source of truth and prevents duplicate or conflicting events as your team grows.

Three Ways to Implement GA4 Custom Events

You have three main paths to create custom events. The best choice depends on your technical resources and workflow.

Method 1: Google Tag Manager (Recommended)

Google Tag Manager (GTM) is the most popular method because it separates tracking logic from your website’s codebase. Marketers can add, edit, and debug events without deploying code.

Step-by-step example: tracking a “Request a Quote” button click

1. In GTM, create a new Trigger of type Click – All Elements.
2. Set the trigger to fire when Click ID equals request-quote-btn (or use a CSS selector).
3. Create a new Tag of type Google Analytics: GA4 Event.
4. Select your GA4 Configuration tag.
5. Set the event name to quote_requested.
6. Add event parameters:
   • button_location → {{Page Path}}
   • product_category → use a Data Layer variable or DOM scraping
7. Attach the trigger to the tag.
8. Use Preview Mode to test, then publish.

GTM’s built-in Debug View and GA4’s DebugView report (Admin → DebugView) let you verify events hit GA4 correctly before going live.

Method 2: gtag.js (Direct Code)

If you prefer code-level control or don’t use GTM, you can fire events directly with the gtag() function.

// Example: Track when a user applies a coupon code
document.getElementById('apply-coupon-btn').addEventListener('click', function () {
  var couponValue = document.getElementById('coupon-input').value;

  gtag('event', 'coupon_applied', {
    coupon_code: couponValue,
    page_location: window.location.href,
    event_category: 'engagement'
  });
});

This approach is straightforward but has a downside: every change requires a code deployment. For fast-moving marketing teams, this can create bottlenecks.

Pro tip: If you use WordPress and are not comfortable editing theme files, plugins like Site Kit by Google or GTM4WP can bridge the gap. As a certified WordPress specialist, the team at Lueur Externe frequently configures these plugins to ensure clean data layer integration with zero code conflicts.

Method 3: GA4 Admin Interface (Create / Modify Events)

GA4 lets you create new events based on existing ones directly in the admin panel. For example, you could create an event called engaged_scroll that fires whenever the existing scroll event occurs and the percent_scrolled parameter equals 90.

Steps:

1. Go to Admin → Events → Create event.
2. Name the new event engaged_scroll.
3. Set matching conditions:
   • event_name equals scroll
   • percent_scrolled equals 90
4. Save.

This method requires no code and no GTM. However, it only works when you can derive the new event from data GA4 already collects. For truly new interactions (like a button click GA4 doesn’t know about), you still need GTM or gtag.js.

Registering Custom Parameters as Dimensions and Metrics

Here is a critical step many people skip: GA4 does not automatically include custom parameters in your reports. You must register them.

1. Go to Admin → Custom definitions.
2. Click Create custom dimension (for text values) or Create custom metric (for numeric values).
3. Enter the exact parameter name as you defined it in your event (e.g., coupon_code).
4. Choose the scope: Event (most common) or User.
5. Save.

It takes up to 24 hours for the new dimension or metric to populate in reports. Until then, you will see (not set).

Remember the limits: 50 custom dimensions + 50 custom metrics. Use them wisely.

Debugging and Validating Your Events

Nothing is worse than discovering three months later that your key event has been misconfigured from day one. Build validation into your workflow.

Real-Time Validation Checklist

• GA4 Realtime report: Events appear within seconds. Check the event name and parameter values.
• GA4 DebugView: Enable debug mode by installing the GA Debugger Chrome extension or adding debug_mode: true to your gtag config. DebugView shows a chronological stream of events per device.
• GTM Preview mode: Confirms the tag fires on the correct trigger and sends the right data.
• Browser DevTools → Network tab: Filter by collect?v=2 to see the raw GA4 payloads.

Common Pitfalls

• Case sensitivity: Quote_Requested and quote_requested are two different events, consuming two of your 500 slots.
• Reserved names: GA4 reserves names like first_open, app_remove, and ad_click. Using them will cause errors.
• Consent management: If your CMP blocks GA4 before consent, events may never fire for a significant portion of users. In the EU, this can mean losing 30–60% of event data if not handled properly.
• Parameter typos: A parameter named coupon_Code (capital C) will not match a custom dimension registered as coupon_code.

Turning Custom Events Into Actionable Reports

Data is only valuable if it reaches the people who make decisions. Here’s how to surface custom event data effectively.

Marking Events as Conversions

Any event in GA4 can be toggled as a Key Event (formerly called a Conversion). When you mark quote_requested as a key event:

• It appears in the Conversions report.
• It becomes available as a conversion in Google Ads for automated bidding.
• It can be used in Audience definitions for remarketing.

To do this, navigate to Admin → Events, find your custom event, and toggle the Mark as key event switch.

Building Exploration Reports

GA4’s Explorations (formerly Analysis Hub) allow you to build freeform, funnel, and path reports using your custom events and parameters.

For example, create a funnel exploration:

1. Step 1: page_view (on the pricing page)
2. Step 2: pricing_tier_toggled
3. Step 3: quote_requested
4. Step 4: purchase

This funnel instantly reveals where users drop off in your conversion journey—and which pricing tier toggle correlates with higher purchase rates.

Connecting to Looker Studio

For teams that need dashboards refreshed automatically, connect GA4 to Looker Studio (formerly Google Data Studio). Custom event counts and parameter breakdowns can be visualized alongside ad spend, CRM data, and other sources.

A well-built Looker Studio dashboard turns raw GA4 events into a decision-making tool that stakeholders actually use.

Real-World Example: E-Commerce Size Guide Tracking

Let’s walk through a complete, real-world implementation.

Scenario: An online fashion retailer notices a high return rate. They suspect customers are not using the size guide. They want to know:

• How many visitors open the size guide?
• On which product pages?
• Does using the size guide reduce returns?

Implementation (GTM + dataLayer):

// Push to dataLayer when size guide modal opens
document.getElementById('size-guide-trigger').addEventListener('click', function () {
  window.dataLayer = window.dataLayer || [];
  window.dataLayer.push({
    event: 'size_guide_opened',
    product_name: document.querySelector('.product-title').innerText,
    product_category: document.querySelector('.product-category').dataset.category
  });
});

GTM Configuration:

• Trigger: Custom Event → size_guide_opened
• Tag: GA4 Event → Event Name: size_guide_opened
  • Parameter product_name → Data Layer Variable product_name
  • Parameter product_category → Data Layer Variable product_category

GA4 Registration:

• Custom dimension: product_name (event scope)
• Custom dimension: product_category (event scope)

Analysis (after 30 days):

The retailer discovered that only 12% of visitors opened the size guide, but those who did had a 40% lower return rate. This insight led to a UX redesign that made the size guide more prominent—boosting usage to 31% and saving an estimated €18,000/year in return logistics.

This is exactly the kind of data-driven optimization that custom events enable.

Best Practices Checklist

Before you go, here is a condensed checklist to keep your GA4 custom event implementation clean and effective:

• ✅ Use the object_action naming convention
• ✅ Always check if a recommended event already exists before creating a custom one
• ✅ Document every event in a shared taxonomy spreadsheet
• ✅ Register custom parameters as dimensions/metrics in GA4 admin
• ✅ Test every event in DebugView before publishing
• ✅ Mark revenue-critical events as Key Events
• ✅ Review your event list quarterly and retire unused events
• ✅ Ensure your consent management setup does not silently block events
• ✅ Use Explorations and Looker Studio to surface insights for stakeholders
• ✅ Keep event names under 40 characters, lowercase, with underscores

Conclusion: Measure What Matters, Then Act on It

GA4 custom events are not just a technical feature—they are a strategic asset. When implemented thoughtfully, they transform your analytics from a passive data repository into an active decision-support system.

The key is intentionality. Don’t track everything. Track the actions that directly tie to your business goals, name them clearly, validate them rigorously, and build reports that turn data into decisions.

If this feels overwhelming, you are not alone. Properly configuring GA4—especially for complex e-commerce or multi-funnel websites—requires a blend of technical skill and strategic thinking. That’s where working with a specialized agency makes a real difference.

Lueur Externe, a web agency founded in 2003 and based in the Alpes-Maritimes, has been helping businesses across France and beyond build analytics setups that actually drive growth. From GA4 implementation and custom event strategy to full SEO and performance optimization, our certified team handles the complexity so you can focus on running your business.

Ready to get more from your analytics? Contact Lueur Externe for a free GA4 audit and discover which user actions you should be tracking—but aren’t—today.