Tracking Done Right #2: cart_update - WHEN, WHAT, WHERE, and WHY It Matters

How to properly track cart interactions to reduce abandonment, optimize checkout, and boost revenue.

Introduction

Without proper cart_update tracking, businesses operate in the dark—unable to detect purchase hesitation, optimize checkout flows, or recover lost revenue. This event provides insights into how users interact with their shopping carts—whether they’re adding products, removing them, or adjusting quantities.

According to the Baymard Institute, 70.19% of online shopping carts are abandoned (Baymard). That means 7 out of 10 users leave without completing their purchase. Without proper cart_update tracking, businesses miss critical data on why customers drop off, making it harder to improve checkout experiences and recover lost revenue.

In this guide, we’ll break down WHEN, WHAT, WHERE, and WHY you should track cart_update, ensuring your setup is optimized for accurate data collection and actionable insights.

👉 If you missed the first part of this series, check it here:

Tracking Done Right #1: view_item – WHEN, WHAT, WHERE, and WHY It Matters

---

WHEN Should You Fire the cart_update Event?

The cart_update event should fire every time a user modifies their cart. Unlike view_item, which is mostly passive tracking, cart_update requires precise logging of user interactions that affect the purchase decision.

This sequence diagram illustrates when and how the cart_update event should fire based on different cart interactions.

Separate vs. Single Event

While some platforms require separate events for actions such as add_to_cart and remove_from_cart (Meta, Google, etc.), Bloomreach recommends consolidating these actions under a single cart_update event, utilizing the action field (add, remove, update, empty, restore) to distinguish between them.

1. When a Product is Added to the Cart (add)

Scenario: A user adds an item to their cart from a Product Detail Page (PDP), category page, or quick-view modal (any point where a user can add an item to the cart).

🔥 Action: Fire a cart_update (add_to_cart) event with:

• action = "add"

• etc. (See the WHAT section for full attribute details.)

✅ Best Practice:

• Ensure cart_update fires only after a successful cart update (not just button click).

💡 Why This Matters:

• Tracking first-time product additions helps optimize recommendations, pricing strategies, and retargeting efforts.

2. When a Product is Removed from the Cart (remove)

Scenario: A user removes an item from their cart via the cart page, mini-cart, or checkout page.

🔥 Action: Fire a cart_update (remove_from_cart) event with:

• action = "remove"

• etc. (See the WHAT section for full attribute details.)

✅ Best Practice:

• Ensure cart_update fires only after the item is successfully removed from the cart. If the user removes all items, track action = "empty" instead of multiple remove events.

💡 Why This Matters:

• Tracking cart removals helps identify drop-off points, pricing hesitations, and user behavior patterns, enabling retargeting and recovery strategies.

3. When a Product in the Cart is Updated (update)

A user modifies a product in their cart from the cart page, mini-cart, or checkout page by:

• Changing quantity (increasing or decreasing).

• Updating a product variant (e.g., size, color, or customization).

🔥 Action: Fire a cart_update event with:

• action = "update" (indicates the product remains in the cart but with changes).

• update product_list to reflect the latest cart state.

• etc. (See the WHAT section for full attribute details.)

✅ Best Practice:

• If the user reduces quantity to 0, fire action = "remove" instead of "update".

• If the cart becomes empty, fire action = "empty" instead of multiple "remove" events.

• Ensure the final cart state is correctly reflected in product_list

• Ensure cart_update fires only after the quantity change is successfully processed to prevent duplicate tracking.

💡 Why It Matters:

• Captures user intent shifts – A quantity increase signals higher buying intent, while a decrease or variant switch may indicate hesitation, price sensitivity, or reconsideration.

• Improves retargeting efforts – Instead of a generic abandoned cart campaign, businesses can personalize offers based on the last selected quantity or variant.

• Optimizes checkout experience – If users frequently switch variants or sizes, this could highlight gaps in product descriptions, missing reviews, or lack of sizing guidance.

4. When a Cart is Cleared (empty)

Scenario 1: User Clicks the "Empty Cart" Button

A user actively clears their cart by clicking the "Empty Cart" button.

🔥 Action: Fire a cart_update with:

• action = "empty" only when the user clicks the "Empty Cart" button.

• empty_reason = "user_clicked_empty_cart" to indicate that the user intentionally emptied the cart through a direct action.

Scenario 2: User Removes Last Item From Cart

A user removes the last item from their cart without clicking the "Empty Cart” button.

🔥 Action: Fire two cart_update events with:

• 1st cart_update event:

  • action = "remove" for the last item removed.

• 2nd cart_update event:

  • action = "empty" to explicitly mark the cart as cleared

  • empty_reason = "last_item_removed" to indicate that the cart became empty due to item-by-item removal rather than an explicit clear action.

  • Note: This doesn’t always need to be explicitly tracked, as it can be inferred from the remove event if product_list is tracked. Depending on your tracking setup, it may be easier to track empty as a standalone event rather than deriving it from remove.

✅ Best Practice:

• Track empty_reason to distinguish between explicit cart emptying and item-by-item removal.

• Ensure the final cart state is correctly reflected in product_list when emptied via remove events.

• Fire empty only once when the cart reaches zero items to avoid duplicates.

💡 Why This Matters:

• Tracking when and how the last item is removed helps differentiate between gradual cart abandonment (last_item_removed) and deliberate full abandonment (user_clicked_empty_cart).

• Understanding cart clearances allows businesses to identify purchase hesitations, pricing concerns, and checkout friction. Users who empty their cart may be reacting to unexpected costs, product uncertainty, or a poor user experience.

• These insights support more effective retargeting strategies, exit-intent interventions, and checkout optimizations to help recover lost sales.

5. (OPTIONAL) When a Cart is Restored (restore)

Scenario: A user returns to the website after leaving, and their cart is automatically restored (e.g., from cookies, user login, or an abandoned cart email).

🔥Action: Fire a cart_update event with:

• action = "restore" (to indicate a cart has been retrieved).

• restore_source (e.g., "user_login", "email_click", "session_resume").

• restored_items_count (number of items recovered).

💡 Why It Matters: Helps businesses track cart recovery effectiveness (e.g., which methods bring users back).

IMPORTANT:

• Ensure the final cart state is correctly reflected in product_list

• Ensure cart_update fires only after the change/action is successfully processed to prevent duplicate tracking.

---

WHAT Data Should Be Tracked in cart_update?

For cart_update to be actionable, it must capture key details about the event, product attributes, action type, and session context. Proper tracking enables businesses to optimize retargeting, personalization, and checkout experience.

Core Identifiers

These attributes uniquely identify the cart and products involved in the update.

• product_id – ID of the product ("product" can be an umbrella for multiple variants)

• variant_id – ID of the specific variant. (most specific id with specific variant - including color, size, material)

• cart_id – Unique identifier for the shopping cart.

• action – Type of cart action (add, remove, update, empty, restore).

Product Attributes

These fields describe the product and its classification. Here you can track the same attributes as you tracked with the view_item.

• title – Product name.

• brand – Brand name.

• tags – Custom tags describing the product (e.g., "new", "sales", "teen").

• Other attributes – Track the same attributes as in view_item, including category information, pricing, and stock levels.

💡 Note: For more details on additional product attributes, check out our previous blog post—Tracking Done Right #1: view_item – WHEN, WHAT, WHERE, and WHY It Matters. Also, don’t forget to track multi-currency data for more accurate insights!

Cart & Session Attributes

These attributes track cart contents, user interactions, and checkout behavior in real time.

• product_list – A JSON object containing all products in the cart after the update, where each product entry includes product_id and quantity (reflecting the final cart state).

• product_ids – List of product IDs in the cart after the update.

• variant_list – A JSON object containing all variants in the cart after the update, where each variant entry includes variant_id and quantity (reflecting the final cart state).

• variant_ids – List of all variant IDs.

• total_products – Total number of unique products in the cart.

• total_quantity – Total number of all product units in the cart.

• total_price_local_currency – Final price of the entire cart in local currency.

• total_price_without_tax – Price of the cart excluding tax.

• total_price – Final price of the cart including tax, shipping, and discounts.

• currency_code – Currency format (USD, EUR).

Page & URL Information

These attributes provide context on where the cart update happened.

• location – Full URL of the page where the event occurred.

• domain – Website domain (e.g., webshop.com).

• referrer – URL of the previous page that led to this page.

• language – Language of the website the user is viewing (e.g., "en", "fr", "de").

Additional Attributes for Advanced Use Cases

These fields help with device tracking, campaign attribution, and behavioral analysis.

• Device & Browser Information – Capture device type (Desktop, Mobile), OS, and browser.

• Screen & Display Attributes – Screen resolution, viewport size.

• Campaign & Attribution Tracking – UTM parameters (utm_source, utm_medium, utm_campaign).

• Cart Status – Tracks whether the cart is active, abandoned, or recovered based on user behavior.

By ensuring cart_update events track these details, businesses gain deeper insights into shopping behavior, optimize marketing strategies, and improve the checkout experience.

---

WHERE Should cart_update Be Tracked?

To maximize its value, cart_update should be tracked across key platforms:

1. Analytics & Data Platforms (For Reporting & Insights)

Tracking cart_update in analytics tools helps businesses analyze cart behavior, identify friction points, and optimize conversion rates.

• Analytics & Attribution Platforms (GA 4, Adobe Analytics, etc.) – Helps measure cart engagement and funnel drop-offs.

• Data Warehouses (BigQuery, Snowflake, Redshift, etc.) – Stores cart behavior data for deeper analysis.

✅ Best Practice: Ensure consistent event tracking across platforms to maintain data accuracy in reporting.

2. Retargeting & Advertising Platforms (For Cart Abandonment Campaigns)

cart_update should be tracked in ad platforms to enable retargeting campaigns for users who abandoned their carts.

• Meta Ads (Facebook & Instagram) – Enables Dynamic Product Ads for cart abandoners.

• Google Ads (Performance Max, Display, YouTube) – Uses cart data for remarketing.

• TikTok, Pinterest Ads – Leverages shopping cart insights for retargeting.

✅ Best Practice: Ensure cart_update tracking matches catalog data to avoid product feed mismatches in ads.

3. Customer Data & Personalization Platforms (For Smart Segmentation & Automation)

These platforms use cart_update data to build real-time audience segments, trigger automations, and personalize marketing messages across multiple channels.

• Bloomreach Engagement - Unlike other platforms that either store data (Segment, Tealium) or execute campaigns (Braze, Klaviyo), Bloomreach does both—ingesting cart data in real time, segmenting users with AI, and instantly triggering personalized multi-channel campaigns—all in a single platform enabling:

  • AI-powered personalization – If a customer frequently abandons high-value items, Bloomreach AI detects this behavior and automatically triggers personalized incentives, product recommendations, or targeted reminders to encourage purchase completion. (Source)

  • Predictive personalization – Analyze likelihood of purchase and trigger automated interventions (e.g., dynamic price adjustments or exit-intent offers).

  • Omnichannel execution – Automatically deliver personalized abandoned cart campaigns across email, SMS, push, in-app, and web without needing external orchestration tools.

• Segment, mParticle, Tealium (CDPs) – These platforms act as data pipelines, aggregating cart_update data from multiple sources to maintain a unified customer profile. However, unlike Bloomreach, they do not provide native automation or activation capabilities, requiring additional tools (like Braze or HubSpot) for campaign execution.

• Braze, Klaviyo, HubSpot, Salesforce Marketing Cloud – These platforms execute cart-based marketing campaigns but rely on external data sources (like Segment or Tealium) to ingest and unify cart data. They enable:

  • Cart abandonment sequences based on cart_update triggers.

  • Behavioral retargeting via email, SMS, and mobile push.

  • Basic segmentation (e.g., cart value thresholds, last update timestamps).

By integrating cart_update tracking with Bloomreach Engagement, businesses gain a complete solution—combining real-time data ingestion, AI-powered segmentation, and automated omnichannel activation—all within a single platform.

✅ Best Practice: If using a CDP, track cart_update server-side where possible to improve data reliability, prevent tracking loss, and reduce ad-blocker interference.

4. E-Commerce Platforms (For Checkout Optimization)

• Shopify, Magento, Salesforce Commerce Cloud – Tracks cart interactions for checkout improvements.

cart_update should be tracked across analytics, advertising, personalization, and e-commerce platforms to maximize customer insights, improve retargeting efforts, and enhance automation workflows.

---

WHY Track cart_update and What Business Use Cases Does It Enable?

Tracking cart_update is essential for reducing cart abandonment and improving revenue. Here’s how businesses can use this data:

1. Cart Abandonment Recovery

• Trigger automated emails, SMS, or push notifications to recover lost carts.

• Offer limited-time discounts or free shipping incentives.

2. Retargeting & Advertising

• Retarget users who added items but didn’t complete checkout.

• Create lookalike audiences of high-intent shoppers.

3. Personalized Recommendations

• Suggest complementary products based on cart contents.

• Display dynamic checkout upsells.

4. Checkout Flow Optimization

• Identify friction points where users frequently remove items.

• A/B test checkout features (e.g., guest checkout vs. account creation).

5. Inventory & Dynamic Pricing Adjustments

• Show stock urgency alerts (e.g., “Only 2 left in stock”).

• Trigger price drop alerts for previously added items.

6. AI-Driven Segmentation & Predictive Insights

• Identify users likely to abandon carts and trigger retention strategies.

• Segment price-sensitive shoppers based on cart modifications.

---

💡 Conclusion & Key Takeaways

Tracking cart_update is critical for improving conversion rates, recovering lost sales, and optimizing customer journeys.

✅ Best Practices for Tracking cart_update

1. Ensure all cart interactions are tracked (add, remove, update, empty, restore).

2. Use consistent event attributes for accurate reporting and automation.

3. Sync cart data with advertising platforms for effective retargeting.

4. Leverage AI-driven segmentation for better personalization.

5. Validate event tracking regularly to prevent data discrepancies.

6. Ensure the final cart state is correctly reflected in product_list.

Accurate cart_update tracking isn’t just about data—it’s about understanding shoppers, reducing friction, and driving more sales. Implement these best practices today and turn abandoned carts into revenue opportunities.

🚀 Looking to optimize your event tracking and activation strategy? Schedule a FREE 30-minute consultation and build a data-driven strategy that drives real business results.