Alright team, I’ve just shepherded a 5-engineer team (and all our customer data) from Mailchimp over to ActiveCampaign. The core automation and segmentation power is fantastic, but oh boy, the migration wasn't a simple "lift and shift." Several things broke in subtle ways that took us days to diagnose. I'm sharing this so you can watch out for these specific integration points.
The main pain points weren't the big features, but the *connective tissue* between systems we'd built over time. Here's what caught us off guard:
**1. Custom Field Data Types & Limits**
Mailchimp is pretty loose with custom field formats. ActiveCampaign is stricter. Our "Lead Score" field, which sometimes had values like `"850+"` in Mailchimp, just silently failed to sync. No errors in the logs—contacts would come over but that field would be empty.
* **Fix:** We had to add a pre-processing step in our middleware (we use Make) to clean/normalize values before the AC API call. For example:
```javascript
// Sample Make scenario step: Format lead score
if (leadScore > 1000) {
leadScore = 1000; // AC had a numeric limit we hit
}
if (isNaN(leadScore)) {
leadScore = 0; // Force non-numbers to default
}
```
**2. Webhook Payload Structure Drastically Different**
All our internal notifications (to Slack, our own dashboard) were built to parse Mailchimp webhooks. AC's structure is completely different. Our "subscription change" alerts died immediately.
* **Example:** Mailchimp sends `type: "subscribe"` at the root level. AC sends `type: "subscribe"` inside an `event` object, and the contact details are in a separate `contact` key. We had to rewrite every webhook handler.
**3. Automation "Delay" Actions Interpreted Differently**
We had a "Welcome Series" that used a "Delay 2 days" step. In Mailchimp, the delay was *from when the contact entered the workflow*. In ActiveCampaign, by default, it's *from the previous step*. This completely desynchronized our email sequences for a cohort of users until we caught it.
* **Gotcha:** Check the "Wait" type in AC—you need to explicitly set it to "Wait until a specific date and time" relative to contact entry, not "Wait for a time period."
**4. API Rate Limiting & Bulk Operations**
Mailchimp's batch operations are more forgiving for large list updates. ActiveCampaign's 300-requests-per-15-second limit on our plan meant our initial migration script (naively firing individual updates) got throttled hard. We had to switch to using their `contact/sync` endpoint and implement a more robust queue with exponential backoff.
**5. The "Tags vs. Lists" Paradigm Shift**
This is a big one conceptually. Mailchimp is list-centric. ActiveCampaign is contact-centric with tags. Our old logic like "If in List X, do Y" broke because we were thinking in lists. We had to rebuild segments using tags (which is more powerful long-term, but a mental and technical hurdle).
Has anyone else made this jump? I'd be especially curious about how you handled the **automation translation**—did you rebuild from scratch or use a migration tool? We ended up rebuilding because we wanted to leverage AC's conditional logic fully, but it was a significant time sink.
-- Ian
Integration Ian
I lead engineering for a 120-person SaaS company in the B2B tools space. Our team has migrated customer comms platforms twice, first from SendGrid to Mailchimp for marketing automation, then from Mailchimp to ActiveCampaign for advanced B2B lead scoring, running both in production for overlapping periods to validate data integrity.
* **Data Model Strictness:** ActiveCampaign's schema enforcement is a significant migration cost. Mailchimp treats most custom fields as text, while AC enforces type constraints. We had a `company_size` field with string values like "11-50". AC's integer field rejected it. The sync didn't fail; it created the contact with an empty field, requiring a full audit of 80k contacts. Plan for a data cleansing and transformation phase that will add 20-30% to your projected migration timeline.
* **Real Cost for Automation:** Mailchimp's pricing scales primarily on list size. ActiveCampaign's cost is driven by contact count *and* automation volume. For a team doing heavy sequencing, our AC bill landed at roughly $950/month for 50k contacts, where Mailchimp was around $550. The hidden cost is compute for automations; a complex "lead nurturing" automation with 15 decision diamonds can consume credits 3-4x faster than a simple welcome series.
* **API Rate Limit Behavior:** Mailchimp's 429 responses are clear and include a `Retry-After` header. ActiveCampaign's limits are stricter and less verbose. In our load tests, AC's API (v3) started returning sporadic `403 Forbidden` responses under sustained loads above ~10-12 requests per second per API key, which their docs didn't clearly map to rate limiting. We had to implement exponential backoff with jitter from the start, whereas Mailchimp tolerated brief bursts.
* **Webhook Payload Differences:** This broke our downstream analytics. Mailchimp's `campaign_report` webhook includes a `time_series` array of opens/clicks per time interval. ActiveCampaign's equivalent `campaign_open` and `campaign_click` events are individual, real-time POSTs. We had to rebuild our aggregation layer to handle a 50x increase in webhook volume, which meant scaling our webhook ingestion service and adding a queuing buffer.
Given your context of a 5-engineer team and a focus on segmentation and automation, I'd recommend ActiveCampaign if your primary goal is sophisticated, conditional customer journeys for a B2B or complex sales cycle. If your operations are more centered on large-scale, batch-and-blast newsletter delivery with simpler segmentation, staying on Mailchimp is likely the more economical and stable choice. To make it definitive, tell us the percentage of your sends that are part of a multi-step automation versus one-off campaigns, and whether your segmentation relies heavily on numeric or date math operations on custom fields.
Trust but verify.
You've hit on the classic migration trap: the illusion of feature parity between platforms. The silent failure on custom fields is the worst kind of problem because it poisons your data silently, and you only find out weeks later when a segmentation campaign fails.
Your pre-processing fix in Make is the right move, but I'd argue you're still putting a band-aid on a deeper issue. You've now externalized your data integrity logic to an integration platform. What happens when someone creates a new, malformed custom field in Mailchimp tomorrow? Your pipeline will happily pass garbage until you catch it.
The real, albeit more painful, solution is to treat your own product database as the source of truth for these values, not the email platform. Sync *to* ActiveCampaign from your app, with strict validation at the source. That way, the email marketing system is just a dumb renderer for your already-clean data. It adds engineering overhead, but it stops these "connective tissue" surprises for good. Otherwise, you're just waiting for the next subtle breakage.
keep it simple