CRM migration

Migrate from monday CRM to Twenty CRM

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

monday CRM logo

monday CRM

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

64%

7 of 11

objects map 1:1 between monday CRM and Twenty CRM.

Complexity

BStandard

Timeline

3-5 weeks

Rollback included Accuracy guarantee Field-level validation

Try the reverse

Twenty CRM
monday CRM

Overview

What this migration involves

Moving from monday CRM to Twenty CRM is a structural conversion, not a direct record copy. monday organizes CRM data as board Items with flexible columns on a flat board hierarchy; Twenty uses a relational object model with Company, People, Opportunity, and optional Custom Objects. We extract People from monday's CRM module, map Deals and pipeline stages to Twenty Opportunities, enumerate subitems individually (they are excluded from monday's bulk export), and flatten custom column types to Twenty custom fields. monday automations (Sentence Builder and the new workflows system) do not migrate; we deliver a written inventory of every automation rule with a Twenty workflow equivalent so your admin can rebuild. Board views, saved Kanban filters, and dashboard widgets also do not migrate; we preserve the underlying tabular data so your team can rebuild those views in Twenty from the imported records.

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

monday CRM logo

monday CRM

What's pushing teams away

  • Advanced features like forecasting, AI insights, chart views, and advanced automation require Pro tier, causing sticker shock as teams grow and feature requirements expand.
  • The board-and-item mental model does not naturally represent standard CRM relationships like Account-to-Contact or many-to-many Deal associations, leading to data duplication and confusion.
  • Per-seat pricing scales linearly with team size, and annual billing is non-refundable — teams that overbought on an annual contract feel locked in.
  • Integration automations built on the legacy Recipe infrastructure are being deprecated, forcing customers to rebuild workflows or risk breakage during migration projects.
  • Limited automation actions per month on lower tiers forces teams to purchase additional automation packs or upgrade, adding unexpected cost.

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

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

monday CRM

People (Contacts)

maps to

Twenty CRM

People

1:1
Fully supported

monday's People feature (inside the CRM module) maps to Twenty's People object. People stores name, email, phone, and CRM-specific properties as a distinct API entity from board Items. We map display name, primary email, primary phone, and any custom People properties to Twenty custom fields on the People object. Note: Twenty's out-of-box People standard fields are more limited than monday's CRM properties — industry, employee count, and social profiles require custom field creation before import. We flag missing standard fields during schema design so the Twenty workspace is provisioned correctly before CSV import.

monday CRM

Deal (CRM Item)

maps to

Twenty CRM

Opportunity

1:1
Fully supported

monday CRM Deals are CRM-typed Items attached to a Pipeline. Each Deal carries standard columns (deal value, close date, stage) plus optional custom columns. We map the deal value to Opportunity Amount, close date to CloseDate, and pipeline stage names to Opportunity StageName. The Twenty workspace must have matching StageName picklist values provisioned before import; we extract stage definitions from monday's Pipeline API response and create the corresponding stages in Twenty during schema setup.

monday CRM

Pipeline

maps to

Twenty CRM

Sales Process + Stage

lossy
Fully supported

monday Pipelines group Deals into ordered Stages with optional probability percentages. We extract each Pipeline's stage definitions (stage name, position, probability) and configure corresponding Opportunity stages in Twenty's Settings → Data Model. Probability percentages migrate to Twenty's StageProbability values. If the monday account has multiple Pipelines (each with its own stage set), we create multiple stage groups in Twenty or use a custom field (Pipeline Name) to differentiate if Twenty's stage model does not natively support multiple independent stage sets.

monday CRM

Board Item (non-CRM)

maps to

Twenty CRM

Note or Task

1:many
Fully supported

monday board Items that are not CRM-typed but contain relevant business data (activity notes, project-linked records) are evaluated during scoping. Items with a Name and long-text body map to Twenty Notes. Items with a due date and assignee map to Twenty Tasks. Items that represent products or services without a deal association may require a custom object in Twenty. We flag the item count per board during discovery so the customer can decide what to migrate versus archive.

monday CRM

Subitem

maps to

Twenty CRM

Custom Object Record or Note

1:many
Fully supported

Subitems are nested rows inside a monday Item and are excluded from monday's bulk account export and standard Excel export. We must enumerate each subitem individually via the monday API using the parent Item's ID, which multiplies API call volume. Each subitem migrates as a record in a Twenty custom object (linked to the parent Opportunity) or as a Note attached to the parent record, depending on the customer's chosen data model. The subitem enumeration count is scoped upfront because it directly affects API time and migration timeline.

monday CRM

Custom Column (board)

maps to

Twenty CRM

Custom Field (People, Opportunity, etc.)

lossy
Fully supported

monday supports over 20 column types including text, number, date, formula, dependency, link, and status. Custom columns are preserved as field definitions in monday exports. We map each custom column to a Twenty custom field on the relevant object (People, Opportunity, or a custom object). Formula and dependency columns in monday — which compute values based on other Items — have no direct Twenty equivalent and are flagged as 'computed field, requires rebuild' in the mapping document. Column types relying on monday-specific integrations (e.g., Integromat columns) are also flagged as non-migratable.

monday CRM

Updates (item comments)

maps to

Twenty CRM

Note

1:1
Fully supported

monday Updates are per-Item comment threads. The per-board Excel export can include Updates as a separate tab; via API, Updates are enumerable per Item. We preserve Update text and timestamps, mapping them to Twenty Note records attached to the parent record (People, Opportunity, or Company). The original author and timestamp migrate to Note fields. Rich text formatting in monday Updates is simplified to plain text in Twenty Notes.

monday CRM

File / Attachment

maps to

Twenty CRM

Attachment

1:1
Fully supported

Files uploaded to monday board Items are stored in monday's file storage. We retrieve file URLs via the monday API and re-attach them to the corresponding Twenty records (People, Opportunity, or Note). File attachments are included in the per-board export but can be excluded to reduce download time on large accounts. The customer chooses whether to include file attachments during scoping.

monday CRM

User / Team Member

maps to

Twenty CRM

User

1:1
Fully supported

monday Users are account members assigned as owners or collaborators. We map users by email and name. monday's permission structure (multi-level permissions, SAML SSO on Enterprise) is not part of the standard export and does not migrate. Twenty workspace membership must be configured manually before migration so that Owner lookups on Opportunity and Note can be resolved during import. We flag any monday Owner without a matching Twenty User for admin provisioning before the record import phase.

monday CRM

Automations

maps to

Twenty CRM

None (written inventory only)

1:1
Not supported

monday automations built on the Sentence Builder (Recipe) system or the new monday workflows system are workflow logic, not CRM data. They fire on item changes and cannot be extracted as transferable rules. We do not migrate automations. We deliver a written inventory of every active automation rule during pre-migration review, capturing the trigger, conditions, and actions with a recommended Twenty workflow equivalent. The customer's admin rebuilds automations in Twenty post-migration.

monday CRM

Dashboard

maps to

Twenty CRM

None (data preserved, views to rebuild)

1:1
Fully supported

monday Dashboards aggregate data across multiple boards into chart and summary widgets. They reference board Items and column data live. We cannot migrate dashboard definitions because they are view configurations, not data. We migrate the underlying tabular data so that Twenty views and reports can be rebuilt on top of the imported records. Saved Kanban filters, board views (Kanban, Calendar, Chart), and conditional colouring are similarly not migratable; we flag their configuration in the pre-migration review document.

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.

monday CRM logo

monday CRM gotchas

High

Subitems are not included in bulk exports

High

Daily API call limits vary sharply by plan

Medium

Legacy automations (Sentence Builder) are being deprecated

Medium

Excel and account exports only include table views

Low

Enterprise admins can disable non-admin exports

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

  • Subitems require individual API enumeration per parent Item

    monday's bulk account export and standard Excel export do not include Subitems — only parent Item rows. Subitems must be fetched individually via the monday API using each parent Item's ID, which multiplies API call volume significantly. A monday board with 500 Items and an average of 3 subitems per Item generates 2,000 additional API calls. On Basic and Standard plans (1,000 API calls/day cap), this alone can take multiple days to enumerate. We scope the subitem count during discovery, estimate the API load, and schedule the enumeration phase around daily rate limits with exponential backoff on 429 responses.

  • Twenty standard fields require manual pre-creation before import

    Twenty's out-of-box People and Company objects have a limited standard field set compared to monday's flexible CRM columns. Fields like industry, employee count, job title, website, and social profiles do not exist by default and must be created in Settings → Data Model before any CSV import runs. A GitHub issue on the Twenty repository (#13953) explicitly documents this as a friction point during CRM-to-Twenty migrations. We create all required custom fields in Twenty before importing data, and we flag any standard fields that are missing in Twenty's base schema as configuration items for the customer's Twenty admin to approve.

  • monday automations and board views do not migrate

    monday's Sentence Builder automations are being deprecated in favour of the new monday workflows system, and neither automation type is portable to Twenty. Board views (Kanban, Calendar, Chart, Map), saved filters with group-by or conditional colouring, and dashboard widgets are similarly excluded from monday's data export and have no Twenty equivalent. We capture automation rule definitions and non-table view configurations in a written inventory during pre-migration review. The customer's admin rebuilds board views in Twenty from the imported tabular data.

  • monday daily API limits can extend migration to multiple days

    Basic and Standard monday plans cap API calls at 1,000 per day; Pro allows 10,000 (soft limit) and Enterprise 25,000. For accounts with tens of thousands of Items and People contacts, these limits mean that a direct API migration cannot complete in a single session. We throttle migration jobs to stay within limits, schedule bulk jobs overnight to maximise the daily window, and use exponential backoff on 429 rate-limit responses. Large accounts on Basic or Standard plans may require a dedicated migration window of five to ten business days purely due to API volume.

  • Twenty's workflow builder is maturing; automation parity is not guaranteed

    Twenty's workflow builder is in active development. Users on the Twenty community channel have reported bugs, view instability, and performance degradation with record counts above 600. The CTO has acknowledged that quality improvements are currently the core team's priority following an aggressive feature-release cycle. We do not migrate monday automations to Twenty as code, and we advise customers to treat the automation rebuild as a post-migration configuration project with realistic expectations for Twenty's current workflow feature maturity.

Migration approach

Six steps for a successful monday CRM to Twenty CRM data migration

  1. Discovery and monday plan-tier scoping

    We audit the source monday account across plan tier (Basic/Standard/Pro/Enterprise), People count, CRM board count, Pipeline definitions, subitem count estimation, custom column types per board, active automation rule count, and file attachment volume. We use monday's account data export endpoint and per-board API queries to enumerate record counts. The daily API call limit for the account's plan tier is a critical scoping variable: Standard plans with large data volumes will require a multi-day migration window that we schedule outside business hours. The discovery output is a written migration scope with object counts, API volume estimate, and a recommendation on whether to include file attachments and activity history in the migration.

  2. Twenty workspace schema provisioning

    We configure the Twenty destination workspace before any data is written. This includes creating custom fields on the People and Company objects to match monday's CRM column types, configuring Opportunity StageName values to match the monday Pipeline stages (extracted from the Pipeline API response), creating any required custom objects for Subitems, and setting up picklist values for status and type fields. We also provision the workspace User list by email so that Owner lookups are resolved before record import. Twenty's constraint is that fields must exist before CSV import — we handle all schema creation in this step using Twenty's Settings → Data Model UI or API.

  3. monday People and Company extraction

    We extract People (Contacts) from monday's CRM module API as a distinct entity from board Items. If monday board Items contain company-level data (stored as a text column rather than a relational link), we extract those as well for later mapping to Twenty Companies. People email addresses are used as the primary deduplication key during import. We also enumerate Subitems individually per parent Item ID using monday's subitem API endpoint, because Subitems are excluded from the bulk account export. The subitem enumeration count is reported to the customer before the production migration window opens.

  4. monday Deal and pipeline extraction

    We extract all CRM-typed Items (Deals) from monday's Pipeline boards via the monday API. For each Deal, we capture the pipeline name, stage name, deal value, close date, assigned owner, and all custom column values. Pipeline stage definitions (stage names, position order, probability percentages) are extracted from monday's Pipeline API response and mapped to Twenty Opportunity StageName and StageProbability values. Any monday custom column that has no Twenty equivalent is flagged as 'requires rebuild' in the mapping document and its values are stored in a catch-all text field on the Opportunity for manual post-migration cleanup.

  5. Production migration in dependency order

    We run the production migration in record-dependency order: Twenty Users (validated against monday Owner list), Companies (from monday company-column data), People (with Company lookups resolved), Opportunities (with StageName, Owner, and Amount populated), Subitems (as custom object records linked to parent Opportunity), Notes (from monday Updates, attached to the parent record), and Activity history. Each phase emits a row-count reconciliation report comparing source record count to destination record count. We use exponential backoff and daily throttling on monday's API to stay within plan limits. File attachments are fetched by URL from monday's file storage and re-attached to the corresponding Twenty records.

  6. Cutover, validation, and automation rebuild handoff

    We freeze monday writes during cutover, run a final delta migration of any records modified during the migration window, then designate Twenty as the system of record. We deliver the Automation and Board View Inventory document to the customer's admin team, documenting every monday automation trigger, condition, and action with a recommended Twenty workflow equivalent. We deliver the Non-Table View Configuration document capturing Kanban layouts, saved filters, and dashboard widget definitions for manual rebuild in Twenty. We support a one-week hypercare window where we resolve reconciliation discrepancies raised by the customer's team. We do not rebuild monday automations as Twenty workflows inside the migration scope; that is a separate engagement or an internal admin task.

Platform deep dives

Context on both ends of the pair

monday CRM logo

monday CRM

Source

Strengths

  • Board-based UI makes pipeline stages and deal progress visually obvious without training.
  • No-code automation builder requires no developer resources to create lead routing and stage-triggered actions.
  • Flexible column system supports custom CRM fields without schema changes or admin involvement.
  • Integrates natively with Slack, Gmail, Outlook, and Zapier with minimal configuration overhead.
  • Layered product means teams already on monday Work Management can add CRM without migrating existing data.

Weaknesses

  • No native Contacts object separate from Items — contacts are managed inside a CRM module's People feature.
  • Pipeline and deal relationships use a flat item model rather than a relational object model, making complex CRM associations awkward.
  • Automations are plan-gated (250 actions/month on Standard, 25,000 on Pro) and the legacy Recipe system is being deprecated.
  • Customization and advanced views (Chart, Formula, Dependency) are locked behind Pro and Enterprise tiers.
  • Per-seat pricing with non-refundable annual billing creates cost lock-in risk during migration.
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 monday CRM 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

    monday CRM: Varies by plan — 200/day (Free/Trial), 1,000/day (Basic/Standard), 10,000/day soft limit (Pro), 25,000/day soft limit (Enterprise). Per-minute limits also apply..

  • Data volume sensitivity

    B

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

Estimator

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

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

Can't find your answer?

Walk through your monday CRM 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 three and five weeks for accounts under 10,000 People, 3,000 Deals, and straightforward pipeline structures. Accounts with heavy subitem hierarchies (requiring individual API enumeration per parent), multiple CRM boards, or complex custom column types move to six to ten weeks because of monday's API rate limits on Basic and Standard plans and the custom field provisioning work in Twenty. The monday API daily cap (1,000 calls/day on Basic/Standard) is the primary variable that extends timeline for larger accounts.

Adjacent paths

Related migrations to explore

Ready when you are

Move from monday CRM.
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