Events in Google Analytics 4: goals and conversions

Google Analytics 4 shows where visitors come from, what pages they view, and what they do on the site. However, to evaluate SEO and advertising results, regular visitor statistics are not enough. You need to understand how many users submitted a request, registered, added a product to their cart, or completed a purchase.

For this purpose, GA4 uses events and key events, previously often referred to as goals and conversions. Let's explore how event tracking works in Google Analytics 4, which actions should be recorded, and how to set up data collection through the analytics interface, Google Tag Manager, or gtag.js.

What are events, goals, and conversions in Google Analytics 4?

Google Analytics 4 uses an event-based data model. Each user interaction that the system can recognize or that a specialist has configured is recorded as a separate event with a name and a set of parameters.

The interface contains three related concepts: Event, Key Event, and Conversion. These concepts serve different purposes, so when setting up analytics, it's important to understand which actions are sufficient to track, which are considered key, and which are useful for advertising optimization.

What is an Event in GA4?

An event in Google Analytics 4 is a record of a specific user action or application state. For example, when a page is opened, a page_view event is sent, when a page is scrolled to a set threshold, a scroll event may be recorded, and when a successful registration occurs, a sign_up event is recorded.

Each event contains an event_name and, if necessary, additional parameters. For the purchase event, you can pass the order price, currency, and product list, while for the contact_click custom event, you can pass the contact type or button location.

GA4 events help analyze visitor behavior on individual pages and throughout the user journey. They help you understand which content leads to conversions, at what stages of the checkout process people abandon their orders, and which interface elements are used most often.

What is a Key Event?

A key event is an action that a company attaches particular importance to. For an online store, this is typically a purchase; for a service website, it's a successful application; for an online service, it's registration or a paid subscription.

In Google Analytics 4, an event can be marked as a key event, after which its data will be used in the corresponding metrics and reports. However, the original event sending logic remains unchanged: the system continues to receive information about user actions.

It's best to select key events after defining business goals. If you mark every button click, scroll, and page view, your reports will include many actions that don't reflect the actual number of requests or sales.

What is the difference between a key event and a conversion?

In current Google terminology, key events are used to evaluate valuable actions in GA4. Google Ads conversions are used to measure the results of advertising campaigns and, if configured accordingly, to manage automated bidding strategies.

Previously, Google Analytics used the term “conversion” for events considered particularly important. Following the terminology update, these actions were renamed Key Events, although older guidelines and search queries still frequently use the old term.

This difference affects reporting settings. An event can be recorded in GA4 without being considered a key event, and a key event doesn't necessarily have to be used as a signal for optimizing advertising campaigns.

What is the relationship between an event, a key event, and a Google Ads conversion?

Let's imagine a law firm's website where a user fills out a consultation form. After a confirmed submission, the site sends the generate_lead event, and the specialist marks it as key in GA4.

If a company runs an ad, this event can be used to create a conversion in Google Ads. The ad account can then track the corresponding user actions according to its attribution and measurement settings.

The measurement scheme is as follows:

User Action → Event → Key Event → Conversion in Google Ads

This sequence describes a typical setup scenario, although it's possible to create an ad conversion based on an event that wasn't initially a key event. In this case, Google may automatically mark the original event as a key event.

How are GA4 events different from Universal Analytics goals?

In Universal Analytics, measurement was built around sessions, pageviews, and goals. Google Analytics 4 uses events, allowing user actions to be analyzed in a unified structure along with additional dimensions.

Search queries like “Google Analytics goals”, “гугл аналитика цели”, and “Google Analytics goal creation” remain common. However, when working with GA4, you should focus on events and Key Events, as the previous Universal Analytics goal creation interface no longer exists.

What goal types were used in Universal Analytics?

In Universal Analytics, you could create a goal based on a visit to a specific URL, session duration, number of pages viewed, and the completion of a specific event. For example, visiting a thank-you page after submitting a form was considered a goal completion.

Events used a structure consisting of a category, action, label, and an optional value. Configuration required defining the conditions under which an action would be matched to the corresponding goal, and then verifying that it was logged in reports.

In GA4, similar scenarios are implemented through events and parameters. Specifically, viewing the thank-you page can be separated into a separate event and then marked as a key event.

What do Event Category, Event Action and Event Label mean?

In Universal Analytics, the Event Category, Event Action, and Event Label parameters described different interaction characteristics. For example, the category might be called Form, the action might be Submit, and the label might be Contact.

The old code and documentation often use the terms eventaction, eventlabel, event label, and ga event action. These are all related to the previous way of organizing events and help us understand how analytics was structured on the old site.

GA4 doesn't have a mandatory Category / Action / Label structure. Instead, it uses the event name and a set of parameters that can be selected for a specific measurement task.

How to pass Event Action and Event Label in GA4?

When migrating an old setup, you need to determine what information the Event Action and Event Label contained. The corresponding values can then be passed to GA4 via custom event parameters, preserving useful detail.

For example, for the form_submit_success event, you can use the form_name parameter with the value “consultation”. This will allow you to differentiate between different forms without creating a separate event for each button, if this level of detail meets your reporting needs.

If your site uses the old gtag call with parameters similar to Event Label, you should check it before migrating. A parameter named event_label can be sent as a custom parameter, but it won't automatically be included in the standard Universal Analytics report.

What event types are there in Google Analytics 4?

Events in Google Analytics 4 are divided into automatically collected, enhanced measurement events, recommended, and custom. The difference between them depends on how they are configured and whether Google has a standard name for a specific action.

Before adding custom tracking, it's a good idea to check the data already incoming. Some events are collected after the tag is installed, so re-sending them via GTM can result in duplicate data.

Automatically collected events

Once the Google tag is installed correctly, the system begins collecting basic website interaction data. This includes first_visit, session_start, page_view, and user_engagement, which help analyze visits and user activity.

For example, session_start records the start of a session, and first_visit is recorded when a user first visits the site, as determined by available identification methods. The user_engagement event is associated with the time of active interaction with the site or application.

For such events, you don't need to create a separate tag for each action. However, you should verify the accuracy of data collection after installing analytics, especially if multiple tag management systems are running on the site simultaneously.

Enhanced Measurement Events

Enhanced Measurement allows you to track additional interactions without separately configuring each event in your code. Depending on the features enabled, GA4 can collect data on page scrolling, site searches, file downloads, outbound clicks, and video interactions.

This group includes scroll, click, file_download, view_search_results, and some form interaction events. The actual data set depends on the stream settings and the specific implementation of the site elements.

For example, the standard scroll event for a web stream detects when the user reaches a threshold of approximately 90% of the page's vertical depth. If you need to analyze multiple scroll levels, you'll need to configure additional events and pass the appropriate parameters.

Google Recommended Events

Google provides a list of recommended event names for common user actions, including login, sign_up, generate_lead, add_to_cart, begin_checkout, and purchase.

These events are convenient for registration, lead generation, and e-commerce. When setting them up, it's important to follow the recommended parameter names, as they affect the accuracy of some standard metrics and reports.

For example, a purchase requires transmitting a transaction ID and product information. Sending only an event named “purchase” may result in incomplete order content and revenue data.

Custom Events

Custom events are created for actions that don't have a suitable standard Google name. For example, a website might track the selection of a plan, opening a calculator, or navigating to a specific section of the dashboard.

It's advisable to agree on the names of such events before implementation to prevent identical actions from being passed under different identifiers. For plan selection, you can use plan_selected, with the specific plan passed as a separate parameter.

The clearer the event names and parameters, the easier it is to analyze events months later. Unified rules are especially useful for sites with multiple forms, language versions, and different traffic sources.

How are GA4 event names and parameters structured?

Each event has a name that Google Analytics 4 uses to identify the type of action recorded. Additional parameters indicate where the interaction occurred and what characteristics should be recorded for subsequent analysis.

For large sites, it's helpful to create an event dictionary in advance, containing names, sending conditions, and required parameters. Such a document reduces the risk of inconsistent settings between the marketer, developer, and web analyst.

What is event_name in Google Analytics 4?

event_name – the name of the event that is sent to GA4 along with its data. For example, the system receives “purchase” after a purchase or “generate_lead” after a successful form submission.

Names are case-sensitive, so Form_Submit and form_submit will be different. For custom events, it's best to use lowercase Latin letters and underscores, avoiding spaces and non-standard characters.

Google limits event names to 40 characters, and some names are reserved for system purposes. Before implementing, please check the directory of recommended events and avoid creating your own name where a standard one is suitable.

What are event parameters used for?

Parameters add information to the registered action. For example, page_location contains the page address, page_title contains its title, and method can describe the registration or authorization method.

For e-commerce events, value, currency, transaction_id, and items are used. These parameters provide analytics with the purchase price, currency, order ID, and information about the purchased items.

The event name and parameters serve different purposes. The event_name identifies the action that occurred, while additional fields help understand its circumstances and compare results across pages or user segments.

When are Custom Dimensions needed?

Let's say a website sends a contact_click event along with a contact_type parameter. This value can indicate the user's preferred contact method: phone, email, or instant messaging.

To use most custom parameters as separate dimensions in standard GA4 reports and explorations, they must be registered in the custom definitions section. Passing a value in an event does not guarantee that the dimension will be available in the interface.

To register, specify the dimension name, scope, and exact parameter name. After configuration, new data is processed for subsequent analysis, so don't expect automatic restoration of all past history.

How to properly create a list of events for a website?

It's best to start with a list of actions that are truly necessary to evaluate the site's performance. Then, for each event, define a name, sending condition, parameters, and verification method.

For example, for a corporate website you can prepare the following plan:

This list becomes the basis for technical configuration and subsequent testing. It's useful to keep it up to date when changing forms, buttons, and business processes.

How to create an event in Google Analytics 4 without coding?

Some events can be configured directly in the Google Analytics 4 interface. This method is suitable when a new action is determined by an existing event and its parameter values.

For example, a site can send a standard page_view, and GA4 will create a separate event based on it when visiting the confirmation page. For complex interactions that analytics doesn't yet capture, GTM or custom code will be required.

What is required to set up an event?

Before adding an event to Google Analytics, you need to ensure the Google tag is installed on your website and the data stream is running. You can check the data stream in the real-time report or through DebugView.

Creating and editing events also requires appropriate access rights to the GA4 property. If the relevant interface elements are unavailable, check the user role and the selected property.

Before setting up, it's a good idea to define the event name, its conditions, and the expected result. For example, for a request, you need to know exactly whether a separate page opens after submission or whether a confirmation appears without a reload.

How to create a new event through the GA4 interface?

To create an event based on existing data, open the admin section and navigate to events. The current Google Analytics 4 interface allows you to create events without coding and with advanced conditions.

Sequence of actions:

1. Open the desired Google Analytics 4 property and go to “Admin”.
2. In the View Data section, select Events and click Create Event.
3. Enter a name for the new event and select an available creation method.
4. Specify the original event and the conditions under which its new version should be created.
5. Check the parameters and save the settings, then perform a test action.

New events may not appear in different interface tables simultaneously. After saving, you should verify their actual arrival, as the created rule alone does not confirm correct tracking.

How to create an event for the thank you page?

Let's say, after submitting a form, the site redirects the user to the /thank-you/ page. In this case, you can create a generate_lead event based on the view of this page.

In the conditions, select the source event page_view and specify the page address via the page_location parameter. For multiple similar URLs, use the appropriate comparison condition or regular expression.

After saving, check that the test form is submitted and the thank-you page is opened. If the user can refresh this page or return to it via a direct link, additional views can create repeat events, so for accurate lead counting, it's best to use confirmation of successful form processing.

Why can't we just mark all page_views as key events?

The page_view event is typically sent when a website page is viewed. If you mark it as a key event without any additional conditions, every registered page view will be counted as a significant action.

For a website with several thousand views, this will lead to inflated statistics for key events. Estimating the number of applications, registrations, or orders based on this metric will be impossible.

It's better to create a separate event for the required URL or send a confirmed action from the site's logic. After that, mark the specific event as the key event, leaving the standard page_view for visitor analysis.

How to set up GA4 events via Google Tag Manager?

Google Tag Manager allows you to manage tags and their triggering conditions without constantly editing your website's source code. Once the container is installed, many tasks can be performed through its interface.

Setting up Google Analytics events via GTM is especially useful for tracking buttons, forms, and user interactions. However, the available triggers should match the actual behavior of the site elements.

How to create a GA4 Event tag?

First, check that the Google tag for the desired GA4 property is configured in the GTM container. The web stream measurement ID has the format G-XXXXXXXXXX and is used when setting up data transfer.

To create a separate event, open the container workspace and follow these steps:

1. In the Tags section, click Create and open the new tag settings.
2. Select the “Google Analytics: GA4 Event” type and specify the measurement ID.
3. In the Event Name field, enter the name of the event, for example contact_click.
4. If necessary, add parameters to be passed along with the event.
5. Connect the trigger, save the changes and test the tag in preview mode.

Older guides may use the GA4 Configuration tag. The Google tag is now used for basic installation, so when reusing older instructions, be aware of the interface changes.

How to set up a button press trigger?

Let's imagine a website has a “Book a Consultation” button with a unique CSS class. To track clicks, you can create a Click – All Elements trigger and limit it to a condition based on Click Classes or Click ID.

For example, the condition “Click Classes contains consultation-button” will register an interaction with the desired element. Before configuring, be sure to check the HTML markup, as the same classes may be used on multiple buttons.

GTM also provides Click Text, Click URL, and other click characteristics. However, button text often changes after page redesigns or translations, so a stable identifier is usually more reliable for technical tracking.

How to track form submission via dataLayer?

To track successful form submission, it's convenient to use the dataLayer. The developer can send an event when the server confirms receipt of the form, after which GTM fires the appropriate GA4 tag.

Example of data transfer after a confirmed server response:

window.dataLayer = window.dataLayer || [];

window.dataLayer.push({
  event: 'lead_form_success',
  form_name: 'consultation'
});

In GTM, create a Custom Event trigger named lead_form_success and then link it to the generate_lead tag. The form_name value is passed via a data layer variable and the corresponding event parameter.

This setting allows you to distinguish between successful requests and failed form submissions. For reliable operation, it's necessary to prevent resending the event when a repeated response is received or the interface state changes.

How to handle AJAX forms without reloading the page?

AJAX forms submit data without the usual page navigation. Therefore, the standard Form Submission trigger may not reflect the processing result, especially if the application intercepts the submit event and displays its own notifications.

For such forms, it's best to record a successful server response or other reliable confirmation of request acceptance. The application then transmits the event via the dataLayer, and GTM sends it to GA4.

If you only track Submit button clicks, analytics may count an inquiry even if required fields are empty or a server error occurs. Therefore, before publishing, you should test successful submission, invalid data, and repeated clicks.

How to send events via gtag.js?

The gtag.js library allows you to send events to Google Analytics directly from your website's JavaScript code. This method is suitable when the developer controls the application logic and can send an event after a confirmed action.

When setting up directly, it's important to check existing tags beforehand. Sending the same event simultaneously through gtag.js and GTM without consistent logic can result in data duplication.

How does the gtag('event') command work?

To send an event, use the gtag('event', ...) call, specifying the event name and additional parameters. For example, after successfully submitting a form, you can pass generate_lead.

gtag('event', 'generate_lead', {
  method: 'website',
  form_name: 'consultation'
});

In this example, generate_lead denotes the action, method describes how the lead is generated, and form_name specifies the form. The custom parameter can be registered as a custom dimension for subsequent analysis.

The command should be called only after the desired action has completed. If you place it in a button click handler without checking the result, events will be logged even if the send attempt fails.

How to set up page_view event via gtag?

The page_view event is typically sent automatically when the page loads if the Google tag is configured in the standard way. Additional manual sending may be necessary for apps with non-standard navigation.

Example of manual call:

gtag('event', 'page_view', {
  page_title: document.title,
  page_location: window.location.href
});

In this case, the current title and the full page URL are transmitted. Before implementing, check whether Google Analytics sends a similar event automatically.

Manually managing page views is especially important for SPA applications, where the URL changes without a full document reload. However, just because you're using React, Vue, or Next.js doesn't mean automatic tracking won't work properly.

How to avoid double page_view on SPA sites?

Duplicates can occur when a site manually sends a page_view, and GA4 simultaneously records the page view when the page loads or the browser history changes. This results in inflated page views in reports.

For manual control in the Google tag configuration, you can use send_page_view: false. However, this setting disables automatic sending when the tag is configured accordingly and does not necessarily disable views generated by modifying browser history via Enhanced Measurement.

Therefore, it's necessary to check both settings and select a consistent method for recording page views. For SPAs, you should separately test page opening, internal link clicks, browser “Back” and “Forward” buttons, and refreshing the current URL.

What user actions should be tracked in GA4?

The choice of events depends on the type of website and the business objectives. For an online store, purchases and checkout steps are particularly important, while for a service website, it's applications, inquiries, and interactions with contact elements.

Not every user action needs to be turned into a key event. Some events are useful solely for behavior analysis, identifying interface issues, and evaluating the user journey.

Submitting forms, applications and registrations

For a service website, the main event is usually the confirmed submission of a feedback form. This action can be tracked using generate_lead and supplemented with parameters indicating the request type.

sign_up is used for user registration, and login is used for account login. If the site supports multiple authorization methods, the corresponding information can be passed via the method parameter.

When evaluating form effectiveness, it's helpful to separately track the initial interaction and successful submission. This will help you understand how many visitors open the form and how many actually complete the action.

Clicks on phone, email and buttons

On mobile websites, users often click a link with the tel: prefix to initiate a call. This interaction can be tracked using GTM and the contact_click event, passing the value contact_type=phone.

Clicks on mailto:, messenger links, and contact buttons can be tracked in a similar way. This data helps us understand which methods of communication visitors prefer on different pages.

However, clicking on a phone link does not confirm the conversation took place. Analyzing real calls will require integration with call tracking, which provides additional information about calls and their results.

Online store purchases and actions

For e-commerce, Google Analytics 4 supports events that reflect key purchase stages. These include view_item, add_to_cart, begin_checkout, add_payment_info, and purchase.

By passing these events with appropriate parameters, you can analyze user flow from the product page to checkout. For example, a high number of additions to cart with a small number of purchases indicates the need to review the checkout process.

The accuracy of revenue and product data requires special attention. If a purchase event is sent multiple times or the price is transmitted in an incorrect format, reports may show incorrect results.

What parameters are needed for purchase?

The purchase event requires information to identify the order and determine its contents. The standard implementation uses transaction_id, value, currency, and the items array.

Example of data structure:

gtag('event', 'purchase', {
  transaction_id: 'ORDER-1052',
  value: 2500,
  currency: 'UAH',
  items: [{
    item_id: 'SKU-125',
    item_name: 'Product',
    price: 2500,
    quantity: 1
  }]
});

In this example, the price is transmitted as a number, and the currency is specified separately in ISO 4217 format. The transaction_id must correspond to a specific order and remain the same when transmitting information about the same purchase again.

The set of actions tracked will vary for each type of website. Below is a sample framework that can be used when creating an analytics plan.

When setting up e-commerce, it's important to carefully check order IDs, product listings, and purchase amounts. Errors in these data can impact revenue calculations and advertising campaign evaluations.

How to set up goals and key events in GA4?

In the old Google Analytics terminology, goals were used to measure important visitor actions. In GA4, these tasks are accomplished through events and the Key Event mark.

Therefore, setting up goals in Google Analytics 4 begins with checking the event itself. You need to ensure it's being sent to the right property, triggered under the right conditions, and contains the required parameters.

How to mark an event as a Key Event?

Once an event appears in GA4, you can select it in the event management section and mark it as a key event. In the current interface, this setting can also be accessed directly when creating an event.

The general procedure is as follows:

1. Open “Admin” and go to the “Events” section.
2. Find the event you need or create a new one if it hasn't been set up yet.
3. Enable the “Mark as Key Event” option.
4. If necessary, check the calculation method and the value of the key event.
5. Save the settings and perform a test action on the site.

After changing the setting, the event will be considered a key event for the corresponding new actions. If you need to analyze a previous period, please remember that a new mark does not automatically recalculate all historical statistics.

How to set up a key event based on specific conditions?

Sometimes a website uses a single event for multiple forms or actions. For example, form_submit_success might be sent after a consultation request, downloading a commercial proposal, or subscribing to a newsletter.

If you only want to consider a consultation request as a key event, you can create a separate event based on the source event and the form_name parameter. The condition should check for a specific value, such as “consultation”.

After creating the separate event, it's marked as a key event, while the original event is retained for general form statistics. This approach helps maintain detailed analytics and avoid mixing different actions into a single metric.

Which events should be considered primary and which secondary?

Macro conversions are typically associated with the achievement of a primary business goal: a purchase, a confirmed application, a service booking, or a subscription. These actions are most often used to measure commercial results.

Microconversions reflect intermediate steps: downloading a file, viewing pricing plans, clicking a button, or starting a form. They help study user behavior and identify problem areas on the site.

Lead SEO specialist — Gennady

In my practice, I often encounter websites with Google Analytics 4 already installed, but the actual results of their promotions are impossible to measure. The reports show visits, views, and clicks, but successful form submissions or purchases are not tracked.

I recommend starting by identifying three to five key actions that drive business results. After that, you need to ensure that each action is sent only once, contains the necessary parameters, and is correctly displayed in GA4. This approach helps you evaluate the amount of SEO traffic and its impact on your business.

How to transfer Google Analytics 4 conversions to Google Ads?

Connecting GA4 with Google Ads helps you use data on important user actions to evaluate advertising campaigns. Events already collected on your website can be used to create conversion actions in your advertising account.

Before connecting, please verify that events are valid and eliminate duplicates. Tracking errors can impact conversion rates and automatic ad optimization.

How to link GA4 with Google Ads?

To connect, you must have the appropriate access rights to Google Analytics 4 and Google Ads properties. The connection is created through the GA4 admin section or through the available settings for the linked products.

General setup procedure:

1. Open the desired Google Analytics 4 property and go to the admin section.
2. Find the Google Ads connection settings and select your ad account.
3. Confirm the connection parameters and complete the connection.
4. In the Google Ads goals section, go to create a conversion action.
5. Select the Google Analytics source and the desired event, then review the settings.

After creating an ad conversion, you need to define its purpose and calculation rules. Simply connecting accounts doesn't guarantee that ad campaigns will use the correct action for bidding.

What is the difference between Primary and Secondary Conversion?

Primary Conversion – the main conversion action that is typically used for bid optimization and is included in the Conversions column when the corresponding objective is used by a campaign.

Secondary Conversion is intended primarily for monitoring and analysis. These actions are typically displayed in the All Conversions column and are not used for bid optimization unless they are included in a custom goal with specific rules.

For example, for an online store, purchasing can be the primary conversion, and adding an item to cart can be a secondary conversion. However, these settings should be verified at the advertising goal and campaign level, as they determine the actual use of the signals.

Why might conversion numbers differ between GA4 and Google Ads?

Discrepancies arise due to differences in attribution, timing, conversion windows, and individual action settings. The same user may interact with multiple channels before making a purchase, and systems distribute credit differently across these contacts.

Data processing consent rules, modeling, time zones, and the chosen calculation method all have additional implications. Therefore, directly comparing two reports without checking the settings often leads to incorrect conclusions.

When analyzing, select consistent time periods, verify metric definitions, and consider their scope. A perfect match between GA4 and Google Ads data does not necessarily indicate correct setup.

Where can I view events and analyze conversions?

Once set up, Google Analytics 4 collects information that can be used to analyze user behavior and evaluate marketing results. Data is available in standard reports, explorations, and specific event management sections.

To effectively analyze events, it's important to select appropriate metrics and compare actions to traffic sources, landing pages, and other visitor characteristics.

Google Analytics 4 Standard Reports

The reports section allows you to explore the number of events, users, and registered key actions. The Event Count metric shows the number of events received, while Key Events helps you analyze actions marked as important.

To evaluate traffic sources, use acquisition reports, which allow you to compare organic search, advertising, direct visits, and other channels. The analysis should take into account the selected attribution parameters and the scope of the metrics.

For example, if organic traffic is growing but the number of confirmed requests remains the same, it's useful to check your landing pages and search intent. Traffic alone is not enough to assess the quality of SEO.

Event Analysis via Explorations

The Explorations section allows you to create custom explorations based on events and user characteristics. Here you can build tables, compare segments, and analyze action sequences within the user journey.

For example, for an online store, you could study the transitions between viewing a product, adding it to the cart, initiating checkout, and making a purchase. For a service website, you could compare page visits, form interactions, and confirmed requests.

Event Count, Key Events, Key Event Rate, and revenue metrics are useful for analysis. The choice of a specific metric depends on the task, as event frequency and the proportion of users performing key actions describe different aspects of behavior.

How to check event settings and fix errors?

After creating events, you need to verify that they are actually sent. Even if the tag is saved without errors, it may trigger under the wrong condition or send data to another GA4 property.

It's recommended to perform testing before publishing changes and repeat it after major website updates. This is especially true for new forms, page structure changes, and the implementation of dynamic components.

Checking with GTM Preview and Tag Assistant

Google Tag Manager's preview mode shows the interaction sequence, triggers, and tags that fired. It can help you determine why an event isn't being sent or is being sent multiple times.

To test, open the GTM container, click Preview, and connect to the site being tested via Tag Assistant. Then, perform the desired action and find the corresponding trigger in the event sequence.

If the tag doesn't fire, check its conditions, variable values, and the element's availability on the page. After successful testing, publish the container and retest the published version.

Checking events via GA4 DebugView

DebugView displays events received by Google Analytics from a device with debug mode enabled. It's a convenient way to check the event name, passed parameters, and the sequence of actions.

You can use GTM Preview or another Google-provided method for enabling debug mode. After performing the test action, open DebugView and find the event in the stream for the selected device.

If the event appears, expand its parameters and compare the values with the expected values. Also, check how many times it was logged, as repeated submissions may not be visible in regular reports.

Common setup errors

Tracking issues are usually related to incorrect sending conditions, tag re-installation, or parameter mismatches. Therefore, it's best to troubleshoot in stages: first, check the action on the website, then the transfer to GTM, and then the arrival in GA4.

Common errors and how to fix them:

• The event is not sent. Check the measurement ID, tag presence, and trigger conditions.
• The event appears twice. Find duplicate tags, JavaScript calls, and automatic submissions.
• The event_name is incorrect. Check the case of the characters and ensure they match the standard name you have chosen.
• The form is counted before it is successfully submitted. Transfer the event sending to the confirmed processing result.
• There are no parameters in the purchase. Check transaction_id, items, value and currency.
• There are no custom parameters in the reports. Check the registration of custom dimensions and data processing time.
• Google Ads is optimizing for an unnecessary action. Review your primary and secondary conversions, as well as your campaign goal settings.

After making the correction, repeat the test with the new action and check its parameters. For requests, it's useful to additionally compare analytics data with the requests actually received in the CRM or other accounting system.

Setting up events in Google Analytics 4 begins with defining the actions you want to track on your website. After that, you select a suitable data delivery method, verify parameters, and mark key events related to business results.

If you already have analytics installed on your website, but your lead and purchase data is questionable, Seo-Gen specialists can help you check your event setup, identify tracking errors, and set up reporting on SEO and advertising channels.