Technical Guide: Triggering Braze In-App Messages from Commerce Events

For modern commerce applications, real-time, context-aware communication is essential for driving conversions and elevating the user experience. The most effective way to communicate with a user at their moment of intent—such as confirming an action, promoting an upsell, or recovering an abandoned cart—is through an in-app msg (Braze). Unlike traditional email or asynchronous push notifications, in-app messages provide immediate, synchronous feedback while the user is actively engaged with the app or website. This technical guide outlines the necessary implementation and configuration steps to reliably trigger Braze in-app messages based on core commerce events.

I. Foundational Data Strategy: Event Logging and Properties

The foundation for triggering any message from a commerce event (e.g., viewing a product, adding to cart) is the reliable logging of these actions as Custom Events within the Braze SDK. The quality of the trigger depends entirely on the data included with the event.

A. Defining Key Commerce Events

Development teams must ensure specific commerce actions are captured immediately as Braze events. While Braze provides specific methods for Purchase Events, most other commerce actions—like “Product Viewed,” “Added to Cart,” or “Checkout Started”—are logged as Custom Events.

• Purchase Event: Crucial for confirming orders and calculating revenue.
• Added to Cart Event: Essential for building cart recovery strategies.
• Product Viewed Event: Used for triggering retargeting or upsell messages based on specific product interest.

See also: The Ultimate Guide to Construction Takeoff Services, Lumber Takeoff Services & Mechanical Takeoff Services

B. Attaching Event Properties

When a commerce event is logged, it must include Event Properties. These are key-value pairs that describe what happened, not just that it happened.

• For an “Added to Cart” event, properties should include the product name, product ID (SKU), price, and the current total value of the cart.
• For a “Product Viewed” event, properties should include the category and the variant ID (e.g., size or color).

These properties are indispensable because they allow for granular segmentation and highly relevant personalization, which is validated in the Braze dashboard’s Data Settings.

II. Braze Dashboard Configuration: Setting the Trigger

Once the data stream is verified, the marketing operations team configures the in-app message campaign within the Braze dashboard using the Action-Based Delivery trigger.

A. Selecting Action-Based Delivery

When creating a new In-App Message campaign, the Delivery method must be set to Action-Based. The trigger is then defined by selecting the relevant Custom Event logged in the first step. For example, selecting “Performs Custom Event” and choosing the “Added to Cart” event.

B. Implementing Property Filters for Precision

To prevent generic messages and ensure messages are highly relevant, the trigger should be narrowed using the Event Properties that were logged from the SDK.

• Example Use Case: A campaign designed to promote financing options should only trigger when the user adds a high-value item (e.g., above a certain price threshold).
• Configuration: A filter condition is applied directly to the trigger: The message only fires if the custom event’s price property is greater than the defined threshold.

This mechanism ensures the message is shown only to users performing a specific action with specific financial or category characteristics.

C. Re-Eligibility and Frequency Controls

Since commerce actions can be frequent (a user might view or add many items sequentially), strict frequency controls are mandatory to protect the user experience.

1. Re-Eligibility: This setting defines the minimum time delay before the same user can trigger this specific in-app message campaign again (e.g., “re-eligible after 24 hours”).
2. Global Frequency Capping: This limits the total number of in-app messages a user sees from any campaign within a given timeframe, preventing message overload.

III. Personalization and Action: Making the Message Relevant

The effectiveness of triggering an in-app message from an event lies in using the real-time event data to personalize the message content and guide the user immediately to the next step.

A. Injecting Real-Time Data

When the in-app message is triggered, all associated event properties are temporarily made available for use in the message template via Liquid Templating.

• The message composer uses specific Liquid syntax to reference these properties (e.g., referencing the product_name to display the exact item the user just added).
• This allows the message to greet the user with “Your Limited Edition T-Shirt has been added!” which is far more engaging than a generic confirmation.

B. Deep-Linking the Call-to-Action (CTA)

The CTA button in the in-app msg (Braze) must reduce friction by sending the user directly to the necessary destination.

• CTA Configuration: The button action should be set to Deep Link.
• URL: The link should point to a specific page or location within the app (e.g., linking directly to the cart, the checkout page, or the product details page for an upsell). This is crucial for guiding the user immediately after the message closes.

IV. Advanced Use Case: Delayed Abandoned Cart Recovery

For sophisticated, time-sensitive use cases like cart abandonment, the trigger logic requires a delay mechanism, which is best managed using a Braze Canvas (customer journey builder).

1. Canvas Entry: The user enters the Canvas when they perform the commerce event, such as the “Added to Cart” custom event.
2. Delay: A Delay component is added (e.g., 30 minutes). This provides the user with time to complete the purchase on their own.
3. Exit Check: An Audience Step is configured immediately after the delay to check if the user has completed the “Purchase” event during the delay window. Users who purchased exit the Canvas immediately.
4. Message Delivery: Only users who have not purchased proceed to the final step, which is the Message Step containing the abandoned cart in-app msg (Braze).

This layered approach ensures that the message is not only timely (30 minutes after abandonment) but also contextually appropriate (it is only shown to users who genuinely abandoned the cart).

Conclusion

Successfully integrating Braze to trigger in-app messages from commerce events requires precise coordination between event logging on the development side and sophisticated campaign configuration on the marketing side. By strictly adhering to logging commerce data with rich properties, using property filters for granular control, and deploying the Canvas tool for time-delayed journeys, technical and marketing teams can deliver real-time, personalized, and high-converting messaging experiences that significantly enhance the commerce journey and user engagement strategy.