CRM migration
Field-level mapping, validation, and rollback between Iterable and Twenty CRM. We move data and schema; workflows are rebuilt natively in Twenty CRM.
Iterable
Source
Twenty CRM
Destination
Compatibility
9 of 10
objects map 1:1 between Iterable and Twenty CRM.
Complexity
BStandard
Timeline
2-4 weeks
Overview
Moving from Iterable to Twenty CRM is a shift from cross-channel marketing automation to a self-hosted relationship management platform. Iterable organizes data around User Profiles, Custom Events, Campaigns, Journeys, Lists, and Catalog items; Twenty CRM uses People, Companies, Opportunities, Tasks, Notes, and Custom Objects. We extract User Profiles and map them to Twenty People records with all custom fields preserved, resolve List memberships as tag or multi-select fields, and migrate Custom Events as Twenty Custom Objects with lookup relationships to the associated People record. We do not migrate Journey definitions, Templates, or Catalog schemas as functional code because Twenty's workflow builder and template system operate on different primitives. We deliver a written inventory of every active Journey and Template with recommended manual-rebuild steps for the customer's admin team. Subscription status per channel migrates as boolean fields on the People record so that opt-in and opt-out state is preserved.
Every standard and custom field arrives verified.
AI proposes the map; you confirm before any record moves.
Parent–child, lookups, and ownership stay linked.
Calls, emails, meetings — with original timestamps.
Documents, uploads, and inline notes move with the record.
Why teams make this switch
Leaving
What's pushing teams away
Choosing
What's pulling them in
Object mapping
Each row shows how a Iterable object lands in Twenty CRM, including any object-level transformations, lookup resolution, or schema-design dependencies.
Typical mapping — final map is confirmed during the sample migration step.
Iterable
User Profile
Twenty CRM
People
1:1Iterable User Profiles map directly to Twenty People records. The dataId, email, userId, and all custom profile fields migrate as named fields on the People object. We preserve system fields like createdAt and updatedAt as readonly date fields. Subscription status per channel (email, SMS, push) migrates as boolean fields (emailSubscribed, smsSubscribed, pushSubscribed) so opt-in state is auditable in Twenty without a separate subscription management module.
Iterable
Company (custom field reference)
Twenty CRM
Company
1:1Iterable does not have a native Company/Account object; companies are referenced via custom fields on User Profiles. During scoping, we audit which custom fields hold company name, domain, or account identifiers. If these fields exist, we extract unique values, deduplicate, and create Company records in Twenty, then resolve the lookup relationship back to People via a custom field companyId that we populate during People import.
Iterable
Custom Event
Twenty CRM
Custom Object
1:1Iterable Custom Events (behavioral data with name, userId, and arbitrary metadata payload) migrate as Twenty Custom Objects. We create a custom object schema in Twenty matching the event's metadata field structure, then import historical event records with a lookup to the associated People record. Event timestamps migrate as the Custom Object's createdAt. The event name becomes a field on the Custom Object for filtering in Twenty's views.
Iterable
List
Twenty CRM
Tag or Multi-Select Field
lossyIterable Lists are audience segments used for campaign targeting. Twenty has no native list object, so we offer two migration strategies during scoping: (1) comma-separated tags migrated to a multi-select field on People, or (2) list membership stored as a JSON field with list names as values. The customer chooses based on how they use Lists in Iterable. Both approaches allow filtering in Twenty's views and workspaces.
Iterable
Campaign
Twenty CRM
Note or Opportunity
1:1Iterable Campaigns (sendable units with name, channel, template, and schedule) are exported as structured metadata with channel, status, and schedule preserved. Campaign content does not migrate because Twenty has no native email or SMS sending engine. We deliver a Campaign Inventory document listing every Iterable Campaign with its send history, channel type, and associated template, which the customer's admin uses to rebuild campaign logic in Twenty Workflows or a separate sending tool.
Iterable
Journey
Twenty CRM
(no equivalent)
1:1Iterable Journeys are multi-step, multi-channel automation paths with trigger conditions, branching logic, and message actions. Twenty Workflows are code-based action sequences that operate on Twenty records and external API calls. These are fundamentally different automation models with no structural equivalence. We do not migrate Journeys as code. We deliver a written Journey Inventory listing every active Journey with its trigger type, conditions, branch paths, and associated message steps so the customer's admin can rebuild in Twenty Workflows or an external sending tool.
Iterable
Template
Twenty CRM
(no equivalent)
1:1Iterable Templates define message content (HTML email, plain text, dynamic Handlebars personalization) for Campaigns and Journey steps. Twenty CRM has no native template engine. We export template metadata (name, channel, content type, personalization variables) to a Template Inventory document that the customer's admin uses to reproduce content in their chosen sending tool (e.g., Postmark, Resend, Klaviyo) with dynamic fields mapped to Twenty People record fields.
Iterable
Catalog Item
Twenty CRM
Custom Object
1:1Iterable Catalog stores product data used for dynamic content insertion in messages (product name, SKU, price, image URL, attributes). We export Catalog schemas and item records as CSV and import them into a Twenty Custom Object (e.g., Product Catalog) with fields matching the source schema. The customer must rebuild any Catalog-driven personalization logic (e.g., product recommendations in emails) using their chosen sending tool's dynamic content system post-migration.
Iterable
Purchase Event
Twenty CRM
Custom Object
1:1Iterable Purchase events (orderId, total, items, associated user) migrate as a Twenty Custom Object (e.g., Purchase) with a lookup to the People record. Order ID, total amount, currency, and item count migrate as typed fields. The line items array is stored as a JSON field if the customer needs granular item-level data, or flattened into summary fields if simpler reporting is sufficient.
Iterable
Subscription Status
Twenty CRM
Boolean Fields on People
1:1Iterable tracks channel-level opt-in/opt-out state per user (email, SMS, push, in-app). We migrate each channel's subscription status as a boolean field on the People record (emailSubscribed, smsSubscribed, pushSubscribed). Subscription event history (opt-in timestamp, opt-out timestamp, source) is preserved as activity notes on the People timeline if available in the Iterable export. This satisfies GDPR accountability requirements for consent records.
| Iterable | Twenty CRM | Compatibility | |
|---|---|---|---|
| User Profile | People1:1 | Fully supported | |
| Company (custom field reference) | Company1:1 | Fully supported | |
| Custom Event | Custom Object1:1 | Fully supported | |
| List | Tag or Multi-Select Fieldlossy | Fully supported | |
| Campaign | Note or Opportunity1:1 | Fully supported | |
| Journey | (no equivalent)1:1 | Fully supported | |
| Template | (no equivalent)1:1 | Fully supported | |
| Catalog Item | Custom Object1:1 | Fully supported | |
| Purchase Event | Custom Object1:1 | Fully supported | |
| Subscription Status | Boolean Fields on People1:1 | Fully supported |
Gotchas + challenges
Platform-specific issues from each side, plus the pair-specific challenges that don't show up on either platform's page on its own.
Iterable gotchas
Iterable does not allow field deletion
Separate API endpoints for US and EU data centers
Soft limit of 8,000 unique fields per project
Enterprise pricing is opaque and contract-based
Usage metrics lag by one calendar day
Twenty CRM gotchas
Import order is enforced and critical
Export limited to 20,000 records and visible columns only
Soft-deleted records count toward uniqueness and trigger restores
API rate limits cap at 200 req/min on Organization tier
No native email sequences — follow-up cadences require external tools
Pair-specific challenges
Migration approach
Discovery and data center confirmation
We audit the source Iterable project across data center (USDC or EDC), User Profile count, custom field count, active Custom Event types, active Lists, active Campaigns, active Journeys, Catalog item volume, and subscription event history. We confirm the data center URL and API key scope before any extraction. The discovery output is a written migration scope document listing every object, field, and automation artifact with a migration recommendation (migrate, inventory, or exclude).
Twenty workspace preparation
We create the Twenty workspace schema before any data import. This includes creating all custom fields in Settings → Data Model (matching Iterable field names and types), creating any Custom Objects required for Custom Events and Catalog items, inviting all team members who will be referenced as record owners or assignees, and verifying that the target People, Company, and Custom Object structures are deployed and accessible. Custom fields must exist before CSV import; we build the full field schema in Twenty first.
Source data extraction and deduplication
We extract User Profiles, Custom Events, Lists, Campaigns, Journeys, Templates, Catalog items, Purchase events, and Subscription status from Iterable using the correct data center API endpoint. We deduplicate profiles by email (preferring the most recently updated record), extract unique company names from custom company-reference fields into a staging set, and audit the Iterable field list to exclude deprecated fields that cannot be deleted on the source platform. The extraction emits a field-level manifest used for mapping in the next step.
Company resolution and People-Company relationship build
Iterable has no native Company object, so we resolve company references from custom User Profile fields into a deduplicated Company set for Twenty. We create Company records in Twenty first (with domain extracted from email as a secondary identifier where available), then resolve the company lookup on People during the People import phase. This dependency ordering ensures that AccountId on People is populated at insert time rather than patched in a second pass.
Custom Object schema creation and event migration
We create Custom Object schemas in Twenty for each distinct Iterable Custom Event type, matching the event's metadata field structure. We then import historical Custom Event records as Twenty Custom Object records with a lookup to the associated People record. Purchase events receive a separate Custom Object schema (e.g., Purchase) with order-level fields and a JSON field for item-level detail. Catalog items are imported as a separate Custom Object (e.g., Product Catalog) with fields matching the source Catalog schema.
List-to-tag transformation and People import
We transform Iterable List memberships into tags or multi-select fields on People based on the customer's chosen strategy during scoping. Each unique List name becomes a tag value. We import People records in batches using Twenty's REST API with rate-limit handling and exponential backoff, populating companyId (lookup), subscription boolean fields, and tag values in a single pass. Custom fields not yet in Twenty are held and created before their records are retried.
Cutover, validation, and automation rebuild handoff
We freeze writes to Iterable during cutover, run a final delta extraction of any records modified during the migration window, then deliver a complete migration report with record counts per object, per-field validation summaries, and a list of any records that failed import with root-cause classification. We deliver the Journey Inventory and Template Inventory documents to the customer's admin team with rebuild guidance for Twenty Workflows and the chosen sending platform. We support a five-business-day hypercare window for reconciliation issues and do not charge separately for fixing import errors discovered within that window.
Platform deep dives
Iterable
Source
Strengths
Weaknesses
Twenty CRM
Destination
Strengths
Weaknesses
Complexity grading
Standard CRM migration. 1 of 8 objects need a mapping; the rest are 1:1.
Overall complexity
Standard migration
Derived from compatibility, mapping clarity, API constraints, and data volume across Iterable and Twenty CRM.
Object compatibility
1 of 8 objects need a mapping; the rest are 1:1.
Field mapping clarity
Field mapping is derived from defaults — final spec confirmed during the sample migration.
Timeline complexity
8-object category — typical timelines run 2–7 days end-to-end.
API constraints
Iterable: Not publicly documented; returns RateLimitExceeded code on limit.
Data volume sensitivity
Iterable exposes a bulk API — large-volume migrations stream efficiently.
Estimator
Rule-based pricing — no per-record fees, no manual quotes. Migrations over 2M records are scoped individually.
Step 1
Pick a category, then your source and destination platforms.
Category
FAQ
Answers to the questions buyers ask most during Iterable to Twenty CRM migration scoping. Not seeing yours? Book a call.
Walk through your Iterable to Twenty CRM migration with a real engineer — 30 minutes, free, written quote within 24 hours.
Book a free 30 minute consultationAdjacent paths
Other ways to leave Iterable
Other ways to arrive at Twenty CRM
Ready when you are
Tell us record counts and timeline. We'll come back with a written quote inside 1 business day — no commitment, no sales pitch.