GA4 Ecommerce Tracking Checklist for Shopify, WooCommerce, and Custom Sites

Overview

GA4 ecommerce tracking usually breaks in small, expensive ways. The purchase event fires twice. Item data disappears on some pages. Refunds never make it into reporting. Traffic source data gets split because checkout happens on another domain. None of these issues are dramatic in isolation, but together they make campaign attribution, funnel analysis, and KPI reporting harder than they need to be.

The goal of this checklist is simple: make sure your GA4 ecommerce setup is complete enough to support daily decision-making. That means answering questions like:

• Are key ecommerce events firing at the right moments?
• Do item-level parameters pass consistently?
• Is revenue tied to the right transaction IDs?
• Can you trust source and medium through checkout?
• Will reports stay usable after app changes, theme edits, plugin updates, or checkout changes?

Before you start, keep one principle in mind: consistency matters more than theoretical perfection. A smaller event model that fires reliably is more useful than a complex setup with gaps. For most stores, the essential GA4 ecommerce events to validate are:

• view_item
• add_to_cart
• begin_checkout
• add_payment_info and add_shipping_info when available and accurate
• purchase
• refund if your workflow supports it

You may also use view_item_list, select_item, remove_from_cart, and promotional events, but those should come after the core flow is stable.

If your broader implementation is still messy, pair this article with GA4 Audit Checklist: 40 Issues to Check Before You Trust Your Data. If your event naming is inconsistent outside the ecommerce schema, GA4 Event Naming Conventions: A Practical Standard for Cleaner Reporting is a useful companion.

Checklist by scenario

Use the scenario that matches your stack, then run the universal checks underneath it. The details differ by platform, but the questions are the same: what fires, when it fires, and whether the payload is complete.

Universal GA4 ecommerce checklist

• Confirm one GA4 property is the source of truth. Avoid scattered measurement IDs across themes, apps, plugins, and tag managers unless there is a clear reason.
• Document how GA4 is installed. Note whether tracking is added through native integration, Google Tag Manager, a plugin, custom code, or a mix.
• Test the full purchase path in a staging or low-risk environment. Check product page, cart, checkout, payment step, and order confirmation.
• Validate the purchase event only fires once per completed order. Refreshing the thank-you page should not create duplicate purchases if your setup depends on page load alone.
• Check transaction_id on every purchase. It should be unique and stable enough to support deduplication and clean revenue reporting.
• Check value and currency. Make sure revenue is sent in expected format and matches the order total logic you intend to report.
• Inspect item arrays. Product-level details should pass consistently, not just order-level totals.
• Verify item parameters. At minimum, item_id and item_name should be present. If available, also validate price, quantity, item_brand, item_category, item_variant, discount, coupon, and affiliation as applicable.
• Mark the right events as key events in GA4. Usually purchase is essential; others depend on your reporting and activation needs.
• Review checkout domain behavior. If cart or checkout lives on another domain or subdomain, check cross-domain tracking and session continuity.
• Test with consent mode or consent tools enabled. Make sure your expected event behavior still occurs within your privacy setup.
• Compare GA4 orders to platform orders directionally, not obsessively. The goal is sensible alignment and explainable differences, not perfect one-to-one parity in every report.

Shopify GA4 setup checklist

Shopify is often easier to launch than to validate. Multiple apps, theme code, and native integrations can create overlapping tracking very quickly.

• Map your current Shopify tracking stack. List the sales channel setup, any GA4 app, any Google & YouTube integration, GTM usage, and any custom scripts still present.
• Check for duplicate purchase tracking. This is one of the most common Shopify problems, especially when a native integration and a custom implementation both send purchase.
• Confirm product identifiers are consistent. If item_id changes between product view and purchase, product reporting becomes harder to trust.
• Review checkout limitations and data access assumptions. Some implementations can track storefront interactions well but depend on different mechanisms for checkout and order completion. Document what is native versus customized.
• Test discount and coupon handling. If promotions matter to your reporting, make sure discounts are sent intentionally rather than inferred later.
• Validate shipping and tax expectations. Decide whether your GA4 revenue analysis should align to gross order value, net value, or another internal standard, then implement consistently.
• Inspect app interference. Wishlist apps, upsell tools, subscription apps, and accelerated checkout tools may affect event timing or item payloads.
• Re-test after theme changes. Even small storefront edits can break add_to_cart or item-list interactions.

WooCommerce GA4 tracking checklist

WooCommerce is flexible, which usually means more variation in tracking quality. Plugin choice matters, but so does how your theme and checkout customizations interact with that plugin.

• Identify the primary ecommerce tracking plugin or GTM setup. Avoid running multiple tools that each claim ownership of GA4 ecommerce events.
• Test variable products carefully. Confirm item_variant, price, and item_id are passed accurately for product variations.
• Validate AJAX add-to-cart behavior. If the cart updates without a page reload, the add_to_cart event still needs to fire once and only once.
• Check cart and mini-cart behavior. Some setups fire remove_from_cart or view_cart inconsistently.
• Confirm order confirmation reliability. Caching, redirect logic, or payment gateway behavior can affect purchase firing.
• Test major payment methods separately. Card checkout, express payment options, and off-site gateways may not behave the same way.
• Review coupon and tax handling. Make sure what you send to GA4 matches the commercial questions your team actually asks.
• Compare plugin updates against data changes. After updates, retest core ecommerce events rather than assuming the old behavior still holds.

Custom site GA4 ecommerce checklist

Custom ecommerce builds offer the most control, but they also require the clearest specification. If there is no written event plan, small assumptions can create permanent reporting problems.

• Create a tracking specification before implementation. Define every event, trigger, parameter, naming rule, and owner.
• Use the recommended ecommerce event names where possible. Custom names may be easier for developers in the short term but harder for reporting and maintenance later.
• Push structured ecommerce data consistently. Whether you use a data layer or direct tagging, the item schema should be predictable across templates.
• Define transaction_id generation clearly. It should reflect actual order identity and support duplicate prevention.
• Separate frontend interactions from confirmed backend outcomes. A button click is not always a completed purchase.
• Plan for partial failures. If the confirmation page does not load, can the purchase still be recorded through a reliable server-assisted or backend-aware workflow?
• Test logged-in and guest checkouts. Different user states often produce different data behavior.
• Document release dependencies. A payment update, cart refactor, or API change should automatically trigger analytics retesting.

Cross-domain and checkout continuity checklist

If your ecommerce journey crosses domains, attribution and session continuity can fall apart quietly.

• List every domain and subdomain in the purchase path. Include storefront, cart, checkout, payment, and confirmation destinations.
• Check whether the same user keeps the same session across domains.
• Review referral exclusions and linker behavior carefully.
• Test campaign parameters from landing page to purchase. Make sure source, medium, and campaign attribution survive checkout transitions.
• Verify self-referrals are not inflating reports.

For a deeper walkthrough, see Cross-Domain Tracking in GA4: Setup Guide, Testing Steps, and Common Fixes.

What to double-check

This is the part most teams skip because the basics appear to work. It is also where a lot of reporting debt begins.

1. Event timing

Make sure each event represents the user action you think it represents. For example, begin_checkout should not fire just because the cart drawer opens. purchase should reflect an actual completed order, not only a redirect to a thank-you page that could misfire or reload.

2. Item scope versus event scope

GA4 ecommerce reporting depends heavily on item-level data. If product details sit only at the event level, analysis becomes limited. Check whether key product attributes are passed inside the items array, not only as top-level parameters.

3. Revenue definition

Different teams mean different things by revenue. Some want product revenue only. Others want shipping and tax included. GA4 can support your chosen model, but only if you define it first and document it. The mistake is not choosing one standard.

4. Internal traffic and test orders

Exclude or clearly label internal traffic, QA sessions, and sandbox purchases where possible. If not, at least maintain a simple process to identify and interpret them in reporting.

5. Attribution through campaign landing pages

Test a real campaign URL with UTM parameters, click through to product and checkout, and verify that the resulting purchase can still be tied back sensibly to campaign traffic. This step matters as much as the event setup itself.

6. Reporting usability

Even a technically valid implementation can be hard to use if parameters are inconsistent. Product IDs should not vary by page type. Category logic should not change by template. Naming consistency is what turns raw GA4 event tracking into useful marketing analytics.

Common mistakes

Most GA4 ecommerce problems are not caused by GA4 alone. They come from unclear ownership, overlapping tools, and assumptions that no one rechecked after a platform change.

• Tracking the same event from multiple places. A native integration, plugin, and GTM container can all fire purchase unless someone explicitly prevents overlap.
• Skipping item-level validation. Teams often confirm that revenue shows up and stop there, even though product reporting is incomplete.
• Using inconsistent identifiers. If item_id changes between browsing and purchase, merchandising analysis gets messy fast.
• Ignoring refunds. If your business relies on net revenue analysis, refund data cannot be an afterthought.
• Assuming checkout tools preserve attribution automatically. They often need explicit review, especially across domains or hosted payment steps.
• Not retesting after plugin, app, or theme updates. Ecommerce tracking is not a one-time setup.
• Treating GA4 and ad platform conversion tracking as interchangeable. They serve related but different purposes. Your GA4 purchase event should be reliable on its own, even if you also use Google Ads conversion tracking or Meta Pixel tracking.
• Building reports before validating definitions. A clean Looker Studio dashboard cannot compensate for unclear event logic underneath.

A useful operational habit is to keep a short changelog: what changed, when it changed, and which events were retested afterward. This sounds basic, but it is one of the easiest ways to reduce future debugging time.

When to revisit

This checklist is most useful when you return to it at the right moments. GA4 ecommerce tracking should be reviewed on a schedule and after any change that could affect the purchase path.

Revisit your setup:

• Before seasonal planning cycles. Do a full validation before high-traffic periods, promotions, or product launches.
• When workflows or tools change. New apps, plugins, payment methods, checkout tools, or consent tools all justify retesting.
• After theme redesigns or template edits. Especially on product pages, carts, and thank-you pages.
• When attribution suddenly shifts. A rise in direct traffic, self-referrals, or unexplained order drops may signal tracking changes, not market changes.
• After analytics ownership changes. If a new marketer, developer, or analyst inherits the stack, use this checklist as the reset point.

For a practical recurring workflow, do this:

1. Run one end-to-end test order per important checkout path.
2. Verify core events in GA4 debug tools or your tag testing workflow.
3. Compare transaction IDs and revenue against platform records.
4. Check item-level parameters for at least three product types.
5. Confirm campaign attribution survives from landing page to purchase.
6. Record what changed and what passed.

If you want a lightweight habit, put this review on the calendar once per quarter and again before major campaigns. GA4 ecommerce tracking is rarely ruined by one dramatic failure. It usually drifts. A repeatable checklist is how you catch that drift before it reaches your dashboard, your budget decisions, or your CRO priorities.

The best outcome is not a perfect implementation on paper. It is a setup that your team understands, can test quickly, and can revisit whenever the platform stack changes. That is what makes this checklist worth keeping close.