CRM migration

Migrate from erxes to Twenty CRM

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

erxes logo

erxes

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

60%

6 of 10

objects map 1:1 between erxes and Twenty CRM.

Complexity

BStandard

Timeline

4-8 weeks

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

Moving from erxes to Twenty CRM is a migration between two self-hosted open-source CRMs with different architectural models. erxes organizes data around its plugin-based XOS architecture with Contacts, Companies, Deals, Tasks, and multi-channel Conversations accessed via GraphQL with no native bulk export. Twenty CRM, backed by Y Combinator S23 and built in TypeScript with Next.js and NestJS, uses a more conventional CRM object model with People, Companies, Opportunities, and Tasks accessed via REST and GraphQL. We resolve the extraction challenge (erxes requires paginated GraphQL queries rather than a bulk export UI), verify plugin activation states before reading any module data, validate erxes schema-less custom field values against Twenty's typed field model, and migrate records in dependency order with parent-record lookup resolution. Automation workflows and sequences do not migrate; we deliver a written inventory of every active automation for the customer's admin to rebuild in Twenty.

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

erxes logo

erxes

What's pushing teams away

  • Steep learning curve for non-technical teams who expect a point-and-click CRM without touching code or GraphQL
  • Limited enterprise-grade documentation and support outside the paid Enterprise tier leaves self-hosted teams troubleshooting alone
  • Plugin ecosystem lacks the third-party integrations available on established platforms, requiring custom development for niche tools
  • Mobile app has stability issues according to App Store reviews, with login failures reported by multiple users
  • Performance and stability can degrade with large datasets when running on underpowered self-hosted infrastructure

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 erxes objects map to Twenty CRM

Each row shows how a erxes 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.

erxes

Contact

maps to

Twenty CRM

Person

1:1
Fully supported

erxes Contacts migrate directly to Twenty CRM People records. Standard fields (name, email, phone, primaryAddress) map to the corresponding Twenty Person fields. We extract custom field values from erxes' property system and map them to Twenty custom fields, validating type compatibility (text, number, date, select) against Twenty's field definitions before insert. Any erxes Contact without an email receives a generated placeholder and a custom flag for manual review.

erxes

Company

maps to

Twenty CRM

Company

1:1
Fully supported

erxes Company records map 1:1 to Twenty CRM Companies. The company domain, industry, size, and address fields migrate directly. We resolve the linked Contacts to associate them with the migrated Company record using the companyId reference preserved in the erxes data model. Company is created before Person import so the lookup relationship is satisfied at insert time.

erxes

Deal

maps to

Twenty CRM

Opportunity

1:1
Fully supported

erxes Deals map to Twenty CRM Opportunities with the deal amount, stage, and custom fields preserved. We translate the erxes dealstage property to Twenty's Opportunity stage values. Any erxes Deals without a linked Company are imported with a placeholder Company record to satisfy the lookup requirement, and we flag these for the customer's admin to reconcile after migration.

erxes

Pipeline

maps to

Twenty CRM

Pipeline

1:1
Fully supported

erxes Pipelines define the sales workflow stages and map directly to Twenty CRM Pipelines. Stage order, names, and probability mappings migrate as configuration. We create the Twenty Pipeline first, then create the stage definitions with the correct sort order before importing Deals so that stage lookups are available at insert time.

erxes

Task

maps to

Twenty CRM

Task

1:1
Fully supported

erxes Tasks migrate to Twenty CRM Tasks with title, description, due date, status, and priority preserved. Task ownership migrates by resolving the erxes userId to the Twenty WorkspaceMember via email match. Tasks linked to specific Contacts or Deals maintain their association through the appropriate lookup fields in Twenty's data model.

erxes

Conversation

maps to

Twenty CRM

Activity + Comment

1:many
Fully supported

erxes multi-channel Conversations (email, SMS, chat, WhatsApp) migrate to Twenty as Activity records with Comment records for the message thread. We preserve the conversation metadata (channel type, direction, customer identifier) and the message body, author, and timestamp. Message ordering depends on erxes' server-side createdAt timestamps which we preserve during import. Channel credentials (API keys, webhook URLs) do not migrate and are flagged for manual reconfiguration in Twenty's workspace settings.

erxes

Custom Field (on Contacts)

maps to

Twenty CRM

Custom Field (on Person)

lossy
Fully supported

erxes custom fields on Contacts map to Twenty custom fields on the Person object. We validate erxes' schema-less values against Twenty's typed field model before import and flag any type mismatches. For example, if an erxes date custom field contains a text string (which erxes allows), we flag the record and either correct the value or exclude it from that field with a reconciliation note.

erxes

Custom Field (on Deals)

maps to

Twenty CRM

Custom Field (on Opportunity)

lossy
Fully supported

erxes custom fields on Deals map to Twenty custom fields on the Opportunity object. Same type-validation approach applies: erxes allows any value to be written to any custom field regardless of UI-defined type, so we validate against Twenty's field schema and flag mismatches. Complex custom field structures (multi-select, relational) are documented separately for the customer's admin to verify in Twenty's data model.

erxes

User / Team Member

maps to

Twenty CRM

WorkspaceMember

1:1
Fully supported

erxes Users map to Twenty WorkspaceMembers via email match. Role and permission configurations are documented for manual review because Twenty's role model differs from erxes' plugin-based permission system. We extract all distinct users referenced on records (Contacts, Companies, Deals, Tasks, Conversations) to build the user mapping table, and flag any erxes user without a matching Twenty WorkspaceMember for the customer's admin to provision before record import.

erxes

Automation Workflow

maps to

Twenty CRM

(no migration)

lossy
Fully supported

erxes Automation Workflows are not migrated as code. We extract the full workflow structure including triggers, conditions, and actions from the erxes plugin configuration and deliver a written inventory document. Each automation is documented with its name, trigger type, conditions, action sequence, and a recommended Twenty equivalent or note that the workflow pattern is not supported. The customer's admin rebuilds automations in Twenty post-migration.

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.

erxes logo

erxes gotchas

High

No native bulk export in Community edition

Medium

Plugin activation state affects data visibility

Medium

Custom fields have no type enforcement during import

Low

Conversation message ordering depends on server timestamps

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

  • erxes has no native bulk export API endpoint

    erxes does not ship a bulk export UI or a dedicated export API in its Community edition. All data extraction requires individual paginated GraphQL queries against the erxes API. We work around this by programmatically iterating through query results with cursor-based pagination, but large datasets (100k+ records) require chunking strategies and careful rate-limit management to avoid timeouts during extraction. We run extraction in record-type batches (Contacts, Companies, Deals, Tasks, Conversations) with checkpointing so that a timeout mid-extraction does not require restarting from zero.

  • Plugin activation state gates data visibility

    erxes modules (Sales, Marketing, Operations, Commerce) must be activated in the plugin configuration for their data objects to be accessible via the API. If a customer deactivated a plugin before migration, related Deals, Tasks, or Conversations become invisible to the API even if records exist in the database. We confirm all relevant plugins are active during the pre-migration audit phase and document any plugin that was deactivated, its associated object types, and the records that would be affected if we proceeded without reactivation.

  • erxes custom fields accept any type at write time

    erxes custom fields are schema-less on ingest—any value can be written to any custom field regardless of the field type defined in the UI. This means a date field can receive a text string and erxes will accept it. Twenty CRM enforces field types on import. We validate erxes custom field values against Twenty's field definitions before loading and flag records where type mismatches occur. These records are held in a reconciliation queue for the customer's admin to correct before the field migrates.

  • Conversation message ordering depends on server timestamps

    erxes Conversation messages store a createdAt timestamp from the server at write time. When migrating message threads, the chronological order in Twenty depends on these server-side timestamps. We preserve the original createdAt values during import to maintain message ordering, but clock skew between the source erxes instance and Twenty's server may cause minor ordering discrepancies in edge cases with high message volume and rapid succession.

  • Twenty's custom field model requires pre-creation

    Twenty CRM requires custom fields to be defined in the workspace settings before data can be written to them. Unlike erxes which accepts any property on ingest, Twenty enforces the schema upfront. We create all custom fields in Twenty's data model before any record import begins, mapping erxes field names and types to the equivalent Twenty field definition. Any erxes custom field that cannot map cleanly to a Twenty field type (e.g., complex nested objects) is documented for the customer's admin to handle as a custom configuration.

Migration approach

Six steps for a successful erxes to Twenty CRM data migration

  1. Pre-migration audit and plugin activation verification

    We audit the source erxes instance across all active plugins, custom field definitions on Contacts, Companies, Deals, and Tasks, pipeline and stage configurations, active automation workflow count, and engagement volume (tasks, conversations). We specifically verify that all plugins whose data the customer wants migrated are currently active, because deactivating a plugin hides its data from the API. The audit output is a written scope document listing every erxes object type, record count estimate, custom field schema, and a confirmation of plugin activation status.

  2. GraphQL extraction with pagination and checkpointing

    We build a programmatic extraction job that queries erxes via GraphQL using cursor-based pagination. Each record type (Contacts, Companies, Deals, Tasks, Conversations) is extracted as a separate batch with checkpointing so that job interruption does not require a full restart. We implement exponential backoff on rate-limit responses and chunk large result sets to avoid memory exhaustion on the extraction host. The extraction output is a set of structured JSON files organized by object type, ready for transformation.

  3. Twenty workspace setup and custom field creation

    Before any record import, we create the Twenty CRM workspace configuration including Pipelines, Pipeline Stages, and all custom fields. Custom fields are defined with the correct type (text, number, date, select, multi-select) matching the erxes field schema. We run this configuration into a Twenty test workspace first to validate the field definitions and confirm that the import process accepts the migrated values without type errors.

  4. Sandbox migration and record-count reconciliation

    We run a full migration into Twenty's test environment using production-like data volume. The customer's admin reviews record counts (People, Companies, Opportunities, Tasks, Activities) against the source erxes counts, spot-checks 25-50 random records for field-level accuracy, and validates that the pipeline stage assignments and custom field values are correct. Any mapping corrections (field name mismatches, type validation failures, missing lookups) happen in this phase. The customer signs off before production migration begins.

  5. User provisioning and owner reconciliation

    We extract every distinct erxes user referenced on Contacts, Companies, Deals, Tasks, and Conversations and match by email against the Twenty workspace's WorkspaceMembers. Any erxes user without a matching Twenty account goes to a reconciliation queue for the customer's admin to provision. Owner assignments on migrated records cannot be finalized until all referenced users exist in Twenty. We run a second pass after user provisioning to update OwnerId lookups on all previously imported records.

  6. Production migration in dependency order

    We run production migration in record-dependency order: Companies (first, because People need a Company lookup), People (with companyId resolved), Opportunities (with companyId and Pipeline stage resolved), Tasks (with ownerId resolved via email match), Activity history and Conversation threads (with Person and Opportunity lookups resolved). Each phase emits a row-count reconciliation report before the next phase begins. Automation workflow inventory is delivered as a separate document alongside the migration reports.

Platform deep dives

Context on both ends of the pair

erxes logo

erxes

Source

Strengths

  • True open-source with MIT license gives full code access and modification rights without vendor lock-in
  • Self-hosting option on DigitalOcean, AWS, or on-premise infrastructure provides complete data residency control
  • All-in-one platform consolidating marketing, sales, operations, and customer service modules
  • Plugin-based architecture allows activating only needed functionality without paying for unused features
  • Free Community edition offers generous feature set comparable to paid SaaS CRM tiers

Weaknesses

  • Steep technical learning curve requiring GraphQL knowledge and React familiarity for deep customization
  • Limited third-party integration marketplace compared to established CRM platforms
  • Documentation gaps make self-service troubleshooting difficult outside of paid support tiers
  • Mobile application stability issues reported in user reviews with authentication failures
  • Performance can degrade with large data volumes on underpowered self-hosted deployments
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. 2 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 erxes and Twenty CRM.

  • Object compatibility

    B

    2 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

    erxes: Not publicly documented.

  • Data volume sensitivity

    B

    erxes doesn't expose a bulk API — REST + parallelization used for high-volume runs.

Estimator

Estimate your erxes 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 erxes to Twenty CRM data migrations

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

Can't find your answer?

Walk through your erxes 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 four and eight weeks for accounts under 20,000 Contacts and 5,000 Deals with no custom objects and a clean plugin configuration. Migrations with multiple active erxes plugins, large custom field sets, substantial conversation history (over 100,000 messages), or complex pipeline structures move to ten to fourteen weeks because of GraphQL pagination extraction time, field-type validation, and the automation inventory documentation work.

Adjacent paths

Related migrations to explore

Ready when you are

Move from erxes.
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