GA4 Ecommerce Events Checklist: The 9 Events You Need to Set Up Now
7 min read · AstraLoop Studio
If you sell online and rely on GA4 to understand what happens between the storefront and checkout, ecommerce events are your wiring. Wired correctly, you see every step of the customer journey, from the product list all the way to purchase and refund. Wired badly, you get numbers that look right but aren’t: inflated revenue, phantom carts, conversion rates that make no sense.
The problem is that GA4 doesn’t track ecommerce automatically. Enhanced measurement handles clicks, scrolls and downloads, but purchase events have to be implemented by hand, with the correct data structure. This guide walks through the 9 events to set up right now, one by one, with the required parameters and the mistakes that most often skew the data. Treat it as an operational manual: use it as a checklist and tick off one line at a time.

How GA4 thinks about ecommerce events
Before the checklist, one concept needs to be locked in: in GA4, every ecommerce event revolves around a parameter called items. It’s an array (a list) describing the products involved, with properties like item_id, item_name, price and quantity, plus optional ones like brand, category and variant. Without the items array, your events still fire, but they stay empty shells: GA4 logs “someone added to cart” without knowing what.
Two other parameters are just as decisive. value is the monetary value of the action, and currency is the ISO currency code (for Italy, “EUR”). They always go together: send value without currency and GA4 won’t calculate revenue. Finally, use Google’s recommended event names exactly as documented (view_item, add_to_cart, purchase, and so on): those are what feed the default ecommerce reports. An event called “cart_add” still works as a generic event, but it falls outside commerce reporting entirely.
In practice, these events are the most granular layer of your ecommerce tracking system: if this layer is wrong, everything you build on top of it inherits the error.
The 9 GA4 events checklist to set up now
These 9 events cover the entire purchase journey, from product discovery to refund. Set them up in this order: it mirrors the funnel and lets you read drop-offs step by step, so you can immediately spot which ecommerce KPIs are suffering.
| # | Event | When it fires | Key parameters |
|---|---|---|---|
| 1 | view_item_list | The user sees a list or grid of products | items, item_list_name |
| 2 | view_item | Opens a product page | items, currency, value |
| 3 | add_to_cart | Adds a product to the cart | items, currency, value |
| 4 | view_cart | Opens the cart | items, currency, value |
| 5 | begin_checkout | Starts the checkout process | items, currency, value, coupon |
| 6 | add_shipping_info | Selects a shipping method | items, currency, value, shipping_tier |
| 7 | add_payment_info | Enters a payment method | items, currency, value, payment_type |
| 8 | purchase | Completes the order | transaction_id, value, currency, items |
| 9 | refund | Full or partial refund | transaction_id, items |
The actual implementation depends on the platform: many stores (for example on Shopify connected to GA4) already send part of these events through an app or theme, but they almost always need to be completed, corrected and tested. Never assume it “just works by default.”
1. view_item_list
Fires when the user views a list of products: a category, search results, a grid on the homepage. It measures which lists generate interest. Common mistake: passing the whole page as a single list without item_list_name, so you can’t tell the “Shoes” category apart from the “Recommended for you” section.
2. view_item
Fires when a product page opens. It’s the first event with an economic value attached (the product’s price). Common mistake: setting value to the price but forgetting currency, or sending the price as text (“$29.90”) instead of a plain number (29.90).
3. add_to_cart
The heart of purchase intent. Fires when a product enters the cart, with quantity and price. Common mistake: firing it on page load instead of on the button click, inflating add_to_cart counts. Always verify it fires exactly once per real action.
4. view_cart
Fires when the cart opens (dedicated page or side drawer). It measures how many users revisit the cart before deciding. Common mistake: confusing it with begin_checkout. They’re two distinct steps, and keeping them separate lets you see precisely where the customer stalls.
5. begin_checkout
Fires when the user starts the checkout process. It’s the dividing line between “browsing” and “buying.” Common mistake: not including the full items array, which loses the cart’s value going into checkout and makes it impossible to calculate drop-off by price range.
6. add_shipping_info
Fires when the user selects a shipping method (parameter shipping_tier, e.g. “Standard” or “Express”). It tells you whether a shipping option is blocking conversion. Common mistake: skipping it because “begin_checkout already covers it,” losing visibility into one of the most frequent drop-off points.
7. add_payment_info
Fires when the user enters a payment method (parameter payment_type). It’s the last step before purchase and one of the costliest drop-off points. Common mistake: omitting it entirely, leaving a blind spot in the funnel exactly where you’d need to understand why the customer stops.
8. purchase
The most important event: it records a completed order. It requires transaction_id (a unique order identifier), value, currency and the items array, plus ideally shipping, tax and coupon. Mark it as a key event in GA4 so it counts as a conversion. Common mistake: the event fires twice because the customer reloads the thank-you page. GA4 uses transaction_id to recognize transactions, but the safest approach is to make sure purchase fires only once.
9. refund
Fires on a full or partial refund. Use the same transaction_id as the original purchase; for partial refunds, include only the returned products in the items array. Common mistake: not implementing it at all, so GA4’s revenue stays gross and doesn’t reflect returns — a figure that, in some industries (fashion above all), radically changes the real ROI.
Three complementary events to add once the base funnel is solid: select_item (clicking a product inside a list, to link lists to product views), remove_from_cart (removing an item from the cart) and add_to_wishlist. They’re not as high-priority as the 9 above, but they sharpen your read on micro drop-offs.
Want to be sure every euro of revenue in GA4 is real? Ask us for an ecommerce tracking audit: we find missing events, duplicates and misconfigured parameters before they corrupt your decisions.

The cross-cutting mistakes that skew ecommerce data
Some problems don’t belong to a single event but to the whole setup. Over time, these are the ones that make you stop trusting the numbers.
- Missing currency. Every time you send value, you must also send currency. Without it, GA4 logs the event but zeroes out the associated revenue.
- Old Universal Analytics schema. If you’re migrating from UA, the dataLayer used products and id; GA4 wants items and item_id. Recycling the old code is the number-one cause of “empty” events.
- Inconsistent item_id. The same product must carry the same item_id across every event and, ideally, in the Merchant Center feed too. If it changes between add_to_cart and purchase, GA4 treats them as different products.
- value sent as a string. Monetary values must be sent as numbers (29.90), never as text with a currency symbol or comma.
- Consent Mode blocking everything. In the EU, events may not fire without consent. Set up Consent Mode v2 so you don’t lose data while staying compliant.
- No testing before go-live. Publishing without checking DebugView means finding the gaps weeks later, once the data is already dirty.
How to verify the events actually work
Setting them up isn’t enough: you need to see the events arrive with the right parameters. Three tools, in order.
- DebugView. Turn on debug mode (with Tag Assistant or Google Tag Manager’s preview) and complete a test purchase. In DebugView you see every event in real time and can click into it to check items, value, currency and transaction_id.
- Realtime report. Confirm the events are also arriving from real traffic, not just your debug session.
- Monetization report (Ecommerce purchases). After 24-48 hours, check that revenue, products and transactions look consistent. Revenue that’s very different from your order-management system is the signal something’s off.
A real test purchase (or a sandbox one) remains the most reliable proof: walk through the entire journey and confirm every step in the checklist fires exactly once, with correct data.
From checklist to reliable data
GA4’s ecommerce events aren’t a technical box to tick: they’re the foundation you use to decide ad spend, pricing and product priorities. A well-tracked funnel tells you where you lose customers, what each step is worth, and which campaigns drive real purchases instead of just clicks.
From there, data turns into action: from GA4 reports that actually matter to abandoned cart recovery automation, clean tracking is the prerequisite for everything. If you’re starting from scratch, setting up GA4 from zero and the complete guide to conversion tracking give you the bigger picture this checklist fits into.
Frequently asked questions
What are the core GA4 ecommerce events?
The 9 to set up right away are view_item_list, view_item, add_to_cart, view_cart, begin_checkout, add_shipping_info, add_payment_info, purchase and refund. They cover the entire journey, from product discovery to returns, and feed GA4's default ecommerce reports.
Does GA4 track ecommerce automatically?
No. Enhanced measurement covers clicks, scrolls and downloads, but not purchase events. view_item, add_to_cart, purchase and the rest need to be implemented manually via dataLayer and Google Tag Manager (or gtag), with a correctly structured items array.
Why don't I see ecommerce revenue in GA4?
In most cases the currency parameter isn't paired with value, or the value is sent as text instead of a number, or the purchase event isn't implemented correctly. Check these three points in DebugView first.
What is transaction_id used for in the purchase event?
It's the order's unique identifier. GA4 uses it to recognize the transaction and avoid counting it twice. The same applies to the refund event, which must use the same transaction_id as the original purchase.
What's the difference between add_to_cart and begin_checkout?
add_to_cart fires when a product enters the cart; begin_checkout fires when the user starts the payment process. They're two distinct steps in the funnel: keeping them separate shows you exactly where the purchase journey breaks down.
How do I check that GA4 events are working?
Use DebugView to inspect every event and its parameters in real time during a test purchase, then confirm with the realtime report on actual traffic, and finally compare the Ecommerce purchases report against your order-management data after 24-48 hours.
If you'd rather start on solid ground than chase dirty data later, talk to us: we set up GA4 events, conversions and the automations connected to your store.