Send event in Customer.io

Overview

Send event in Customer.io is the operational move that turns shopper behavior into automation triggers, so your cart recovery, post-purchase, and reactivation flows react to what customers actually do (not what you hope they do). In D2C, the difference between a high-performing program and noise is usually event quality and timing, and Send event is how you control both.

If you want this wired to Shopify, your ESP, and your ad stack without messy event naming and broken triggers, Propel can help you implement it cleanly in Customer.io, then pressure test it against revenue outcomes. If you want help mapping events to journeys, book a strategy call.

How It Works

Send event in Customer.io works by recording a timestamped behavioral action against a person profile, then making that event available to trigger campaigns, branch logic, goals, and segmentation.

In practice, you pass an event name (like checkout_started or order_completed) plus event attributes (like cart_value, items, discount_code, variant_id, shipping_country). Those attributes become the levers you use to personalize messages, qualify who enters a flow, and decide which path they take.

Most brands implement this via the Track API or via a data pipeline, then use the resulting event stream inside Customer.io Journeys to trigger abandoned cart recovery, post-purchase education, replenishment reminders, and winback.

Step-by-Step Setup

Send event in Customer.io setup is mostly about defining the right events, sending them consistently, and then using them to drive journey entry and branching.

1. Define your revenue-critical events first. For most D2C brands, start with: product_viewed, collection_viewed, added_to_cart, checkout_started, order_completed, refund_created, subscription_created (if applicable), and email_clicked (if you want cross-channel logic).
2. Standardize event naming and casing. Pick one convention (snake_case is common) and lock it. Changing names later breaks triggers and reporting.
3. Decide which attributes you need at send time. For cart and checkout events, include: cart_value, currency, item_count, items (array), product_ids, variant_ids, categories, discount_code, and landing_page or referrer where possible.
4. Implement event sending from your source of truth. Typically Shopify plus your checkout layer, or your CDP if it is trustworthy. Avoid double-sending the same event from multiple sources.
5. Verify events in Activity Logs. Check that events appear on the correct person profile, with the expected attributes. Confirm timestamps look right (timezone and latency issues show up here).
6. Build a triggered Journey off the event. Example: trigger on checkout_started, then branch by cart_value and item_count, then send email and SMS with the right delay strategy.
7. Add guardrails with filters and exit conditions. Exclude people who purchased after entering, suppress recent purchasers, and cap message frequency so you do not cannibalize margin or spike unsubscribes.
8. Set a conversion goal tied to revenue. For cart recovery, use order_completed within 24 to 72 hours as the success signal, then measure lift by segment and channel.

When Should You Use This Feature

Send event in Customer.io is most valuable when you need automation to respond to high-intent shopper behavior with tight timing and clean segmentation.

• Abandoned cart recovery that adapts to the cart. Trigger on added_to_cart or checkout_started, then branch messaging based on cart_value, category, or whether a discount code was already applied.
• Product discovery journeys. If someone views the same category three times in a week but never adds to cart, trigger a browse abandonment series that features bestsellers in that category.
• Post-purchase engagement that reduces refunds and drives second order. Trigger on order_completed, then send care instructions, how-to content, and cross-sell based on items purchased.
• Reactivation based on real inactivity. Trigger a winback when a customer has no site_visit or product_viewed events for 60 days, and tailor the offer based on last category purchased.

Operational Considerations

Send event in Customer.io only performs as well as your event design and your data discipline, so treat it like infrastructure, not a one-off integration task.

• Event taxonomy governance. Assign an owner for naming, definitions, and changes. A single renamed event can silently stop a cart recovery flow.
• Deduplication strategy. Checkout and order events are common sources of duplicates (payment retries, page refreshes, multiple webhooks). Use an order_id or event_id and dedupe upstream when possible.
• Identity resolution. If you have anonymous browsing, plan how you will merge anonymous activity to known profiles at email capture or checkout. Without this, browse and cart signals often get stranded.
• Latency and timing windows. If events arrive late, your “send in 30 minutes” cart message can become a “send in 3 hours” message. Monitor event delay, especially during peak promos.
• Attribute payload size and consistency. Keep item arrays consistent in structure. If items sometimes send as strings and sometimes as objects, Liquid personalization becomes fragile.

Implementation Checklist

Send event in Customer.io implementation goes smoothly when you validate the full loop from event to message to conversion tracking.

• Event naming convention documented and enforced
• Definitions written for each event (what it means, when it fires, sources)
• Required attributes defined for cart, checkout, and purchase events
• Events verified on real customer profiles in Activity Logs
• Deduplication confirmed for checkout_started and order_completed
• At least one triggered Journey built per core event (cart, purchase, winback)
• Exit conditions added (purchased, refunded, unsubscribed, suppressed)
• Conversion goal configured using order_completed within a defined window
• QA across email and SMS rendering using real event payloads
• Ongoing monitoring plan for event volume drops or schema changes

Expert Implementation Tips

Send event in Customer.io gets powerful when you design events around decisions your journeys need to make, not around what your engineering team happens to emit.

• Model events for branching, not just triggering. In retention programs we’ve implemented for D2C brands, the biggest lift often comes from branching cart recovery by category and margin tier, not from adding more messages.
• Send “why” attributes, not only “what” attributes. For example, include traffic_source or campaign_id on checkout_started, so you can avoid discounting customers who were already promo-driven.
• Use order_completed as the universal exit event. Build all commerce journeys so they listen for purchase and exit cleanly, otherwise you will keep sending nudges after someone converts.
• Keep a test profile and a test order flow. In retention programs we’ve implemented for D2C brands, teams that maintain a repeatable QA path catch broken webhooks and schema changes before revenue takes the hit.

Common Mistakes to Avoid

Send event in Customer.io mistakes usually show up as “why didn’t the flow send” or “why did we message people who already bought,” and both are preventable.

• Triggering cart recovery on the wrong event. If added_to_cart fires too early, you will hit low-intent shoppers. If checkout_started fires too late or inconsistently, you will miss recoveries.
• Missing key attributes. Without cart_value, item_count, and items, you cannot personalize effectively or protect margin with smart offer logic.
• Duplicate purchase events. This can inflate conversion reporting and break post-purchase timing (customers get multiple “thanks for your order” messages).
• No suppression rules. Not excluding recent purchasers or high-frequency message recipients leads to list fatigue and deliverability issues.
• Changing schemas without updating Liquid. A small payload change can break dynamic product blocks and create blank emails at scale.

Summary

Use Send event when you need journeys to react to shopper behavior in real time, especially for cart recovery, post-purchase, and winback. Clean event design and consistent attributes are what turn Customer.io into a revenue engine instead of a broadcast tool.

Implement with Propel

Propel can help you map your commerce events, implement Send event in Customer.io, and QA the full path from behavioral trigger to conversion tracking. If you want a clean event taxonomy and higher-performing flows, book a strategy call.