CRM migration

Migrate from Iterable to Twenty CRM

Field-level mapping, validation, and rollback between Iterable and Twenty CRM. We move data and schema; workflows are rebuilt natively in Twenty CRM.

Iterable logo

Iterable

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

90%

9 of 10

objects map 1:1 between Iterable and Twenty CRM.

Complexity

BStandard

Timeline

2-4 weeks

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

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.

Field-level fidelity

Every standard and custom field arrives verified.

Schema-aware mapping

AI proposes the map; you confirm before any record moves.

Relationships preserved

Parent–child, lookups, and ownership stay linked.

Full activity history

Calls, emails, meetings — with original timestamps.

Attachments & notes

Documents, uploads, and inline notes move with the record.

Why teams make this switch

Two sides of the same decision

Leaving

Iterable logo

Iterable

What's pushing teams away

  • Steep learning curve with unclear documentation forces teams to rely heavily on support for tasks that should be self-service.
  • SMS deliverability issues with accounts blocked without clear accountability or transparent root-cause communication from Iterable.
  • Contract pricing increases when usage is reduced, creating a billing model that punishes customers who downscale usage.
  • Cluttered UI requiring multiple clicks through nested menus to access common functions, slowing down campaign creation and editing.
  • Inconsistent conversion tracking and reporting makes it difficult to reliably measure campaign performance and optimize spend.

Choosing

Twenty CRM logo

Twenty CRM

What's pulling them in

  • Top open-source CRM on GitHub with 40.6K stars, giving teams full source code access and infrastructure ownership without per-feature licensing surprises.
  • Free self-hosting under AGPL-3.0 means unlimited users and custom objects for the cost of cloud infrastructure alone, typically $20–100/month.
  • Pricing page explicitly mocks competitors for charging add-on fees for API access, webhooks, and workflows — transparency that resonates with RevOps teams burned by Salesforce.
  • Unlimited custom objects and fields with no price impact, letting teams shape the data model to their business rather than forcing business into rigid schemas.
  • Modern TypeScript/React/PostgreSQL stack means developer-led teams can extend, self-host, or integrate without fighting legacy architecture.

Object mapping

How Iterable objects map to Twenty CRM

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

maps to

Twenty CRM

People

1:1
Fully supported

Iterable 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)

maps to

Twenty CRM

Company

1:1
Fully supported

Iterable 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

maps to

Twenty CRM

Custom Object

1:1
Fully supported

Iterable 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

maps to

Twenty CRM

Tag or Multi-Select Field

lossy
Fully supported

Iterable 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

maps to

Twenty CRM

Note or Opportunity

1:1
Fully supported

Iterable 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

maps to

Twenty CRM

(no equivalent)

1:1
Fully supported

Iterable 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

maps to

Twenty CRM

(no equivalent)

1:1
Fully supported

Iterable 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

maps to

Twenty CRM

Custom Object

1:1
Fully supported

Iterable 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

maps to

Twenty CRM

Custom Object

1:1
Fully supported

Iterable 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

maps to

Twenty CRM

Boolean Fields on People

1:1
Fully supported

Iterable 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.

Gotchas + challenges

What specifically takes care here

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 logo

Iterable gotchas

Medium

Iterable does not allow field deletion

High

Separate API endpoints for US and EU data centers

Medium

Soft limit of 8,000 unique fields per project

High

Enterprise pricing is opaque and contract-based

Low

Usage metrics lag by one calendar day

Twenty CRM logo

Twenty CRM gotchas

High

Import order is enforced and critical

High

Export limited to 20,000 records and visible columns only

Medium

Soft-deleted records count toward uniqueness and trigger restores

Medium

API rate limits cap at 200 req/min on Organization tier

Low

No native email sequences — follow-up cadences require external tools

Pair-specific challenges

  • Journeys and Templates have no functional migration path

    Iterable Journeys and Templates are tightly coupled to Iterable's campaign infrastructure and cannot be exported as reusable automation code. Twenty's Workflow builder operates on code-based actions that do not share the same trigger model. We do not migrate them as functional code. We deliver a written Journey and Template inventory with recommended rebuild steps for the customer's admin team. If the customer relies heavily on Journey automation for customer lifecycle campaigns, they will need to rebuild those in Twenty Workflows or select a separate sending platform post-migration.

  • Twenty Workflow iterator stability issue

    Twenty's workflow iterator step has a known bug (GitHub issue #15776, November 2025) where iterators receive valid inputs but remain in a 'running' blocked state after completing step 4. Teams planning to rebuild Iterable Journey logic in Twenty Workflows should test iterator behavior before committing to a production workflow design. We flag this during migration scoping and recommend using code-based iteration or API-triggered workflows as alternatives if the customer's automation relies on iterator steps.

  • Custom fields must exist before CSV import

    Twenty's CSV import creates records but does not create fields. All custom fields must be defined in Settings → Data Model before the import runs. We pre-create the full custom field schema in Twenty during the preparation phase, including field type (text, number, date, boolean, select, multi-select), required flags, and select options. Fields added to the source export that do not exist in Twenty are held in a reconciliation queue and created before their corresponding records are imported.

  • Iterable's US vs EU data center separation affects extraction

    Iterable operates two distinct data centers with separate API base URLs (api.iterable.com for USDC, api.eu.iterable.com for EDC). API keys are scoped to a single data center and are not interchangeable. We confirm the customer's Iterable data center during scoping and use the correct base URL for all extraction operations. Cross-region extraction attempts produce authentication failures. This does not affect Twenty because Twenty's API base URL is determined by the customer's deployment (cloud: api.twenty.com; self-hosted: customer-configured domain).

  • Iterable field deletion is permanent on source

    Iterable does not allow field deletion once a custom field is created. Deprecated fields remain in the schema and appear in exports. We filter out deprecated fields during the extraction phase to avoid importing unused schema overhead into Twenty. The customer should review their Iterable field list during scoping and confirm which fields are active versus deprecated so we exclude the latter from the migration set.

Migration approach

Six steps for a successful Iterable to Twenty CRM data migration

  1. 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).

  2. 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.

  3. 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.

  4. 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.

  5. 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.

  6. 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.

  7. 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

Context on both ends of the pair

Iterable logo

Iterable

Source

Strengths

  • Cross-channel execution across email, SMS, push, and in-app from one unified platform interface.
  • Real-time AI decisioning using behavioral, contextual, and performance signals to optimize message delivery.
  • Enterprise-grade infrastructure with contracts supporting billions of messages and high deliverability standards.
  • Comprehensive API with documented endpoints for users, events, campaigns, and catalogs, plus an interactive API reference.
  • Helpful customer support with strong onboarding assistance cited across review sites.

Weaknesses

  • High total cost of ownership with opaque enterprise pricing starting at $20K+ annually.
  • Significant learning curve requiring extensive support and time investment to build competent workflows.
  • SMS deliverability reliability issues with account suspensions applied without clear explanation.
  • Cluttered UI requiring multiple navigation steps to complete common campaign management tasks.
  • Limited reporting consistency that complicates performance measurement and campaign optimization.
Twenty CRM logo

Twenty CRM

Destination

Strengths

  • AGPL-3.0 open-source license with full source code on GitHub — no vendor lock-in, no sunset risk.
  • Unlimited users and unlimited custom objects on self-hosted, with no feature gating based on headcount.
  • REST and GraphQL APIs available on all paid tiers, not locked behind an enterprise add-on fee.
  • MCP server and webhooks shipped as standard features, not premium upgrades.
  • Modern PostgreSQL-backed data model that developer teams can query, extend, and self-host.

Weaknesses

  • Recent v1.0 release means limited production hardening compared to CRMs with multi-year operational track records.
  • No native email sequencing or sales engagement tools — follow-up cadences require a separate platform.
  • No native two-way email sync or inbox integration, requiring third-party connectors for full activity logging.
  • Self-hosting 'free' pricing hides real infrastructure and DevOps costs that stack up over time.
  • Workflow automation is functional but lacks the complexity needed for sophisticated multi-step sales motions.

Complexity grading

How hard is this migration?

Standard CRM migration. 1 of 8 objects need a mapping; the rest are 1:1.

B

Overall complexity

Standard migration

Derived from compatibility, mapping clarity, API constraints, and data volume across Iterable and Twenty CRM.

  • Object compatibility

    B

    1 of 8 objects need a mapping; the rest are 1:1.

  • Field mapping clarity

    C

    Field mapping is derived from defaults — final spec confirmed during the sample migration.

  • Timeline complexity

    B

    8-object category — typical timelines run 2–7 days end-to-end.

  • API constraints

    B

    Iterable: Not publicly documented; returns RateLimitExceeded code on limit.

  • Data volume sensitivity

    A

    Iterable exposes a bulk API — large-volume migrations stream efficiently.

Estimator

Estimate your Iterable to Twenty CRM migration cost

Rule-based pricing — no per-record fees, no manual quotes. Migrations over 2M records are scoped individually.

Step 1

What are you migrating?

Pick a category, then your source and destination platforms.

Category

FAQ

Frequently asked questions about Iterable to Twenty CRM data migrations

Answers to the questions buyers ask most during Iterable to Twenty CRM migration scoping. Not seeing yours? Book a call.

Can't find your answer?

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 consultation

Most migrations land between two and four weeks for accounts under 50,000 User Profiles with a straightforward custom field schema and no high-volume Custom Event history. Migrations with over 1M Custom Events, multiple active Journeys, or a large Catalog requiring Custom Object schema design move to six to ten weeks because of Custom Object design, schema creation in Twenty, and the delta reconciliation passes required to validate lookup resolution across all records.

Adjacent paths

Related migrations to explore

Ready when you are

Move from Iterable.
Land in Twenty CRM, intact.

Tell us record counts and timeline. We'll come back with a written quote inside 1 business day — no commitment, no sales pitch.

Accuracy guarantee Rollback included Quote in 1 business day