The Complete GA4 Ecommerce Tracking Checklist.

GA4 ecommerce tracking is deceptively simple on the surface — push a few events with an items array and you're done. In reality, most implementations we audit have critical issues that silently corrupt revenue data, break funnel reports, and misattribute product performance. GA4 ecommerce is the highest-stakes area of your implementation because errors directly impact business decisions about products, marketing spend, and inventory.

This comprehensive checklist covers every event, required parameter, and validation step you need for accurate GA4 ecommerce reporting — from the first product impression to the completed purchase and beyond. For the full step-by-step GTM setup, see our complete GA4 ecommerce tracking guide.

Skip the manual check: the enhanced ecommerce audit walks the full view_item → add_to_cart → begin_checkout → purchase funnel, cross-references the items[] schema against your GA4 reports, and flags the exact step where your revenue number diverges from Shopify/Stripe — in 60 seconds, no QA session required.

Required Ecommerce Events

GA4 ecommerce uses a predefined set of events that map to a typical shopping funnel. At minimum, implement view_item, add_to_cart, begin_checkout, and purchase. These four events give you a functional conversion funnel and are the foundation of all ecommerce reporting in GA4.

purchase

The most critical event in your implementation. Fires when an order is completed. Errors here directly affect revenue reporting, attribution, and ROAS calculations. Every purchase event must include transaction_id, value, currency, and a populated items array.

dataLayer.push({ ecommerce: null });
dataLayer.push({
  event: 'purchase',
  ecommerce: {
    transaction_id: 'T-12345',
    value: 99.98,
    tax: 8.50,
    shipping: 5.99,
    currency: 'USD',
    coupon: 'SUMMER10',
    items: [{
      item_id: 'SKU_001',
      item_name: 'Blue Widget',
      item_brand: 'Acme',
      item_category: 'Widgets',
      item_category2: 'Blue',
      price: 49.99,
      quantity: 2,
      discount: 0
    }]
  }
});

begin_checkout

Fires when the checkout process begins, marking the transition from browsing to buying intent. This event is the primary input for checkout funnel analysis. Include all items currently in the cart so GA4 can attribute checkout starts to specific products.

add_to_cart

Fires when a user adds a product to their shopping cart. Should include the exact quantity and variant information. This event powers add-to-cart rate reports and is essential for understanding which products drive intent without converting.

Recommended Events

Beyond the required minimum, these events significantly improve funnel visibility and product performance reporting. None are mandatory, but each one fills a specific measurement gap that absence makes invisible.

view_item

Fires on the product detail page. This is one of the most important funnel events for measuring conversion rate by product — it establishes the denominator for the add-to-cart rate. Without it, you cannot tell whether a low-selling product is being overlooked or viewed and rejected.

view_item_list

Fires on product listing or category pages when products are displayed. Captures which products were shown and in what order (list position). Enables impression-to-click analysis and lets you measure whether product placement in a list affects conversion.

Additional Funnel Events

• select_item — Fires when a user clicks on a product from a list. Captures which product was selected and from which list.
• remove_from_cart — Often overlooked but important for understanding cart abandonment behavior.
• view_cart — Fires when the user views their cart page. Include all items currently in the cart.
• add_shipping_info — Fires when shipping information is provided. Include the shipping_tier parameter.
• add_payment_info — Fires when payment information is provided. Include the payment_type parameter.

Parameter Requirements

Every ecommerce event must include an items array containing the products involved. Each item object has required and recommended parameters that determine which GA4 reports are populated.

The Items Array

• item_id (required): Your product's unique identifier (SKU, product ID). Without this, product-level reports are empty.
• item_name (required): The product name as displayed to the user.
• price (recommended): The unit price as a number (not a string). Must be the individual item price, not the total.
• quantity (recommended): The number of units. Defaults to 1 if omitted.
• item_brand (optional): The brand or manufacturer name.
• item_category (optional): Primary product category. GA4 supports up to 5 category levels (item_category through item_category5).
• item_variant (optional): Product variant (size, color, etc.).
• discount (optional): Per-item discount amount.
• coupon (optional): Coupon code applied to this item.

Top-Level Purchase Parameters

The purchase event requires these top-level parameters in addition to the items array:

• transaction_id (required): Unique order identifier. GA4 uses this for deduplication.
• value (required): The total order value as a number.
• currency (required): ISO 4217 currency code (USD, EUR, GBP). Must match the price currency.
• tax (recommended): Tax amount as a number.
• shipping (recommended): Shipping cost as a number.
• coupon (optional): Order-level coupon code.

Common Implementation Mistakes

These are the recurring issues found across ecommerce implementations. Each one silently corrupts a different part of your GA4 reporting.

Missing item_id

Without item_id, GA4's product-level reports (most popular products, product performance, item purchase quantity) are completely empty. Purchase events still fire and revenue still records — the data just has no product association. This is the most common ecommerce tracking error and the easiest to miss.

Currency mismatches or missing currency

Sending value: 49.99 without currency: 'USD' breaks revenue reports. GA4 requires the currency parameter on every ecommerce event with a monetary value. If your site supports multiple currencies, ensure the currency matches the price values in the items array. Mixed currencies in the same event will corrupt your revenue data.

Duplicate purchases from missing transaction_id

The transaction_id must be unique per order. If users refresh the thank-you page, re-open a confirmation email, or navigate back to the confirmation page, the purchase event fires again. Without a unique transaction_id, GA4 counts it as a new purchase, inflating your revenue. Always implement server-side deduplication or use a flag in session storage to prevent duplicate fires.

Not clearing the ecommerce object

You must push dataLayer.push({ ecommerce: null }) before every ecommerce event. Without this clear step, GTM may merge old product data with new events, creating phantom products in your reports where a previous event's items bleed into the next push.

Price as a string instead of a number

Sending price: "49.99" (string) instead of price: 49.99 (number) causes GA4 to treat the value as text rather than a numeric value. Revenue calculations will not work, average order value will be zero, and product performance metrics will be empty.

Testing and Verification

Before going live with your ecommerce implementation, verify each event fires correctly and carries the right data. There are two primary tools for this: the GA4 DebugView and GTM Preview mode.

Using GA4 DebugView

Enable debug mode by adding ?gtm_debug=x to any page URL (when using GTM) or by setting debug_mode: true in your gtag config. Then open GA4 DebugView (Configure → DebugView). As you interact with your site, events appear in real time. For each ecommerce event, expand the event to verify the items array and all required parameters are present with the correct values and types.

Purchase Event Validation Checklist

Before going live with your purchase event, verify each of these items:

• transaction_id is unique per order and does not change on page refresh
• value matches the actual order total (including tax and shipping if applicable)
• currency is present and matches the price currency (ISO 4217 format: USD, EUR, GBP)
• Each item has item_id and item_name
• price is a number, not a string
• quantity reflects the actual quantity purchased
• ecommerce: null push precedes the purchase push
• The event only fires once per transaction (no duplicate fires on refresh)
• Tax and shipping are included if your reporting requires them

Refund Tracking

GA4 supports refund tracking through the refund event. This is critical for accurate revenue reporting — without refund tracking, your GA4 revenue will always be higher than actual revenue:

dataLayer.push({ ecommerce: null });
dataLayer.push({
  event: 'refund',
  ecommerce: {
    transaction_id: 'T-12345',  // Must match original purchase
    value: 49.99,
    currency: 'USD',
    items: [{
      item_id: 'SKU_001',
      quantity: 1
    }]
  }
});

Key Takeaways

• At minimum, implement view_item, add_to_cart, begin_checkout, and purchase events for a functional ecommerce funnel.
• Every item must have item_id and item_name — without these, product-level reports are empty.
• Always include currency, use numeric values for price, and ensure transaction_id is unique per order.
• Clear the ecommerce object (ecommerce: null) before every ecommerce dataLayer push to prevent data bleeding between events.
• Implement refund tracking to keep GA4 revenue aligned with actual business revenue.

Frequently Asked Questions

What GA4 ecommerce events are required?

GA4 does not enforce a strict minimum, but for functional ecommerce reporting you need at least four events: view_item, add_to_cart, begin_checkout, and purchase. These four establish a conversion funnel from product view to completed order. The purchase event is non-negotiable — without it, GA4 records no revenue. The other three give you the funnel context to understand where users drop off before purchasing.

What is the difference between GA4 ecommerce and enhanced ecommerce?

Enhanced ecommerce was a Universal Analytics feature that required a specific plugin and had its own implementation model. GA4 ecommerce replaces it with a native event-based model using the standard gtag.js or dataLayer approach — no plugin required. The key structural difference is that GA4 uses a flat items array rather than UA's nested products array, and event names have changed (for example, UA's productClick becomes GA4's select_item). If you are migrating from UA enhanced ecommerce, every event name and most parameter names will need updating.

How do I track purchases in GA4?

Push a purchase event to the dataLayer on your order confirmation page, immediately after the order is confirmed. The event must include transaction_id (unique order ID), value (order total as a number), currency (ISO 4217 code), and an items array with at least item_id and item_name for each product. Always push { ecommerce: null } to the dataLayer first to clear any previous ecommerce data. If you use GTM, configure a Custom Event trigger on the purchase event name and read the parameters from the dataLayer.

What parameters does the GA4 purchase event require?

The purchase event has three required top-level parameters: transaction_id, value, and currency. Inside the items array, each item requires item_id and item_name. Recommended but not strictly required are tax, shipping, coupon at the top level, and price, quantity, item_brand, and item_category at the item level. Omitting the recommended parameters does not break the event, but it leaves those report dimensions empty.

How do I test GA4 ecommerce tracking?

The primary tool is GA4 DebugView. Enable debug mode by adding ?gtm_debug=x to your URL (if using GTM) or by passing debug_mode: true in your gtag configuration. Then open GA4 and navigate to Configure → DebugView. Trigger each ecommerce event on your site and verify in real time that the correct event name appears, the items array is populated, and all numeric parameters have numeric values (not strings). For the purchase event, also confirm the event fires only once per transaction by refreshing the confirmation page and checking that no duplicate appears.

Why is my GA4 purchase event not recording revenue?

The most common causes are: (1) the currency parameter is missing from the event — GA4 requires it to process the value; (2) value or price is passed as a string rather than a number — GA4 will not aggregate text as revenue; (3) the event is firing before the order is confirmed, so GA4 receives it but with a zero or missing value; (4) the currency in the event does not match the currency configured in the GA4 property settings. Check all four in DebugView before looking for more obscure causes.

Does GA4 ecommerce work with Shopify?

Yes. Shopify exposes purchase data through its checkout events and the checkout.liquid / additional scripts area (or via the Shopify Web Pixel API in newer stores). The standard approach is to push GA4 ecommerce events from the order status page using Shopify's Liquid variables (checkout.order_id, checkout.total_price, checkout.line_items, etc.) mapped to the GA4 purchase schema. The most common Shopify-specific mistake is using plural URL paths — Shopify uses /products/ and /collections/, not the singular forms — which affects event trigger matching in GTM. Our Shopify GA4 tracking guide covers the full implementation.

What is the item_id parameter in GA4 ecommerce?

item_id is the unique identifier for a product in your catalog, typically a SKU or internal product ID. It is the primary key GA4 uses to associate ecommerce events with specific products in reports like Item Purchase Quantity and Item Revenue. Without a consistent item_id across events, GA4 cannot connect a view_item on Monday with the purchase of the same product on Wednesday. The value should be stable — if you change a product's item_id, historical data for that product will appear as a separate item in reports. Use the same identifier you use in your product catalog or order management system.