CSV Imports for People and Events in Customer.io

Overview

CSV imports in Customer.io are the fastest way to get usable customer and behavioral data into your workspace when you need campaigns live before engineering can prioritize a full integration. In a D2C context, this usually means uploading customers, order history, or key moments like checkout started so you can trigger abandoned cart, post-purchase, and winback flows without waiting weeks.

Anonymous messaging in Customer.io is not the goal here, but the same principle applies: start capturing intent early, then upgrade your data flow over time so journeys get smarter and drive more repeat purchase.

If you want your CSV-based programs to behave like a real-time integration (clean IDs, consistent events, and reliable suppression logic), Propel can help you stand it up quickly and safely, book a strategy call.

Propel works with Customer.io to get retention programs live fast, then harden the data layer so performance scales.

How It Works

CSV imports for people and events in Customer.io work by mapping spreadsheet columns to either person attributes (who someone is) or events (what they did, and when), then processing the file to create or update profiles and append activity.

At a practical level, you use CSV imports to:

• Create new customer profiles (email, phone, customer_id, acquisition source, first_order_date).
• Update existing profiles (VIP tier, last_order_date, total_orders, LTV bucket).
• Backfill events you want to trigger journeys from (Order Placed, Product Viewed, Checkout Started), including timestamps so recency logic works.

Once processed, the imported people and events are available for segmentation, campaign triggers, and reporting inside Customer.io.

Step-by-Step Setup

CSV imports for people and events in Customer.io are easiest when you decide your identifiers and naming conventions before you upload anything.

1. Pick your primary identifier. Use a stable customer_id if you have one. If not, email can work, but it makes later identity resolution harder when you add SMS or multiple emails per shopper.
2. Decide whether you are importing people, events, or both. People imports are for attributes. Event imports are for behavioral triggers and journey timing.
3. Prepare your people CSV. Include at minimum: customer_id (or email), and any attributes you will segment on (first_order_date, last_order_date, total_orders, opt_in flags, locale).
4. Prepare your events CSV. Each row should represent one event with: customer identifier, event_name, and a timestamp. Add event properties like cart_value, product_sku, category, discount_code, or order_id.
5. Normalize formats. Keep timestamps consistent (ISO-8601 is safest), keep currency fields numeric, and avoid mixed types in the same column.
6. Import people first, then events. This reduces the chance of events landing on incomplete profiles and makes QA easier.
7. QA with a small file. Upload 20 to 50 rows first, confirm attributes and events look correct on profiles, then import the full dataset.
8. Build segments and triggers immediately after import. Create a segment like “Checkout Started in last 4 hours AND no Order Placed” to validate that your event timestamps and naming are usable.

When Should You Use This Feature

CSV imports for people and events in Customer.io are best when you need revenue-driving journeys live quickly, or when you need to backfill history so your segmentation and timing rules behave like a mature program.

• Abandoned cart recovery without an integration yet: Import yesterday’s “Checkout Started” events from Shopify exports or your data warehouse, then run a short-delay recovery series (email first, then SMS for opted-in shoppers).
• Post-purchase education and cross-sell: Import “Order Placed” events with line items and category, then branch flows by product type (for example, skincare regimen tips vs supplement usage guidance).
• Reactivation and winback: Import last_order_date and total_orders as attributes, then target “2+ orders, no purchase in 90 days” with a replenishment reminder and a category-specific offer.
• First purchase conversion from lead lists: Import people collected from quizzes, popups, or in-store events, then segment by quiz result or interest and send a short discovery series that pushes to best sellers.

Realistic scenario: a brand is migrating ESPs mid-quarter and cannot wait for full event piping. They export the last 60 days of orders and checkout starts nightly, import via CSV, and keep cart recovery and post-purchase flows running while engineering finishes the real-time integration.

Operational Considerations

CSV imports for people and events in Customer.io can drive real revenue, but only if your data hygiene supports suppression, timing, and attribution.

• Identity and deduping: Decide how you will handle customers who checkout with different emails, or who opt into SMS later. In retention programs we’ve implemented for D2C brands, choosing a stable customer_id early prevents painful merges and broken frequency caps later.
• Event naming conventions: Keep event names consistent with what you will eventually send via API (for example, “checkout_started” vs “Checkout Started”). If you change naming later, you will end up maintaining two sets of segments and triggers.
• Timestamp accuracy: Cart recovery depends on minutes and hours, not days. If your CSV timestamps are in the wrong timezone or get rounded, your “send after 30 minutes” logic will misfire.
• Suppression logic: Make sure you can reliably exclude purchasers from cart recovery. That usually means importing “order_placed” events and/or updating last_order_date immediately after purchase imports.
• Incremental vs full refresh: Avoid re-importing the same events repeatedly. If you must do recurring CSV uploads, include a unique order_id or event_id property and keep a process to prevent duplicates.

Implementation Checklist

CSV imports for people and events in Customer.io go smoothly when you treat the upload like a mini data integration project.

• Primary identifier chosen (customer_id preferred) and used consistently across all CSVs
• People attributes defined (last_order_date, total_orders, LTV, SMS/email opt-in flags)
• Event taxonomy defined (checkout_started, order_placed, product_viewed) and documented
• Timestamps validated (timezone, format, and recency checks)
• Small-batch QA completed on real profiles before full upload
• Core segments built (cart abandoners, first-time buyers, repeat buyers, lapsing customers)
• Core journeys launched (cart recovery, post-purchase, replenishment, winback)
• Duplicate prevention plan in place for recurring imports (event_id or order_id approach)

Expert Implementation Tips

CSV imports for people and events in Customer.io can be a high-performing bridge solution if you design them around the journeys you care about, not around whatever columns happen to be available.

• Import the minimum viable fields that unlock revenue. For cart recovery, you need checkout_started timestamp, cart_value, and a purchase signal. For post-purchase, you need order timestamp, category, and order_id.
• Use attributes for state, use events for moments. “total_orders” belongs on the profile. “order_placed” belongs as an event. That split makes segmentation and journey branching cleaner.
• Backfill just enough history to make timing logic trustworthy. In retention programs we’ve implemented for D2C brands, importing 60 to 120 days of orders is usually sufficient to power winback and replenishment without bloating your workspace with years of noise.
• QA by building one diagnostic segment per critical flow. Example: “Checkout Started in last 2 hours AND not purchased” should have a believable count relative to site traffic. If it is zero or massive, your timestamps or event names are off.

Common Mistakes to Avoid

CSV imports for people and events in Customer.io often fail quietly, then you find out when cart recovery sends to buyers or winbacks target recent purchasers.

• Using email as the only identifier when you plan to add SMS. It creates fragmented profiles and inconsistent frequency control.
• Importing events without timestamps. Without time, you cannot run “within the last X hours/days” logic reliably.
• Changing event names later. It breaks triggers and forces you to rebuild segments and reporting.
• Re-importing the same events repeatedly. Duplicate checkout_started rows can spam customers and distort conversion reporting.
• Skipping suppression design. Cart recovery must exclude purchasers, and post-purchase must not target cancelled or refunded orders if you have that data.

Summary

Use CSV imports when you need journeys live fast or you need to backfill customer history for segmentation and timing. Done well, it powers cart recovery, post-purchase, and winback programs while you build a real-time pipeline in Customer.io.

Implement with Propel

If you want CSV imports to behave like a reliable retention engine, Propel can help you map identifiers, clean event taxonomy, and launch revenue-first journeys in Customer.io. book a strategy call.