Migrate from Mailchimp to Customer.io: When Batch Logic Isn't Enough

There is a specific moment when Mailchimp stops being the right tool. It usually happens quietly — a campaign that needed to fire within minutes of a user action fires six hours later. An automation that should branch on what a user did inside your product branches on a tag that someone remembered to apply manually. A re-engagement sequence that should know a user hasn't logged in for 30 days instead fires to everyone on a list because that was the closest approximation the tool could support.

None of these are Mailchimp failures. Mailchimp was built for a different kind of email program — list-based, schedule-driven, broadcast-oriented. It is exceptionally good at that. What it was not built for is the real-time, event-triggered, behavioral lifecycle marketing that subscription businesses and SaaS products need once they've grown past their first few thousand users.

Customer.io was built for exactly that next stage. The migration is not complicated — Mailchimp's architecture is simple enough that the data translation is relatively clean. What requires careful thought is the event schema design, because Mailchimp never required one.

Why Mailchimp Teams Make the Move

Lists vs. events. Mailchimp organizes contacts into lists (or audiences) and drives automations through list membership and tag changes. Customer.io organizes around people with Attributes who fire Events. The difference sounds abstract until you try to build a trial expiration sequence, a payment failure recovery flow, or a feature adoption nudge in Mailchimp — and discover that every one of them requires a workaround because the trigger you need isn't a list change, it's a product event.

Automation depth. Mailchimp's Customer Journeys are functional for linear, time-based email sequences. They are not built for complex conditional branching on event properties, real-time behavioral triggers from your product, or webhook actions that push data to external systems. For subscription retention strategies that depend on responding to user behavior within minutes, Mailchimp's automation model creates structural constraints.

Personalization ceiling. Mailchimp's merge tags (*|FNAME|*) are limited. Customer.io's Liquid templating allows conditional content blocks, loops through event properties, complex date arithmetic, and personalization logic that adapts to what a user actually did — not just who they are. For teams trying to build personalized email flows without manual work, this capability gap becomes a daily frustration.

No event stream. Mailchimp has no native API for receiving behavioral events from your product. Custom events require Mailchimp's API with specific workarounds, or a third-party integration layer. Customer.io's Track API receives any event from any source — your backend, your app, Stripe, your data warehouse — with no integration layer required.

The Architecture Difference: Mailchimp vs. Customer.io

Mailchimp's model: List-centric and broadcast-oriented. Contacts belong to audiences. Tags categorize contacts within audiences. Automations trigger on audience events (subscribes, tag changes), date-based conditions, or ecommerce events (if using Mailchimp's ecommerce integrations). The model is optimized for scheduled campaigns and linear drip sequences.

Customer.io's model: Event-driven and person-centric. People have Attributes. They fire Events with properties. Campaigns trigger on Events in real time. There are no lists — segmentation is dynamic, based on Attribute values and event history that update continuously. A person's segment membership changes the moment their behavior changes.

The migration consequence: Mailchimp audiences map to Customer.io People imports. Mailchimp tags map to Customer.io Attributes (boolean flags or string values). Mailchimp automations must be rebuilt as Customer.io Campaigns — with the key step of identifying the source event that should trigger each Campaign, which Mailchimp was approximating through tag changes and list events.

What Transfers and What Doesn't

Transfers With Mapping ✅

Contacts. Email address, first name, last name, and any custom fields transfer via CSV export from Mailchimp and import to Customer.io. Map Mailchimp's MERGE fields to Customer.io Attributes with matching data types.

Tags → Attributes. Mailchimp tags are boolean state indicators — a contact either has a tag or doesn't. In Customer.io, these map to boolean Attributes (is_paying_customer: true, has_completed_onboarding: true). Document every tag in active use across Mailchimp automations and segments.

Suppression data. Mailchimp's unsubscribed contacts and cleaned (hard bounced) contacts export cleanly. Unsubscribed contacts map to Customer.io's global unsubscribe. Cleaned contacts map to email suppression. Both move before active contacts import.

Must Be Rebuilt 🔄

Every Customer Journey or automation becomes a Campaign. Mailchimp automations cannot be imported into Customer.io. For each Mailchimp automation, identify the behavioral event that should be the Customer.io trigger — signup_completed, trial_started, payment_failed — and rebuild the Campaign around that event. The first rebuild for most Mailchimp teams reveals that their previous automations were triggering on list events that were poor approximations of the actual behavioral moment they cared about.

Segments. Mailchimp's segment conditions (tag-based, activity-based, date-based) must be recreated in Customer.io using Attribute filters and event conditions. For teams whose Mailchimp segments were approximating behavioral conditions with tag-based workarounds, Customer.io's event-based segment logic will be more precise and less maintenance-intensive.

Templates. Mailchimp's drag-and-drop templates and merge tag personalization are platform-specific. Rebuild in Customer.io's email editor with Liquid. *|FNAME|* becomes {{ customer.first_name }}. Every merge tag must be remapped.

Left Behind ❎

Mailchimp's audience growth tools. Mailchimp's landing pages, signup forms, and pop-up builders are not replicated in Customer.io. If you use these tools, evaluate what replaces them in your stack before migration — Customer.io focuses on messaging to people already in your system, not on acquiring new ones. Tools like Typeform, Webflow forms, or your product's own signup flow feed directly into Customer.io via the API.

Historical campaign analytics. Mailchimp performance data stays in Mailchimp. Export click and open rate benchmarks before closing the account. Customer.io engagement starts fresh.

The Event Schema: Building What Mailchimp Never Required

This is the intellectual core of a Mailchimp-to-Customer.io migration. Mailchimp never asked you to design an event schema. Customer.io requires one — and the quality of that schema determines the ceiling of what your lifecycle program can do.

Start by auditing your Mailchimp automations and asking, for each one: what is the actual product moment that should trigger this? Not "subscriber joins the trial list" — what happens in your product that causes someone to join that list? That product action is your Customer.io event.

For most Mailchimp teams, this audit is revelatory. Automations that felt complete in Mailchimp — because they were doing what Mailchimp could do — reveal themselves as approximations of what they should be. A "welcome series" that fires when someone subscribes to a newsletter should fire in Customer.io when signup_completed fires from your backend, with properties like acquisition_source, plan_type, and referral_code available for immediate personalization and branching.

The event schema document — every event name, trigger source, and property — is the pre-migration artifact that everything else is built from. Our events and attributes architecture service produces this as a formal deliverable before any Customer.io configuration begins.

Migration Checklist: Mailchimp to Customer.io

Pre-Migration Audit

• Inventory all active Mailchimp automations — trigger, email count, 30-day performance.
• Map every automation trigger to its source product event.
• Document all MERGE fields and tags in active use across automations and segments.
• Design Customer.io event schema from the trigger mapping exercise.

Data Migration

• Export Mailchimp unsubscribed contacts — import to Customer.io global unsubscribe first.
• Export cleaned hard bounced contacts — import to Customer.io email suppression.
• Export active contacts with all MERGE fields and tags — import as Customer.io People with Attributes.
• Segment import into engagement tiers.

Technical Setup

• Instrument Customer.io API events per designed event schema — validate every event fires correctly.
• Configure sending domain in Customer.io — DKIM, SPF, DMARC. Reference email deliverability channel health standards.
• Set up global unsubscribe and subscription preferences in Customer.io.

Campaign Rebuild and Go-Live

• Rebuild automations as Customer.io Campaigns triggered by the source product event.
• Rebuild all email templates with Liquid personalization.
• QA every Campaign with test events before activating.
• Deactivate Mailchimp automations as Customer.io Campaigns go live — never run both simultaneously for the same audience.
• Deliverability warm-up — 4–6 weeks, engaged contacts first.

Stakeholder Expectations

Marketing team: Budget 6–10 weeks. The event schema design and Campaign rebuild are the primary time investments. For teams with simple Mailchimp programs (5 or fewer automations), this can be significantly faster. The deliverability warm-up is the primary constraint on send volume during the first 4–6 weeks.

Engineering: 1–3 weeks for event instrumentation, depending on your stack. Mailchimp teams often don't have existing API event infrastructure — this may be the first time your product fires events directly to a messaging platform. Plan accordingly.

Leadership: The customer retention impact calculator gives you a revenue baseline before migration starts. Brief leadership on warm-up before the first month shows reduced send volume.

Propel's Role in Your Migration

Propel is a certified Customer.io partner. We have run migrations for subscription and SaaS brands making the move from list-based tools to behavioral messaging platforms. Our event schema design process is specifically built for teams like Mailchimp migrators — teams that have never designed an event schema before and need a structured process to get it right the first time.

See the full migrate to Customer.io guide for the platform-agnostic migration framework. Then talk to us about making it specific to your stack.