GA4 Setup Checklist for Indian E-commerce Businesses

GA4 Setup Checklist for E-commerce Businesses in India

A reliable GA4 setup for e-commerce in India must track the full customer journey, from product discovery to payment confirmation, refund and repeat purchase. The most important work is not installing the GA4 tag; it is making sure product, order, payment and marketing data are sent consistently without duplicate purchases or missing transactions.

This GA4 setup checklist for e-commerce India is designed for Shopify, WooCommerce, custom stores and marketplace-led brands. It covers the technical setup, Indian payment behaviour, consent, GST-related reporting needs and the checks your team should complete before relying on GA4 data.

1. Decide What GA4 Must Answer

Before creating events, write down the business questions GA4 should answer. A small D2C brand and a multi-category online retailer may use the same GA4 events, but they may need different reports and audiences.

Common questions include:

• Which channels generate purchases, not just website visits?
• Which products receive views but rarely get added to cart?
• Where do customers leave the checkout?
• Do mobile visitors convert differently from desktop visitors?
• Are COD orders more or less likely to be cancelled or returned?
• Which campaigns bring new customers, repeat customers or high-value orders?
• Which products are frequently bought together?
• How much revenue comes from paid search, social media, email and direct traffic?
• Are payment failures happening on the website or at the payment gateway?
• What is the difference between orders placed and orders ultimately fulfilled?

GA4 can help answer many of these questions, but only if your event plan and transaction data are designed around them. It is not a complete accounting, inventory or customer relationship management system.

For Indian e-commerce businesses, it is useful to separate these concepts:

• Order value: The value recorded when the customer places an order.
• Payment status: Whether the order is paid, pending, failed or cash on delivery.
• Fulfilment status: Whether the order is packed, shipped, delivered, cancelled or returned.
• Net revenue: Order value after discounts, cancellations, refunds, shipping adjustments and other deductions.

GA4 can receive some of this information as event parameters, but your store backend, payment gateway, accounting software and order management system remain the source of truth for financial reconciliation.

Choose an implementation approach

Your implementation usually falls into one of three categories:

1. Platform integration: A native Shopify, WooCommerce or other platform integration sends basic data.
2. Google Tag Manager: GTM manages the GA4 tag and custom events using a data layer.
3. Custom or server-side implementation: A developer sends events directly through website code, server-side tracking or the Measurement Protocol.

A platform integration can be a useful starting point, but do not assume it covers your full funnel. Check whether it sends item details, refunds, transaction IDs, internal promotions, payment methods and consent signals correctly.

2. Create the GA4 and Google Tag Manager Foundation

Complete the account structure before adding tracking code.

Account and property checklist

• Create or confirm the correct Google account and business ownership.
• Create one GA4 property for the e-commerce website.
• Create a separate data stream for the production website.
• Use the correct website URL and protocol.
• Record the measurement ID in your implementation documentation.
• Give access to the business owner, marketing team, developer and agency as needed.
• Avoid creating multiple properties for the same store without a clear reporting reason.
• Keep test and production data separate where possible.
• Document who owns the Google account and recovery details.

The business should own the GA4 property, Google Tag Manager container and related advertising accounts. An agency or freelancer can be given access, but the business should not lose access when a vendor relationship ends.

Install the Google tag once

Install the Google tag through one controlled method. Common problems occur when:

• A Shopify app adds GA4.
• A developer adds the Google tag directly to the theme.
• Google Tag Manager also loads the tag.
• A marketing plugin adds another copy.

Multiple implementations can inflate users, sessions and events. Purchase duplication is especially serious because it can overstate revenue and return on ad spend.

Decide whether GA4 will be installed through:

• The e-commerce platform’s official integration.
• Google Tag Manager.
• Direct website code.
• A combination where the main tag and transaction events are clearly separated.

Do not add a second implementation simply because the first one is not showing the data you expect. First use Tag Assistant, browser developer tools and the GA4 DebugView to identify the problem.

Configure internal traffic

Exclude visits from your office, warehouse, agency or development team if they would distort reporting. Define internal traffic using reliable IP addresses where practical, and apply the internal traffic filter carefully.

For remote teams and mobile internet connections, IP-based exclusion may not be enough. Use a testing environment, debug mode and clear naming conventions rather than relying only on filters.

3. Build the E-commerce Event Plan

GA4 uses event-based measurement. For e-commerce, use Google’s recommended event names so reports, explorations and advertising integrations remain easier to manage.

The essential event sequence is:

You may also use view_promotion and select_promotion for banners, coupons and internal merchandising campaigns.

Required purchase event fields

The purchase event deserves the most attention. At minimum, capture:

• transaction_id
• value
• currency
• items

The currency for Indian orders will usually be INR. Use a consistent currency code rather than displaying the rupee symbol inside the numeric value.

Useful additional fields include:

• tax
• shipping
• coupon
• customer_type
• payment_type
• shipping_tier
• Product item ID
• Product name
• Product category
• Quantity
• Item price
• Item-level discount where supported

Do not send personally identifiable information such as a customer’s name, email address, phone number, full postal address or payment card details as normal GA4 event parameters. Hashing information does not automatically make it appropriate to send to an analytics platform. Treat customer data and consent as a separate privacy decision.

Use a stable item ID

Your item ID should match a dependable product or SKU identifier in your store. Avoid using a product name as the only identifier because names can change and variants may have similar titles.

For Indian stores with size, colour, pack size or language variants, decide whether the item ID represents:

• The parent product.
• The exact SKU.
• The variant.

For inventory and product-level analysis, the exact purchasable SKU is usually more useful. Document the convention so the marketing, product and operations teams interpret reports consistently.

Plan custom events carefully

Use recommended GA4 events for standard shopping actions. Create custom events only when they represent a genuine business action not covered by the standard list.

Examples may include:

• cod_selected
• payment_failed
• order_cancelled
• delivery_confirmed
• return_requested

These events can be useful, but they should not replace the standard purchase event. A payment failure is not a purchase, and a COD order may be a purchase at the time of order placement even though payment is collected later.

4. Handle Indian Payment and Checkout Journeys

Indian e-commerce checkouts often involve UPI, cards, net banking, wallets, buy-now-pay-later options and cash on delivery. Payment gateways may also redirect the customer to a different domain before returning them to the store.

Configure unwanted referrals

If a customer leaves your store for a payment gateway and returns after payment, GA4 may record the gateway as a new referral. This can overwrite the original source and create misleading attribution.

Review the payment services used by your store, such as:

• Razorpay
• Cashfree
• PayU
• CCAvenue
• Stripe
• Paytm payment services
• Bank-hosted payment pages
• Other gateway or checkout domains

Add genuine payment gateway domains to the unwanted referrals list where appropriate. The exact configuration depends on your checkout architecture. Test the result after making the change because some payment systems use multiple domains or redirect paths.

This setting does not solve every attribution problem. If the customer leaves the browser, blocks cookies or returns much later, the original session may still be difficult to preserve.

Track payment methods without exposing sensitive data

You can send a broad payment method such as:

• upi
• card
• netbanking
• wallet
• cod
• bnpl

Do not send card numbers, UPI IDs, bank account information, CVV values or payment gateway tokens to GA4.

For COD, decide when the business considers the conversion to have occurred. Many stores count an order at checkout confirmation, while others focus on delivered or collected orders for operational analysis. Use purchase for the order event, then use separate backend or CRM events for delivery, cancellation and return status.

Test failed and abandoned payments

Run controlled tests for:

• Successful UPI payment.
• Successful card payment.
• Payment failure.
• Customer cancellation during payment.
• Payment timeout.
• COD order.
• Gateway redirect followed by return to the store.
• Mobile checkout.
• Coupon applied during checkout.
• Shipping charge added at checkout.

Check whether each scenario creates the correct event, whether the purchase fires only once and whether the correct value reaches GA4.

5. Set Up Data Layer, GTM and Platform Tracking

For a reliable implementation, the website should expose structured product and order information to the tracking layer. A data layer helps developers and marketers use consistent values rather than scraping text from the page.

Data layer requirements

For product and transaction events, the data layer should make available:

• Product or SKU ID
• Product name
• Category and relevant category levels
• Brand, if applicable
• Variant
• Price
• Quantity
• Discount or coupon
• Currency
• Cart value
• Shipping value
• Tax value
• Transaction ID
• Payment type
• Shipping tier
• Promotion or list name

The exact structure depends on your platform and GTM implementation. What matters is that values are generated from the store’s actual product and order data.

Shopify considerations

Check whether your Shopify setup uses the platform’s current customer events and checkout capabilities, an app integration or custom tracking. Some checkout steps and checkout extensibility options may limit what can be added directly to theme files.

Confirm:

• Whether product views and cart actions are sent.
• Whether checkout and purchase events are available.
• Whether consent is respected before analytics cookies load.
• Whether refunds can be sent or reconciled.
• Whether the integration sends one transaction ID per order.
• Whether app-generated tracking duplicates GTM or theme tracking.

Do not assume that a tag visible on storefront pages also covers all checkout pages.

WooCommerce considerations

WooCommerce stores often use multiple plugins for analytics, payment, consent, caching and marketing. Plugin combinations can generate duplicate events or break after theme and plugin updates.

Review:

• The active GA4 or GTM plugin.
• Theme-level scripts.
• Checkout and thank-you page hooks.
• Payment gateway redirects.
• Order status and refund integration.
• Cache and optimisation settings.
• Consent management compatibility.

After updates, repeat the purchase and refund tests. A setup that worked before a plugin change may no longer send the same data.

Custom stores

For a custom website, define the event contract with the development team. This should specify event names, parameter names, data types, trigger conditions and examples.

If the purchase confirmation page can be refreshed, the implementation must prevent duplicate purchase events. Common approaches include storing the sent transaction ID or firing the transaction from a controlled order confirmation process. The correct approach depends on your architecture.

6. Configure Conversions, Audiences and Reports

GA4 no longer treats every important action as a standard “goal” in the older Universal Analytics sense. Mark important events as key events in the current GA4 interface, then connect them to advertising platforms only when appropriate.

Mark useful key events

For a store, likely key events include:

• purchase
• begin_checkout
• add_to_cart
• generate_lead for catalogue or enquiry-based businesses
• sign_up
• A confirmed subscription event, where relevant

Do not mark every interaction as a key event. A product view may be useful for analysis but is usually not a business conversion.

Keep the distinction between:

• Micro-conversions: Product view, add to cart, wishlist, account creation.
• Primary conversion: Completed order or qualified enquiry.
• Post-purchase events: Delivered order, repeat purchase, refund or return.

Build useful audiences

Potential audiences for an Indian e-commerce business include:

• Viewed a product but did not add it to cart.
• Added to cart but did not purchase.
• Began checkout but did not purchase.
• Purchased in the last 30, 60 or 90 days.
• First-time purchasers.
• Repeat purchasers.
• Purchased from a specific category.
• Used COD.
• Received a refund or requested a return.
• Customers who have not purchased again after a defined period.

Audience definitions should reflect your product’s buying cycle. A repeat purchase audience for cosmetics may need a different time window from one for furniture or appliances.

Use caution when creating audiences based on sensitive categories or personal characteristics. Analytics and advertising activity should follow applicable platform policies and the business’s privacy commitments.

Connect other Google tools

Connect GA4 with relevant tools such as:

• Google Ads
• Search Console
• BigQuery, where a suitable plan and technical capability are available
• Merchant Center, where relevant
• Looker Studio for reporting

Before importing conversions into Google Ads, check that the event is not duplicated by another conversion action. A purchase may be imported from GA4, tracked through Google Ads code and also counted by a platform integration. This can lead to inflated conversion numbers.

7. Add Privacy, Consent and Governance Controls

Indian businesses collecting customer information should treat analytics governance as part of the setup, not an afterthought. The Digital Personal Data Protection Act, 2023 and related rules may affect how organisations collect, use and manage personal data. The exact obligations depend on the business, data processing activity and current legal requirements.

This checklist is not legal advice, but the implementation should be reviewed with a qualified privacy or legal professional where needed.

Consent management

If your website uses a consent management platform, configure it so analytics and advertising tags behave according to the user’s choices. Do not load all tags first and ask for consent afterwards if that conflicts with your declared privacy approach or applicable requirements.

Check:

• Whether analytics cookies are blocked until the appropriate consent.
• Whether advertising consent is separate from analytics consent.
• Whether the consent banner explains categories in plain language.
• Whether users can change or withdraw consent.
• Whether consent signals are passed to Google tags and advertising tools.
• Whether the banner works on mobile and across checkout pages.
• Whether regional rules require different behaviour for different visitors.

Consent should not be hidden in an inaccessible policy page. The user interface, privacy notice and technical configuration should match each other.

Data minimisation

Do not send:

• Names
• Email addresses
• Telephone numbers
• Full addresses
• Payment card data
• UPI IDs
• Bank details
• Order notes containing personal information

Review URLs as well. A customer email address or phone number should not appear in query parameters, page URLs or event parameters.

Set appropriate data retention, user deletion and access processes. Document who can access raw analytics data and how long business reports are retained.

8. Validate the Setup Before Reporting

Never treat the appearance of a few visits in GA4 as proof that the implementation works. Validate each event and compare it with the website backend.

Technical testing checklist

Use Google Tag Assistant, GTM Preview, GA4 DebugView and browser developer tools to check:

• The Google tag loads only once.
• Page views are not duplicated.
• Product view events contain the correct item.
• Add-to-cart events contain the correct quantity and value.
• Checkout events fire at the intended step.
• Payment method data is broad and non-sensitive.
• Purchase fires after a confirmed order.
• Purchase fires only once per transaction.
• Transaction IDs are not blank or reused incorrectly.
• Currency is consistently INR for Indian orders.
• Tax, shipping and discounts are represented consistently.
• Refund events use the original transaction ID.
• Internal traffic is excluded as intended.
• Consent changes affect tag behaviour.
• Payment gateways do not become the main source of completed orders.
• Cross-domain or redirect journeys preserve attribution as far as possible.

Compare GA4 with the order system

Select a test period and compare:

• Number of successful orders.
• Total order value.
• Transaction IDs.
• Refunds.
• Currency.
• Product quantities.
• New and returning customer indicators.
• Device and channel dimensions.

GA4 totals will not always match your order management system exactly. Differences can result from consent refusal, ad blockers, browser restrictions, time zone settings, attribution rules, refunds recorded later and orders that are cancelled after purchase. The purpose of reconciliation is to understand and control the differences, not to force every platform to show identical numbers.

Review reports after processing time

Some GA4 reports update at different speeds. Use DebugView for immediate event testing and standard reports or explorations for broader analysis. Do not make a major marketing decision from a partial same-day data view without understanding the reporting delay and attribution window.

Create a simple monitoring routine:

• Daily check for purchase event volume and obvious breaks.
• Weekly comparison with orders and revenue.
• Monthly review of traffic sources, product performance and checkout drop-offs.
• Review after website, theme, plugin, payment gateway or consent-banner changes.

Common GA4 Mistakes in Indian E-commerce

Counting page views as purchases

A thank-you page view is not automatically a valid transaction. If the page can be refreshed, shared or visited later, a purchase tag may fire repeatedly. Use the order transaction ID and a controlled trigger.

Using inconsistent transaction IDs

One system may use an order number, another may use an internal database ID and a third may append a payment reference. Choose a stable convention and document it.

Ignoring refunds and cancellations

Revenue can look healthier than reality if refunds, cancelled orders and returns are never considered. GA4 refund tracking may not fully replace backend reconciliation, but it gives marketing and product teams useful context.

Treating COD orders like collected revenue

A COD order can be placed but later refused or cancelled. Track the original order and the later fulfilment outcome separately.

Keeping payment gateways as referral sources

This can make a paid campaign or organic search visit appear to have no role in the conversion. Review referrals after testing successful payment journeys.

Installing multiple plugins

Multiple analytics plugins can duplicate page views, add-to-cart events and purchases. Audit all scripts before adding another integration.

Reporting only on sessions

Sessions are useful for context, but e-commerce decisions should include product engagement, checkout progression, transaction value, refunds and customer type.

Frequently Asked Questions

Is GA4 enough for e-commerce reporting in India?

GA4 is useful for customer journey, traffic, product and marketing analysis, but it is not a replacement for your order management, accounting, inventory or GST records. Use your store and finance systems as the source of truth for invoices, tax reporting, settlements and net revenue.

What is the most important GA4 event for an online store?

The purchase event is usually the most important because it connects a completed order with value, currency, transaction ID and products. It must be implemented carefully because duplicate or missing purchases can affect revenue reports and advertising decisions.

Should an Indian website track UPI and COD separately?

Yes, broad payment-method information can help you compare checkout behaviour and post-order outcomes. Track methods such as UPI, card and COD without sending sensitive payment details, and analyse COD cancellations or delivery outcomes separately from the initial order.

Why does GA4 revenue not match Shopify or WooCommerce revenue?

Differences can arise from consent choices, blocked tags, refunds, cancellations, time zones, attribution models, currency settings and duplicate or missing transaction events. Compare transaction IDs and order statuses rather than comparing only the headline revenue totals.

Do I need Google Tag Manager for GA4?

No. A platform integration or direct code installation can work for a straightforward store. GTM becomes useful when you need controlled event management, consent conditions, custom data-layer variables, multiple marketing tags or frequent changes without editing website code.

Should I use server-side tracking?

Server-side tracking can improve control and resilience in some implementations, but it adds development, hosting, privacy and maintenance requirements. It should be considered after the browser-side event plan, consent setup and transaction reconciliation are working correctly.

Where to Start

Begin by documenting your store platform, checkout flow, payment gateways, order statuses and required business reports. Then create the GA4 event plan, choose one implementation method, configure consent and payment referrals, and test the complete journey using real product and order scenarios.

After launch, compare GA4 transaction IDs and revenue with your store backend, monitor purchases and refunds regularly, and repeat the checks after every major website or plugin change. If you need help planning or reviewing the implementation, you can talk to the Govindani Infotech team on WhatsApp; project scope and pricing are confirmed there.