Four events make or break your GA4 ecommerce funnel: view_item, add_to_cart, begin_checkout, and purchase. Each one needs an items array plus its own set of required parameters, and if any of them are missing or malformed, your funnel reporting quietly falls apart. This is the core of any google analytics 4 ecommerce events view_item add_to_cart begin_checkout purchase documentation task, whether you're setting it up fresh or auditing a broken implementation.
This guide covers what parameters each event needs, exactly when it should fire, and the tagging mistakes that show up most often in real GTM containers and Shopify checkouts. We'll also flag where web and app implementations diverge.
One more thing up front: this applies to both GA4 web (gtag.js or Google Tag Manager) and app implementations through Firebase. The event names and parameter structures are nearly identical, but the firing mechanism and some syntax differs. We'll call that out section by section.
view_item: parameters and when it should fire
view_item needs an items array containing item_id, item_name, price, and quantity for each product, plus currency and value set at the event level, outside the array.
This event fires when a product detail page loads. Not when a product card shows up in a grid, not when someone hovers over a thumbnail. That's view_item_list, a different event entirely, and conflating the two is one of the most common setup errors we see in GTM containers.
Here's the bug that trips up almost everyone: forgetting the currency parameter. GA4 doesn't throw an error when currency is missing. It just drops the event from revenue-based reports without telling you. You'll see the event count in Realtime, but it won't show up correctly in monetization reports, and your view_item to purchase conversion math will look wrong for reasons that have nothing to do with actual user behavior. Always hardcode or dynamically pull currency, never leave it to default.
add_to_cart: parameters and when it should fire
Same items array structure as view_item: item_id, item_name, price, quantity, with currency and value at the event level. The one difference that matters here is quantity. It needs to reflect the actual amount added, not just a flat 1 every time.
This event should fire the moment the add-to-cart action happens, whether that's a click on the PDP or a quick-add button on a collection page. If your store has quick-add tiles and they're not wired to fire add_to_cart, you're undercounting cart activity across your whole catalog, not just a few product pages.
The quantity mismatch is the sneaky one. If someone adds 3 units of a product in a single click and your tag fires once with quantity hardcoded to 1, GA4 records one cart addition instead of three. That skews your cart-to-purchase ratio and makes average order value calculations unreliable downstream. Check your dataLayer push against the actual form input value, not against the number of clicks.
begin_checkout: parameters and when it should fire
Required parameters: items array, value, currency, and an optional coupon parameter if you're tracking promo code usage through the funnel.
This fires when the checkout page or checkout step loads, before the customer has entered shipping or payment details. It's the first touchpoint in the actual checkout flow, as opposed to the cart page, which is a separate step entirely in most implementations.
If you're on Shopify, there's a specific trap here. checkout.liquid is deprecated, which means custom scripts injected into the old checkout page template often stop firing, or fire inconsistently depending on the checkout extensibility rollout for that store. For most Shopify merchants, this means begin_checkout needs to come from checkout extensibility (Shopify's new UI extension framework) or a dedicated GA4 app integration rather than a hand-rolled script tag. If your begin_checkout numbers dropped suddenly and nothing else changed, check whether Shopify migrated that store's checkout in the background. For a deeper look at how Shopify's checkout changes affect tracking setups generally, see our Shopify integration guide.
purchase: parameters and when it should fire
purchase needs transaction_id (unique per order, no exceptions), value, currency, and the items array. If your business needs revenue reporting that reconciles with actual financials, add tax and shipping as separate parameters too, since GA4 doesn't infer these from value automatically.
This event fires once, on the order confirmation or thank-you page. Once is the operative word. A lot of implementations fire purchase again if the customer refreshes the confirmation page or navigates back to it, which inflates revenue in GA4 compared to what actually happened. You need deduplication logic, usually checking whether that transaction_id has already been sent in the current session, before letting the tag fire again.
Transaction ID mismatches are the number one reason GA4 revenue doesn't match Shopify or Stripe order totals. This happens when the ID gets generated client-side before the order is fully confirmed, or when test orders and draft orders get included in GA4 but excluded from your financial systems. If you're debugging a revenue discrepancy, start here before you start questioning attribution models or sampling.
Validating the funnel: common setup mistakes
Don't trust funnel data until you've confirmed it in GA4 DebugView and Realtime. Load a product page, add to cart, start checkout, complete a test purchase, and watch each event land with the parameters you expect. This takes fifteen minutes and catches most of the errors above before they pollute weeks of reporting.
Watch for events firing out of order. If you're seeing purchase events with no preceding begin_checkout in the same session, that's almost never organic user behavior. It's a tagging error, usually a purchase tag that fires independently of the rest of the funnel sequence, maybe triggered by a different tag manager trigger than the one managing the earlier steps.
Here's something worth sitting with: GA4's native funnel exploration tends to undercount compared to server-side tracking or warehouse-based reporting. Ad blockers strip a meaningful share of client-side GA4 tags before they ever fire, and consent mode gaps mean users who decline cookies don't get tracked at all, even though their purchase still happened and shows up in your order management system. If your GA4 funnel and your actual order count have been drifting apart, this is usually why, not a tagging bug.
Where this data goes after GA4: building a funnel you can actually trust
GA4's client-side tracking is useful for directional signal, but it's not something we'd build revenue reporting on by itself. Trivas pulls these four events (view_item, add_to_cart, begin_checkout, purchase) into Redshift-backed dashboards, so your view_item to purchase conversion rates aren't entirely dependent on GA4's sampling thresholds or whatever client-side tracking survived ad blockers that day.
The bigger fix is combining GA4 event data with actual order data from Shopify or Amazon. That's what closes the gap between "this many purchase events fired in GA4" and "this many orders actually happened and this much revenue actually came in." Once those two sources are reconciled, you stop guessing about whether a funnel drop-off is real user behavior or a measurement gap.
If you're starting a GA4 ecommerce implementation from scratch, it's worth checking the GA4 solutions page or the data dictionary first, so you know what the downstream reporting expects before you write a single tag.
Next steps
The sequence is view_item, add_to_cart, begin_checkout, purchase, each one needs its items array plus its own event-level parameters, and the single biggest failure point across all four is a missing or mismatched parameter, usually currency or transaction_id.
If you're implementing this yourself, the developer docs cover the technical specifics, and the data dictionary is a good reference for how each metric gets defined once the data lands in reporting.
If you'd rather not spend a week debugging GTM triggers and reconciling revenue by hand, Trivas's GA4 integration is built to get funnel accuracy without that process. Worth a look before you commit to building it all from scratch.
Content author and contributor at Trivas.ai, sharing insights on e-commerce analytics, business intelligence, and data-driven strategies to help businesses grow.
Continue Reading
explore more insights
How to Set Weekly ROAS Targets for Each Channel
3 min read
Ecommerce Analytics for Brands Spending $100K+/Month on Ads: What Actually Works at This Scale
3 min read
5 Real Time Ecommerce Analytics Myths Founders Believe
.d53b12e5.png&w=3840&q=75 "Trivas.ai")
