GA4 events for e-commerce: essential setup checklist

E-Commerce Events in GA4

E-commerce events in GA4 are the foundation of all analytics, and for e-commerce projects, it is specifically e-commerce events that allow tracking the full user journey — from product view to purchase. Unlike Universal Analytics, GA4 (Google Analytics 4) has no categories or actions — everything comes down to events with parameters. This is flexible, but requires correct implementation before the site goes live. If you don’t include e-commerce events in the technical specification or do it after launch — you’ll have to rewrite code, lose data, and waste time.

At COI.UA, we implement event-based analytics at the technical specification level, preparing the site to measure sales, revenue, traffic sources, and marketing performance before the first customer. This article provides a complete checklist of GA4 e-commerce events that must be implemented before launch.

What Are E-commerce Events in GA4 and How Do They Work

How GA4 Differs from Universal Analytics

Google Analytics 4 is a fundamentally new model of web analytics that is no longer based on sessions and pageviews like Universal Analytics. In GA4, all analytics are built around events, each of which can include additional parameters. This means that any user interaction — from a click to a purchase — is recorded as a separate event with detailed data: product, price, quantity, traffic source, etc.

For e-commerce projects, this opens up broader possibilities: instead of simply tracking “visits” or “pageviews,” you can monitor specific actions at the level of products, shopping carts, checkout, and payments. However, GA4 does not include built-in templates like UA did, so the entire e-commerce logic must be implemented manually or via tags in GTM.

The Core Logic: Event + Parameters

In GA4, e-commerce events are standard or custom events that send a data set in the format: event → set of parameters → category/product/session.

For example:

Event: add_to_cart
Parameters: { item_name: "Shirt", item_id: "SKU123", price: 890, quantity: 2 }

This data allows you to:

See which products are most frequently added to the cart
Calculate actual revenue for each SKU (Stock Keeping Unit — a unique identifier for a product in the inventory or accounting system)
Measure the performance of ad campaigns at the product level

Such a flexible structure makes GA4 a universal tool for e-commerce website tracking — but it requires clearly defined events in the technical specification before development begins.

Why E-commerce Projects Need Events From the Start

The biggest mistake is postponing event setup until “after launch.” In that case:

You lose data from the very first traffic
You can't see what’s working in advertising or what drives revenue
You spend extra budget integrating analytics retroactively

GA4 events aren’t just statistics — they are the foundation for ROI tracking, remarketing, SEO priorities, and business decision-making. If you skip them at the start, you lose control over your e-commerce strategy.

At COI marketing and software, we implement GA4 from the technical specification stage: every event is defined, tested, and clearly documented for the client. That’s why our projects are always analytics-ready — even before the first sale.

Standard GA4 Events for E-commerce

Google Analytics 4 includes a set of standard events that help track key user actions in e-commerce — from viewing a product to completing a purchase. To make these events work correctly, they must be passed along with parameters related to the product and transaction.

Which Events Are Required

view_item_list — tracks the view of a product list: categories, filters, collections. Used when the catalog is opened.
view_item — tracks the opening of a specific product page. Helps evaluate interest in individual items.
add_to_cart — triggers when a user adds a product to the cart. A key indicator of interest.
remove_from_cart — tracks the removal of a product from the cart. Helps analyze purchase barriers.
begin_checkout — signals the start of the checkout process. Important for building the sales funnel.
add_payment_info — triggered after entering payment details or selecting a payment method. Indicates checkout progress.
purchase — the main conversion event that records a successful purchase. Triggered on the thank-you page after payment.

How Event Structure Works

For each GA4 event, you must pass an items array, where each product contains the following key parameters:

item_id — unique product SKU or article number
item_name — product name
item_brand — brand
item_category — product category
price — price
quantity — quantity
currency — currency (e.g., UAH)

For the purchase event, additional parameters are required:

transaction_id — unique order number
value — total purchase amount
shipping — shipping cost
tax — taxes, if applicable

Example of add_to_cart Event Structure

{

"event": "add_to_cart",

"ecommerce": {

"items": [

{

"item_id": "SKU-12345",

"item_name": "Men’s Shirt",

"price": 1200,

"item_brand": "Zara",

"item_category": "Men’s Clothing",

"quantity": 1,

"currency": "UAH"

}

]

}

Why This Is Critical for E-commerce

If you fail to send the required parameters, the events will not be saved in reports. Without the SKU, it’s impossible to analyze which specific products were sold. Without a transaction_id, purchase data can be duplicated or lost. All of this reduces the accuracy of analytics and makes it impossible to correctly measure the effectiveness of advertising or SEO for e-commerce websites.

Marketing and Analytics Events

In GA4, e-commerce events aren’t just about tracking purchases. They also form the foundation for remarketing, personalized campaigns, and audience segmentation. To get the most from analytics, it’s important to implement marketing events before the website launch.

Key Events for Tracking Promotions and Product Interactions

select_item — records a user selecting an item from a list (e.g., in a catalog or on the homepage). Helps identify which products attract the most attention.
view_promotion — triggered when a promotional banner, offer block, or special deal is displayed. Enables analysis of promo visibility and reach.
select_promotion — tracks clicks on promo blocks or banners. Indicates how engaged users are with promotions.

These events allow you to build not just sales funnels, but also promo engagement funnels — from impression to click, and then to purchase.

How GA4 Collects Data for Campaigns and Audiences

GA4 automatically builds audience segments based on events. For example:

users who viewed a product but didn’t add it to the cart;
those who interacted with a promo but didn’t complete a purchase;
visitors who returned within 7 days after viewing a product.

These audiences can be used for Google Ads remarketing or personalized content on the website. Events act as triggers for creating real-time dynamic segments.

Event Linkage with UTM Tags

GA4 automatically reads UTM tags when they are present in the URL. It’s crucial that all marketing campaigns include properly tagged links:

utm_source — source (e.g., facebook, email, google)
utm_medium — medium (cpc, organic, referral)
utm_campaign — campaign name (promo_spring, launch_2025)

The combination of UTM tags and event tracking allows you to pinpoint exactly which channel brought the traffic, which products were viewed, whether the promo worked — and ultimately, measure ROI.

How We Implement This at COI.UA

At COI marketing and software, we implement all key marketing events and build reusable templates for deploying them across different site sections. From the moment your site launches, you can see:

which promotions actually work;
which products are most frequently selected;
which campaigns drive traffic and which generate sales.

By integrating GA4 and Google Ads, we enable smart remarketing with minimal setup — because the analytics already knows your users’ behavior.

Additional Custom Events: When They’re Needed

Not all important user actions are covered by GA4’s standard events. For e-commerce projects, it's often necessary to track interactions that don’t directly lead to a purchase but significantly impact conversion. In these cases, we implement custom events — events with unique names and parameters tailored to your business processes.

Newsletter Subscription

The subscribe_newsletter event tracks users who enter their email. This is critical for:

evaluating the effectiveness of subscription forms;
building an email marketing strategy;
segmenting your database for remarketing.

It also allows you to analyze where users are most likely to subscribe: in the header, in a popup, or under articles.

CTA Button Clicks

The cta_click event tracks clicks on key calls-to-action — such as “Buy Now,” “Learn More,” or “Get a Consultation.” With this event, you can:

determine which button performs better — above the fold or below the product description;
evaluate which CTA text drives a higher CTR;
understand how behavior changes after a click.

This helps the UX team improve layout and messaging.

Chat Initiated

The chat_initiated event fires when a user opens the online chat or sends a message. It reveals:

which pages generate the most questions;
whether the trigger worked (e.g., time on page, scroll depth, or CTA);
how chat engagement affects conversions.

This insight is valuable for sales and support teams.

File Downloads (Price Lists or Presentations)

The file_download event captures downloads of PDFs, Excel sheets, or other documents (like price lists, portfolios, or case studies). This shows:

user interest in a product or service;
the user’s readiness to move forward in the funnel;
the performance of content sections featuring materials.

It can also serve as a trigger for remarketing or a CRM follow-up.

How We Do It at COI.UA

At COI marketing and software, we don’t just add custom events — we build a structured interaction map. Each custom event:

has a clear name and set of parameters;
appears automatically in GA4 reports;
is integrated with GTM, CRM, and advertising platforms.

This allows our clients to gain a full picture of user behavior — even if no purchase occurs — and respond in time through email, ads, or content.

How to Describe Events in the Technical Specification

To ensure proper implementation of e-commerce events in GA4, the analyst must define not only the list of events but also the triggers, required parameters, and responsible parties in the technical specification (TS). Without this, events may not fire correctly — or worse, they’ll send incorrect data.

Sample Event Specifications

Below are typical constructions we use in technical specs at COI.UA. The descriptions must be unambiguous, technically clear, and aligned with GA4 naming conventions:

The view_item_list event should trigger upon rendering a product list. Parameters to send: item_name, item_id, item_list_name, price, category.
The add_to_cart event should be fired after clicking the “Add to Cart” button on a product card. Required parameters: item_id, item_name, price, quantity.
The purchase event must be triggered upon order confirmation. Parameters: transaction_id, value, currency, items (an array of product data).
The file_download event should trigger after clicking on a link to a PDF file. Parameters: file_name, file_url, page_location.

Each event in the TS must include the following: Event name → Trigger condition → Parameters to be passed. Without clearly defining these elements, it will be difficult to link the data in reports or set up remarketing properly.

Who’s Responsible for What

Event implementation is a cross-functional effort, and it’s important to define areas of responsibility early on:

Analyst: compiles the event list, required parameters, and trigger conditions. Prepares technical documentation for the developer.
Marketer: provides a list of business-critical interactions that need tracking (e.g., newsletter signups, downloads, CTA clicks).
Developer: implements the events in the website code or via Google Tag Manager. Ensures correct parameter delivery.
QA Team: verifies that events trigger properly, data is passed correctly, and there are no duplicates.

At COI marketing and software, we integrate all these steps into a single workflow — events aren’t just “implemented,” they become part of the business logic, fully synced with analytics, CRM, and advertising before the site goes live.

How to Check if Everything Works

Even if the events are implemented according to the technical specification, they must be tested before the website launch or campaign start. Without testing, you risk losing important analytical data, misconfiguring goals, or sending incorrect values into reports.

GA4 DebugView: Real-Time Diagnostics

DebugView is a section in Google Analytics 4 that shows all events sent from your device in real time. To use it:

Enable debug mode (via Google Tag Assistant or by setting the debug_mode parameter).
Open DebugView in GA4 (in the “Admin → DebugView” section).
Check which events are being sent, in what order, and whether there are any duplicates.
Review parameter values — they should be populated and not undefined.

This tool is especially useful for testing custom events (e.g., button clicks, file downloads).

Google Tag Assistant: Tag and Trigger Validation

Google Tag Assistant (v2) is a free tool that allows you to:

Verify that your GA4 tags are firing correctly;
See which events are being transmitted;
Confirm whether key parameters (item_id, price, value, etc.) are passed;
Detect errors in GTM configuration.

It helps localize the issue — if an event doesn’t reach GA4, you’ll see that directly in the browser.

Pre-Launch Testing Workflow

Before launching an e-commerce site, you must run full end-to-end testing in a staging or preview environment. Here's the process:

Enable Preview Mode in Google Tag Manager.
Test all core user flows:

Category views (view_item_list);
Product detail views (view_item);
Add to cart (add_to_cart);
Checkout initiation (begin_checkout);
Order confirmation (purchase).

Each step is verified via GTM → Debug → GA4 → DebugView.
Marketing events are also tested: CTA clicks, subscriptions, downloads, scroll tracking, and more.

At COI marketing and software, we conduct two testing stages: first in the development environment, and then on the live domain in sandbox mode. This guarantees that after the launch, the website immediately transmits a complete dataset to GA4, ready for advertising, remarketing, and SEO analytics.

How We Implement It at COI.UA

At COI marketing and software, we don’t just plug in basic analytics. We design the event-based structure alongside your marketing strategy — even before the site is live. This ensures your analytics system is ready for e-commerce loads, advertising, and scaling from day one.

Event Analytics in the Admin Panel with Prebuilt Events

We integrate GA4 via Google Tag Manager and display key events directly in your site’s admin panel. This allows you to:

track events in real time;
view the event structure and parameters without technical knowledge;
quickly test and update your analytics.

All critical e-commerce events — view_item, add_to_cart, purchase, begin_checkout — are already configured.

Transparent Reporting for E-commerce Clients

We create custom reports based on your business metrics:

number and value of orders;
conversion rates at each stage;
revenue by channel;
campaign performance.

Our clients always have access to clear, structured, and up-to-date reports — with no need to contact an analyst.

Built-in Event Logic for Fast Launch

During development, we immediately:

define triggers for key user actions;
configure event parameters according to GA4 guidelines;
implement templates for easy generation of custom events;
test and document analytics in the technical specification.

This enables campaign launches, A/B testing, and scaling — without losing time or budget on fixes.

Summary and GA4 Event Checklist for E-commerce

Event analytics in GA4 isn’t a post-launch add-on — it’s a critical element of a successful e-commerce strategy. The accuracy of your reports, the effectiveness of your ad campaigns, and the completeness of your business data all depend on correct event implementation.

The most common mistakes — missing event plans, vague technical specs, skipping pre-launch testing — are easy to avoid if you:

integrate an analyst into the website creation process;
define the event structure in the spec;
use testing tools before going live;
verify GA4 parameters against a checklist.

GA4 Event Checklist for E-commerce

Structured event plan: view_item, add_to_cart, purchase, etc.
Defined parameters: id, name, category, value, currency, quantity, affiliation
Marketing events included: select_item, view_promotion, select_promotion
Custom events covered: newsletter signup, CTA click, chat, file download
Spec includes: event names, triggers, parameters
Debugging with GA4 DebugView and Google Tag Assistant
UTM-tag tracking and remarketing set up
GA4 and Looker Studio reports tested
Analytics visible in admin panel (if required)

How We at COI.UA Implement GA4 Events for E-commerce: Our Approach

Event-based analytics isn’t just a technical detail. For e-commerce, it’s a tool that defines the effectiveness of your marketing, promotion, and sales. At COI marketing and software, we integrate Google Analytics 4 events not during post-launch fixes, but from day one — in the specs, wireframes, and development.

Here’s how we do it:

Implementing Events Before Site Launch

We create a GA4 event list based on the site’s structure, business goals, and marketing scenarios. Each event is documented in the technical specification: