Article in English.
GA4 custom events record business actions that your current measurement does not describe adequately. Specify the trigger and necessary parameters, then verify the event before reporting it.
Define successful completion precisely
A click on a submit button can happen before validation or a server error. Choose a reliable success signal, test valid and invalid paths, and avoid placing personal data in event parameters. See contact-form conversion tracking for a focused example.
What Are GA4 Custom Events?
A GA4 custom event is an event you define to measure a specific interaction that isn't already covered by GA4's automatically collected or recommended events.
GA4 uses an event-based measurement model.
Instead of simply measuring page visits, events allow you to record actions users take on your website.
For example:
quote_requested
could represent someone submitting a quote request.
You could then attach parameters such as:
form_location = "homepage"
This gives you more useful information than simply knowing that an event occurred.
The basic structure is:
Event name → Event parameters → User action → GA4 report
GA4 Events vs Custom Events
Not every event you see in GA4 is a custom event.
GA4 broadly includes several types of events.
| Event type | Example | How it is collected |
|---|---|---|
| Automatically collected events | page_view | Collected automatically by GA4 |
| Enhanced measurement events | scroll, file_download, outbound clicks | Collected when relevant enhanced measurement options are enabled |
| Recommended events | Ecommerce and other standardized business events | Implemented according to Google's recommended event structure |
| Custom events | quote_requested, calculator_used | Defined specifically for your website or business |
The important SEO and analytics distinction is this:
Custom events are for actions that your business needs to measure but that aren't adequately represented by GA4's existing event collection.
Before creating a custom event, check whether GA4 already provides an appropriate event or whether Google recommends a standard event name for your use case.
When Should You Create a GA4 Custom Event?
You don't need a custom event for every interaction on your website.
Tracking everything can make your GA4 property difficult to understand and can make reporting more complicated.
A custom event is most useful when the action is:
1. Important to your business
For example:
- Quote requests
- Contact form submissions
- Appointment requests
- Product configurator usage
- Important downloads
- Phone clicks
2. Not already captured appropriately
If an existing GA4 event or recommended event already represents the interaction, use that structure where appropriate instead of creating another event that measures the same thing.
3. Something you'll actually analyze
Ask:
"Would we make a business decision based on this number?"
If the answer is no, the event may not need to exist.
Examples of GA4 Custom Events
Different businesses need to track different interactions.
Service business
A web design or professional services company might track:
quote_requested
contact_form_submitted
phone_clicked
pricing_page_viewed
E-commerce website
An online store might need more detailed event tracking around product interactions and purchasing behavior.
SaaS website
A software company might track:
demo_requested
trial_started
pricing_calculator_used
signup_completed
Content website
A content-heavy website might track meaningful interactions such as:
newsletter_signup
resource_download
video_completed
The important principle is to track business outcomes and meaningful user behavior, rather than creating an event for every possible click.
How to Set Up a GA4 Custom Event with Google Tag Manager
Google Tag Manager is one of the most practical ways to implement GA4 custom event tracking.
The basic workflow is:
User action → GTM trigger → GA4 event tag → GA4 event → reporting
Here's how to set one up.
Step 1: Define the Event You Want to Track
Start by deciding exactly what action should generate the event.
For example:
Track clicks on the "Request a Quote" button.
Define:
Event name:
quote_requested
Trigger:
A click on the relevant quote button.
Optional parameter:
button_location
This makes the tracking specification clear before you start building it.
Step 2: Create the Trigger in Google Tag Manager
Open your Google Tag Manager container and create a new trigger.
The trigger should match the exact interaction you want to measure.
For example, you could trigger an event when:
- A specific button is clicked
- A form is successfully submitted
- A particular link is clicked
- A specific page element is interacted with
For a button, you might use an appropriate CSS selector or another reliable element identifier.
Avoid creating triggers based on fragile selectors that could change whenever the website design is updated.
Step 3: Create the GA4 Event Tag
Create a GA4 event tag in Google Tag Manager.
Give the event a clear, consistent name such as:
quote_requested
Avoid inconsistent variations such as:
Quote Requested
QuoteRequested
quoteRequest
request_quote
Pick a naming convention and use it consistently.
Step 4: Add Event Parameters
Event parameters provide additional context about what happened.
For example:
event_name = quote_requested
button_location = homepage
Or:
event_name = resource_downloaded
resource_type = ebook
Parameters are useful because they allow you to analyze variations of the same event without creating separate events for every variation.
Instead of creating:
homepage_quote
services_quote
pricing_quote
you can potentially use:
quote_requested
with:
page_location
or another appropriate parameter.
This produces a cleaner analytics structure.
GA4 Event Naming Best Practices
Good event naming becomes increasingly important as your analytics implementation grows.
Use names that are:
- Clear
- Consistent
- Descriptive
- Lowercase
- Easy to understand
- Consistent with GA4's naming conventions
For example:
quote_requested
is much easier to work with than:
Quote Requested!!
or:
button1_click
Your event names should describe what happened, not simply how the website happened to implement the interaction.
Good examples
contact_form_submitted
quote_requested
demo_requested
calculator_used
phone_clicked
Poor examples
button_3
click1
homepageThing
blue_button_click
The better the event naming structure, the easier your GA4 reports will be to understand six months from now.
GA4 Event Parameters: What Are They?
An event parameter is additional information attached to an event.
For example:
Event:
quote_requested
Parameters:
form_location = homepage
service = web_design
The event tells you what happened.
The parameters tell you more about what happened.
This becomes especially valuable when you want to break down performance.
For example:
How many quote requests came from the homepage versus the services page?
Instead of creating two separate events, you can potentially track:
quote_requested
with a parameter such as:
page_location
or another relevant parameter.
This keeps your event structure simpler and more scalable.
Step 5: Test Your GA4 Custom Event in DebugView
Never assume an event works just because you published the GTM tag.
Test it first.
GA4's DebugView can help you verify that events are arriving correctly.
Perform the action yourself and check:
- Does the event fire?
- Does it fire once?
- Is the event name correct?
- Are the expected parameters present?
- Is the trigger firing on the correct page?
- Does the event fire when it shouldn't?
Testing is particularly important for forms and buttons because poorly configured triggers can fire multiple times.
Step 6: Publish Google Tag Manager
Once you've confirmed that the event works correctly in testing, publish the GTM container.
Then continue monitoring the event in GA4.
Don't immediately assume the implementation is perfect simply because the test worked.
Check the actual incoming data after deployment.
Step 7: Mark the Event as a Key Event
Not every custom event should be a key event.
A key event represents an action that is particularly important to your business.
For example:
Probably worth marking as a key event
quote_requested
contact_form_submitted
purchase
demo_requested
Probably not a key event
menu_opened
tab_clicked
image_viewed
footer_link_clicked
The exact events you designate depend on your business model.
The principle is simple:
Use key events for actions that represent meaningful business outcomes.
This keeps your conversion and performance reporting useful rather than turning every interaction into a "conversion."
Custom Events vs Key Events in GA4
These terms are often confused.
They are not the same thing.
Custom event
A custom event is an event you have defined to track a specific interaction.
For example:
pricing_calculator_used
Key event
A key event is an event that you've identified as an important business outcome.
For example:
quote_requested
A custom event can be marked as a key event if the action represents meaningful business value.
So:
Custom event = what you track
Key event = what you consider important
How to Track Button Clicks in GA4
Button-click tracking is one of the most common reasons businesses create custom events.
For example, you may want to track:
quote_button_clicked
or, if the click itself represents the actual lead action:
quote_requested
However, be careful about what the click represents.
A button click isn't necessarily a successful conversion.
For example:
"Submit Form" clicked
is not necessarily the same as:
"Form successfully submitted."
Where possible, track the actual meaningful outcome rather than simply tracking that a user interacted with a button.
How to Track Form Submissions in GA4
Form tracking is another common GA4 custom event use case.
For a contact form, a useful event might be:
contact_form_submitted
You could potentially add parameters such as:
form_name
form_location
The implementation should ideally fire after the form has successfully submitted rather than simply when someone clicks the submit button.
This distinction matters because a click can occur even when:
- Required fields are missing
- Validation fails
- The submission produces an error
- The user abandons the form
Accurate event tracking should represent the actual business action, not merely an attempted interaction.
Common GA4 Custom Event Mistakes
1. Tracking Everything
More events don't automatically mean better analytics.
If your property contains hundreds of vaguely defined events, it becomes harder to identify the numbers that actually matter.
Track actions that support real analysis.
2. Creating Duplicate Events
Before creating a custom event, check whether GA4 already collects the interaction or whether a recommended event is appropriate.
Duplicate tracking can produce confusing reports.
3. Using Inconsistent Event Names
Don't mix:
quote_requested
QuoteRequested
request_quote
quoteRequest
for essentially the same action.
Choose a naming convention and document it.
4. Tracking Clicks Instead of Outcomes
A button click isn't always a conversion.
If possible, track the completed action.
For example:
Better:
contact_form_submitted
Less useful:
contact_button_clicked
depending on the purpose of the button.
5. Not Using Event Parameters
Creating dozens of slightly different events can often be avoided by adding meaningful parameters.
For example:
resource_downloaded
with:
resource_name
can be more useful than creating a separate event for every downloadable resource.
6. Skipping DebugView
Always test your implementation before publishing.
A broken trigger can create incorrect data, and incorrect historical analytics data generally can't simply be "fixed" after the fact.
7. Marking Every Event as a Key Event
If everything is a key event, nothing is particularly useful as a business KPI.
Reserve key events for meaningful outcomes.
GA4 Custom Events Checklist
Before publishing a custom event, ask:
- Is this action important to the business?
- Does GA4 already collect it?
- Is there a recommended event that fits?
- Is the event name clear and consistent?
- Does the trigger fire at the correct point?
- Are useful parameters included?
- Does the event fire only once when appropriate?
- Have you tested it in DebugView?
- Should it be marked as a key event?
- Will someone actually use this data for reporting or decision-making?
If you can't answer why you need an event, you probably don't need to create it.
Frequently Asked Questions
What is a custom event in GA4?
A GA4 custom event is an event you define to measure a specific user interaction that isn't adequately covered by GA4's automatically collected, enhanced measurement, or appropriate recommended events.
How do I create a custom event in GA4?
Custom events can be implemented in different ways depending on your website and tracking setup. Google Tag Manager is a common approach: create a trigger for the user action, create a GA4 event tag, define the event name and parameters, test the implementation in DebugView, and then publish it.
Do I need Google Tag Manager to create GA4 custom events?
No. GA4 events can be implemented through different methods, including website code and Google Tag Manager. GTM is popular because it allows many tracking changes to be managed without modifying site code for every implementation.
What is the difference between a GA4 event and a custom event?
A GA4 event is a recorded user interaction. A custom event is an event you specifically define for your business or website when existing event collection doesn't adequately represent the interaction.
What is the difference between a custom event and a key event in GA4?
A custom event describes an interaction you've defined and tracked. A key event is an event you've identified as an important business outcome. A custom event can be marked as a key event when appropriate.
How many custom events should I create in GA4?
There is no universal ideal number. Focus on tracking meaningful actions that support business decisions rather than trying to maximize the number of events. A smaller, well-documented event structure is often easier to analyze.
How do I test custom events in GA4?
Use GA4's DebugView while performing the tracked action on your website. Confirm that the event fires correctly, fires at the appropriate time, and contains the expected parameters.
Why aren't my GA4 custom events showing up?
Common causes include an incorrect GTM trigger, a tag that isn't firing, an incorrect measurement configuration, browser or consent restrictions, implementation errors, or simply a reporting delay. DebugView is a useful first place to investigate.
Final Thoughts
GA4 becomes much more useful when it measures the actions that actually matter to your business.
Instead of simply asking:
"How many people visited my website?"
custom event tracking lets you answer questions such as:
"How many people requested a quote?"
"Which pages generated the most leads?"
"How often are visitors using our pricing calculator?"
"Which marketing channels generate the most valuable actions?"
The goal isn't to track every interaction.
The goal is to build a clean GA4 event tracking structure around meaningful business outcomes.
Start with the actions that matter most, use consistent event names, add useful parameters, test everything in DebugView, and only mark genuinely valuable actions as key events.
If your GA4 setup isn't currently tracking the actions that matter to your business, our team can help identify and implement the right custom events and key events.