CRM migration

Migrate from Lime CRM to Twenty CRM

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

Lime CRM logo

Lime CRM

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

67%

8 of 12

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

Complexity

BStandard

Timeline

3-5 weeks

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

Moving from Lime CRM to Twenty CRM requires navigating two fundamentally different data philosophies. Lime CRM organises data around Limetypes that each organisation configures independently, meaning there is no canonical schema across tenants and every migration begins with live schema discovery. Twenty CRM uses standard objects (Company, Person, Opportunity, Task, Note) with a custom object layer that must be provisioned before CSV import. We handle the discovery phase to capture every Limetype definition, reassemble email threads from Lime CRM's per-message file export, resolve owner records by email match against Twenty workspace members, and sequence the import so parent records exist before child records are loaded. Workflow automations, GDPR-portal configurations, and custom web components do not migrate in transferable format; we document them for reconstruction in Twenty's workflow builder.

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

Lime CRM logo

Lime CRM

What's pushing teams away

  • Integrations are reported as limited and immature, forcing teams to log emails manually rather than having them auto-linked to customer records, deal profiles, or company accounts.
  • The desktop client is described as slow by multiple reviewers, particularly when navigating large datasets or running reports across custom objects.
  • Global CRM competitors offer richer native feature sets out of the box, so teams requiring advanced marketing automation, AI-powered lead scoring, or built-in calling often find Lime CRM requires more customisation to match feature parity.
  • Feature depth is described as limited compared to platforms like Salesforce or HubSpot, with some mid-market teams citing insufficient advanced capabilities as they scale beyond 50–200 users.

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

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

Lime CRM

Company

maps to

Twenty CRM

Company

1:1
Fully supported

Lime CRM Company records (sometimes called Account in certain industry variants) map directly to Twenty CRM Company. Standard fields including name, address, industry, website, and phone transfer cleanly. We use company name as the dedupe key during import. Company must be imported before any Person record that references it, because the Company record must exist to satisfy the Person's companyLink relationship.

Lime CRM

Contact

maps to

Twenty CRM

Person

1:1
Fully supported

Lime CRM Contact records map to Twenty CRM Person. Name fields, email address, phone numbers, and any standard contact properties transfer directly. We normalise phone number formats during transformation to prevent the leading-zero stripping that commonly occurs with international numbers during CSV import. Person records are imported after Company records so that the company relationship can be resolved at import time rather than through a post-import reconciliation pass.

Lime CRM

Deal

maps to

Twenty CRM

Opportunity

1:1
Fully supported

Lime CRM Deals map to Twenty CRM Opportunity. The dealstage property maps to the destination StageName, and pipeline assignments map to Twenty pipeline stages that we configure during workspace preparation. Deal value, expected close date, owner, and associated Company and Contact relationships all transfer. Closed-won and closed-lost reasons from Lime CRM custom fields become Opportunity custom fields in Twenty.

Lime CRM

Custom Limetype (per-tenant)

maps to

Twenty CRM

Custom Object

lossy
Fully supported

Lime CRM's Limetypes have no canonical schema across tenants. During discovery, we export the live Limetype definition from the customer's Lime CRM admin and document every property including field name, data type, relation type (BelongsTo, HasMany), and any custom validation. Each Limetype maps to a Twenty CRM Custom Object created via Settings → Data Model before import. Properties with BelongsTo relations resolve to existing Company or Person records; HasMany relations are created after the parent record exists. This mapping phase is the primary driver of timeline for complex Lime CRM tenants.

Lime CRM

Activity (Call, Meeting, Task)

maps to

Twenty CRM

Task or Note

1:1
Fully supported

Lime CRM Activities representing logged calls, meetings, tasks, and notes attached to a Contact or Deal migrate to Twenty CRM as Task or Note records. Call records map with TaskSubtype preserved. Meeting records with start and end times map to Task with the time preserved. Notes with rich text content map to Note records. Each record carries a link back to the parent Person or Opportunity, and the ActivityDate timestamp is preserved for timeline ordering.

Lime CRM

Email Conversation

maps to

Twenty CRM

Task (Email type)

lossy
Fully supported

Lime CRM exports email conversations as individual ConversationMessage files rather than threaded records. We detect this at scoping, reassemble threads by conversation ID and timestamp during the transformation phase, and inject them into Twenty CRM as a unified activity record per thread rather than per message. Sender, recipient, subject, body, and timestamp are preserved. This transformation step is unique to Lime CRM migrations and is applied before any CSV is presented to Twenty's import tool.

Lime CRM

Ticket

maps to

Twenty CRM

Task (Support type)

1:1
Fully supported

Lime CRM Ticket records migrate to Twenty CRM as Task records with a support-type classification and associated status values. Ticket pipeline stages map to Task status values, priority transfers to Priority, and assignee resolves by email match against Twenty workspace members. Ticket conversation history is processed through the email thread reassembly logic and imported as related activity records linked to the Task.

Lime CRM

Attachment

maps to

Twenty CRM

Attachment (stored alongside records)

1:1
Fully supported

Lime CRM attachments are downloaded individually per record without bulk export support in the base tier. We batch download all attachment files, validate file integrity against the export manifest (catching any truncated or missing files before the destination import begins), and rename files to preserve the parent record relationship. Files exceeding 25 MB are flagged for manual handling because they may require chunked upload or a direct storage migration approach. The Twenty import CSV references the attachment path so records display their linked files after migration.

Lime CRM

Tag

maps to

Twenty CRM

Tag

lossy
Fully supported

Tags from Lime CRM (applied to Contacts, Deals, and Tickets) export as a flat list per record. We preserve the tag taxonomy as a flat list and recreate tag values in Twenty. The customer chooses whether to apply tags as direct values or to use Twenty's Topics feature during scoping. Tag inheritance across object types is noted and handled per the destination's tagging model.

Lime CRM

User and Owner

maps to

Twenty CRM

Workspace Member

1:1
Fully supported

Lime CRM User records and Deal owners resolve by email match against Twenty CRM workspace members. We validate that a destination member exists for every owner referenced in the migration before importing Opportunities and Activities, because owner resolution is required for Activity assignment. Users without a matching Twenty member enter a reconciliation queue for the customer's admin to provision before the migration resumes.

Lime CRM

Document (auto-fill templates)

maps to

Twenty CRM

Attachment (manual reconstruction)

1:1
Fully supported

Lime CRM Documents with auto-fill templates export as document blobs with metadata. The document blob migrates as a file attachment to the related Person or Opportunity. Template auto-fill field mappings require manual reconstruction in Twenty because template logic does not export in transferable format. We document the template structure during discovery for the customer's admin to rebuild using Twenty's document capabilities or a third-party document tool.

Lime CRM

Workflow Automation

maps to

Twenty CRM

Workflow (reconstruction required)

lossy
Fully supported

Lime CRM workflow automations (ticket assignment rules, follow-up triggers, status change alerts) cannot be exported as machine-readable files. We capture the automation logic from the Lime CRM UI during discovery, document each rule's trigger, conditions, and actions, and deliver a written inventory for reconstruction in Twenty's workflow builder. Complex multi-step flows requiring branching logic, time-based delays, or cross-object triggers require manual reconfiguration by the customer's admin or a consultant engagement.

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.

Lime CRM logo

Lime CRM gotchas

High

Email threads export as individual message files

High

Super API-key generation removed from API

Medium

Custom Limetype schema is customer-unique

Medium

No bulk export for attachments in base tier

Medium

Workflow Automations do not export in transferable format

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

  • Lime CRM Limetype schema is customer-unique with no stable canonical definition

    Lime CRM's data model is built around Limetypes that each organisation configures independently. There is no stable schema across tenants, which means the migration scope cannot be defined from external documentation alone. We must export the live Limetype definition from the customer's Lime CRM admin during discovery before any field mapping can begin. Each custom field is treated as a mapping workstream, not a direct transfer. This discovery step adds one to two weeks to the project timeline for complex tenants with many custom Limetypes.

  • Email threads export as individual message files requiring reassembly

    Lime CRM does not export email conversations as threaded objects. Each ConversationMessage is a separate file in the export, not a linked conversation record. Without reassembly, the migration arrives in Twenty CRM as hundreds of disconnected message files with no parent thread reference. We detect this at scoping, regroup messages by conversation ID and timestamp, and inject them as unified activity records so the timeline is intact and readable in Twenty.

  • Super API-key generation removed from Lime CRM API in v4.195.0

    As of June 2025, Lime CRM removed the ability to generate new super API-keys via the API itself. We cannot self-provision credentials from within the platform. Credentials must be requested through Lime Technologies' account management or support channels before migration begins, with a typical acquisition lead time of two to five business days. We flag this in the discovery call and build the credential step into the project schedule as a hard dependency.

  • Twenty CRM requires custom objects and fields to exist before CSV import

    Twenty CRM's CSV import creates records but not fields or objects. Custom fields and custom objects must be provisioned in Settings → Data Model before the import file is presented. For Lime CRM migrations with many custom Limetypes, we create all destination schema before beginning data import, which requires the Limetype discovery phase to complete first. Skipping this step results in custom fields being silently ignored during import.

  • No bulk export for attachments in Lime CRM base tier

    Attachment files are downloaded individually per record rather than as a bulk archive. For migrations with more than 10,000 attachment files, we batch downloads, validate each file against the export manifest, and flag any truncated or missing files before the destination import begins. This validation step adds time proportional to the attachment volume and is scoped separately during discovery.

Migration approach

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

  1. Discovery and credential acquisition

    We audit the source Lime CRM tenant across the live Limetype schema, record counts per object type, activity volume (calls, meetings, tasks, emails), attachment file count and total size, active workflow rules, and GDPR export availability. We simultaneously request API credentials through Lime Technologies' account management because super API-key generation was removed from the API in v4.195.0. The discovery output is a written migration scope including every Limetype, its properties, and the relationship definitions, plus a confirmed credential delivery date from Lime Technologies.

  2. Limetype schema capture and Twenty workspace preparation

    We export every Limetype definition from the customer's Lime CRM admin, document each property (field name, data type, relation type, required flag), and map each Limetype to a Twenty CRM Custom Object. We create all custom objects and custom fields in the Twenty CRM workspace via Settings → Data Model before any data import begins, because Twenty requires the schema to exist before CSV import can populate records. We also invite all team members to the Twenty workspace and validate that all owner email addresses have corresponding workspace accounts.

  3. Email thread reassembly and data transformation

    We process Lime CRM's email export (individual ConversationMessage files) by conversation ID and timestamp to reconstruct threaded records. Each reassembled thread is formatted as a single activity record per thread with the sender, all recipients, subject, full body, and earliest timestamp preserved. We also normalise phone number formats, standardise address formats, deduplicate records on name-and-email pairs, and apply any value mappings defined during scoping. The output is a set of clean CSVs ready for Twenty's import tool.

  4. Sequential import in dependency order

    We import records into Twenty CRM in the dependency order that Twenty's documentation specifies: Companies first, then People, then Opportunities, then Tasks and Notes, then Custom Objects last. Each phase emits a row-count reconciliation report before the next phase begins. Attachments are imported after their parent records exist, with file integrity validated against the manifest before each batch is committed. Owner references are resolved by email match against the Twenty workspace members list.

  5. Attachment migration and deduplication validation

    We batch download all Lime CRM attachment files, validate each against the export manifest (catching any truncated or missing files before the destination import begins), rename files to preserve the parent record relationship, and link them to the corresponding Twenty CRM records. Files exceeding 25 MB are flagged for manual handling. We also run a deduplication pass against the imported records to catch any name-and-email duplicates that were not removed during transformation.

  6. Cutover, validation, and workflow handoff

    We freeze writes in Lime CRM during the cutover window, run a final delta migration of any records modified during the migration window, then deliver the migration as complete. We provide a written inventory of every Lime CRM workflow automation with its trigger, conditions, and actions for reconstruction in Twenty's workflow builder. We support a one-week post-cutover window to resolve any reconciliation issues. We do not rebuild Lime CRM automations as Twenty workflows inside the migration scope; that work is a separate engagement or an internal admin task.

Platform deep dives

Context on both ends of the pair

Lime CRM logo

Lime CRM

Source

Strengths

  • Configurable Limetypes let each organisation define its own data model without developer involvement.
  • All features (automations, BI, templates, map views) are included from the Start tier without add-on fees.
  • Industry variants are pre-built for insurance, real estate, and professional services with sector-appropriate field sets.
  • GDPR compliance features are native, including consent management, customer-facing data portals, and JSON export.
  • Runs on Lime-hosted cloud or on the customer's own server, addressing data residency requirements.

Weaknesses

  • Native integrations are sparse and require manual workarounds such as manual email logging.
  • Desktop client performance degrades with large custom object datasets.
  • Feature set is shallower than global CRM platforms for advanced marketing and AI capabilities.
  • Custom Limetype schema varies per organisation, requiring per-customer analysis before migration can begin.
  • Release cadence and documentation suggest a smaller global support footprint compared to tier-one CRM vendors.
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 Lime 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

    Lime CRM: Not publicly documented.

  • Data volume sensitivity

    B

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

Estimator

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

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

Can't find your answer?

Walk through your Lime 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 tenants with two to five Limetypes, fewer than 20,000 records, and straightforward activity histories. Migrations with complex multi-Limetype schemas (more than five custom object types), large activity histories (100,000+ records), or extensive email thread reassembly requirements move to eight to twelve weeks because the Limetype discovery and schema creation phases must complete before any data import can begin.

Adjacent paths

Related migrations to explore

Ready when you are

Move from Lime 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