Using Customerio to segment users based on product usage data

If you want to send smarter emails or run targeted campaigns, you need to segment users based on what they actually do in your product—not just who they are. This guide is for anyone who’s tired of blasting generic messages and wants to actually use product usage data in Customer.io to make segments that matter.

You'll get a step-by-step walk-through, including what’s worth your time, what to skip, and what probably won’t work as advertised.

Why usage-based segmentation beats basic lists

Let’s be honest: segmenting by signup date or “plan type” gets you only so far. The gold is in the details—like who used Feature X in the last week, or who’s stuck halfway through onboarding. When you segment by real product usage, you can:

  • Send more relevant emails (and fewer that annoy people)
  • Spot power users, churn risks, or trialists who need a nudge
  • Run experiments that actually move numbers

But it’s easy to get lost in the weeds. You don’t need a PhD in SQL or a perfect data pipeline—just a willingness to wire up events and keep things simple.

What you need before you start

Before you crack open Customer.io, make sure you have:

  • Events tracked: Your app (or a backend job) sends product usage events to Customer.io. This is the hardest part, and where most teams get tripped up. If you’re not sure, ask your devs: “Are we sending usage events like feature_used or page_viewed to Customer.io for each user?”
  • A clear idea of the segments you want. Don’t try to boil the ocean. Pick one or two practical examples (e.g., “active in the last 7 days,” “completed onboarding,” or “used search 3+ times”).
  • Customer.io set up and live. This guide assumes your workspace is ready and you can see people and events in it.

Step 1: Get the right data into Customer.io

Everything depends on this. If you skip it or fudge it, segmentation falls apart.

How usage data gets into Customer.io

You have two main ways to send product usage data:

  • Track Events: These are custom events you send when users do something in your product. For example, project_created, file_uploaded, or searched. These are the bread and butter of usage segmentation.
  • Attributes: These are properties on the user, like plan, last_login, or num_projects. These can be useful, but they’re static or update slowly.

Pro tip: Don’t overthink which events to send. Start with the basics. If you try to track every button click, you’ll drown in noise and make life miserable for everyone.

How to actually send events

  • Use the official SDKs: Customer.io has SDKs for web, iOS, Android, and backend languages. Use these if you can—they’re faster and less error-prone than rolling your own API calls.

  • Keep events simple: Each event should have a name and relevant properties. For example: json { "name": "feature_used", "data": { "feature": "search", "timestamp": "2024-06-14T15:30:00Z" } }

  • Make sure user IDs are consistent: If users log in on different devices, make sure you’re identifying them the same way everywhere. Otherwise, your segments will have holes.

What to ignore: Don’t try to retroactively import months of old data unless you really need it. Start with new events going forward.

Step 2: Map your usage events to segment conditions

Once events are flowing, you can build segments based on those events. This is where Customer.io is actually pretty decent—if a bit clunky at times.

Building a segment

  1. Go to the “Segments” tab in Customer.io.
  2. Click “Create Segment.”
  3. Choose between “Data-driven” (based on events/attributes) or “Manual” (don’t use manual—defeats the purpose).
  4. Set your conditions.

Example segments you can build

  • Active users in the last 7 days:
  • Where feature_used occurred in the last 7 days.
  • Trial users who haven’t used a key feature:
  • Where plan is trial AND feature_used does NOT include export_pdf.
  • Power users:
  • Where feature_used occurred more than 10 times in the last 30 days.

Heads up: Customer.io’s condition builder is powerful, but it can get awkward if you need really complex logic (like “used Feature A but not Feature B”). For that, you might need to preprocess data outside Customer.io and send calculated attributes instead.

What works (and what doesn’t)

  • Works: Simple event-based logic, like “did X in the last Y days.”
  • Clunky: Combining lots of AND/OR logic or referencing event properties deeply.
  • Doesn’t work: Real-time segmentation. There’s a bit of lag (usually a few minutes). Don’t expect instant updates.

Step 3: Test your segments before you hit “Go”

It’s easy to think your segment is perfect—until you see 0 users, or everyone, in it.

How to sanity-check your segments

  • Preview segment members: Customer.io lets you see a sample of users who match. If it looks wrong (“wait, why is our CEO in the ‘unengaged’ list?”), check your logic.
  • Check event data: Pick a user you know well and look at their event history. Do their events line up with what your segment is supposed to do?
  • Try “reverse” segments: If you’re segmenting “users who did X,” also build “users who didn’t X.” Do the numbers look reasonable?

Pro tip: Don’t trust the first numbers you see. Test, tweak, and wait a few hours for data to flow if you’ve just set up new events.

Step 4: Take action on your segments

Segments are only useful if you actually use them. Here’s how to put them to work:

  • Send targeted campaigns: Message “power users” differently from “stuck newbies.” Don’t just swap in their first name—change the message.
  • Trigger automations: Start a re-engagement series for “inactive” users, or offer a discount to trialists who haven’t used a key feature.
  • Exclude people: Don’t send “getting started” tips to folks who finished onboarding months ago.

What to avoid: Don’t overpersonalize. Just because you can send a unique email to every micro-segment doesn’t mean you should. It’s easy to get creepy or overwhelming.

Step 5: Keep it simple and iterate

You’ll be tempted to build dozens of overlapping segments. Resist.

  • Start with 1-2 key segments. For example, “active,” “churn risk,” or “engaged with X feature.”
  • Review segments every month. Are people still falling into the right buckets? Has product behavior changed?
  • Kill segments that don’t get used. If you’re not acting on a segment, it’s just clutter.

Pro tip: The best segments are the ones you actually use to drive action, not the fanciest ones you can dream up.

Common pitfalls and honest advice

Here’s where teams usually slip up:

  • Sending the wrong data: If events are missing or inconsistent, your segments will be junk. Invest time in setting up good tracking.
  • Trying to be too clever: Complex segments sound cool but are hard to maintain and explain. Keep it obvious.
  • Ignoring segment drift: As your product changes, so does user behavior. Segments that made sense last quarter might not now.
  • Assuming real-time: There’s always a short delay. For “urgent” triggers, Customer.io isn’t the right tool anyway.

If you want something super custom (like cross-channel, real-time analytics), Customer.io might not be enough. But for most teams, it’s plenty powerful—if you stick to the basics.

Wrap-up: Don’t overthink it

Usage-based segmentation in Customer.io isn’t rocket science, but it does take some setup. Get your key events flowing, start with simple segments, and make sure you’re using them for something practical. Review, refine, and don’t be afraid to kill what’s not working.

Most importantly: keep things simple and keep iterating. The best results come from using what you’ve built—not from chasing perfection.