CRM migration
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
Source
Twenty CRM
Destination
Compatibility
8 of 12
objects map 1:1 between Lime CRM and Twenty CRM.
Complexity
BStandard
Timeline
3-5 weeks
Overview
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.
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 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
Twenty CRM
Company
1:1Lime 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
Twenty CRM
Person
1:1Lime 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
Twenty CRM
Opportunity
1:1Lime 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)
Twenty CRM
Custom Object
lossyLime 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)
Twenty CRM
Task or Note
1:1Lime 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
Twenty CRM
Task (Email type)
lossyLime 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
Twenty CRM
Task (Support type)
1:1Lime 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
Twenty CRM
Attachment (stored alongside records)
1:1Lime 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
Twenty CRM
Tag
lossyTags 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
Twenty CRM
Workspace Member
1:1Lime 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)
Twenty CRM
Attachment (manual reconstruction)
1:1Lime 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
Twenty CRM
Workflow (reconstruction required)
lossyLime 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.
| Lime CRM | Twenty CRM | Compatibility | |
|---|---|---|---|
| Company | Company1:1 | Fully supported | |
| Contact | Person1:1 | Fully supported | |
| Deal | Opportunity1:1 | Fully supported | |
| Custom Limetype (per-tenant) | Custom Objectlossy | Fully supported | |
| Activity (Call, Meeting, Task) | Task or Note1:1 | Fully supported | |
| Email Conversation | Task (Email type)lossy | Fully supported | |
| Ticket | Task (Support type)1:1 | Fully supported | |
| Attachment | Attachment (stored alongside records)1:1 | Fully supported | |
| Tag | Taglossy | Fully supported | |
| User and Owner | Workspace Member1:1 | Fully supported | |
| Document (auto-fill templates) | Attachment (manual reconstruction)1:1 | Fully supported | |
| Workflow Automation | Workflow (reconstruction required)lossy | 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.
Lime CRM gotchas
Email threads export as individual message files
Super API-key generation removed from API
Custom Limetype schema is customer-unique
No bulk export for attachments in base tier
Workflow Automations do not export in transferable format
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 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.
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.
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.
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.
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.
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
Lime CRM
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 Lime CRM 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
Lime CRM: Not publicly documented.
Data volume sensitivity
Lime CRM doesn't expose a bulk API — REST + parallelization used for high-volume runs.
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 Lime CRM to Twenty CRM migration scoping. Not seeing yours? Book a call.
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 consultationAdjacent paths
Other ways to leave Lime CRM
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.