CRM migration
Field-level mapping, validation, and rollback between Moskit and Twenty CRM. We move data and schema; workflows are rebuilt natively in Twenty CRM.
Moskit
Source
Twenty CRM
Destination
Compatibility
5 of 10
objects map 1:1 between Moskit and Twenty CRM.
Complexity
BStandard
Timeline
4-6 weeks
Overview
Moving from Moskit to Twenty CRM is an internationalization and self-hosting migration. Moskit is priced in Brazilian Real, operates primarily in Portuguese, and has no publicly documented API rate limit, which requires migration tooling to probe and adapt dynamically. Twenty CRM is an open-source, AGPL-licensed platform available as a cloud service ($9/user/month for Cloud Pro API access) or self-hosted deployment. We use Twenty's REST API (cloud at api.twenty.com, self-hosted at your domain:3000) to import records in dependency order: Companies first, then Contacts with their Account lookups resolved, then Deals with stage configuration applied, then Activities as Tasks and Events, and finally Projects re-created as custom objects with a deal-link custom field. We do not migrate Moskit's WhatsApp message history (the content lives in WhatsApp's infrastructure), nor do we migrate Workflows or mass email campaigns; we deliver a written inventory of these for your admin to rebuild 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 Moskit 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.
Moskit
Contact (Contato)
Twenty CRM
Person
1:1Moskit Contacts map to Twenty's Person object. We extract all standard fields (name, email, phone, custom properties) via the Moskit REST API and map them to the corresponding Twenty Person fields. The mapping includes any Brazilian Portuguese picklist values, which we preserve in a field-label glossary so administrators can rename labels post-migration. Person records are inserted before any Opportunity import so that the Account-Person relationship resolves at insert time.
Moskit
Company (Empresa)
Twenty CRM
Company
1:1Moskit Companies map directly to Twenty Companies. The Moskit domain and address fields map to Twenty's domain and address compound fields. The company record is the first object imported because both Person (linked to a Company) and Opportunity (linked to a Company) depend on the Company foreign key. We resolve Moskit's company ID to the new Twenty company UUID before inserting any related Person or Opportunity records.
Moskit
Deal (Negócio)
Twenty CRM
Opportunity
1:1Moskit Deals map to Twenty Opportunities. The dealstage property maps to Twenty pipeline stage values that we configure in the workspace before migration. Closed-Won and Closed-Lost reason custom fields map to Twenty custom fields with equivalent picklists. The pipeline assignment in Moskit maps to a Twenty pipeline that we create via the workspace schema editor before migration begins.
Moskit
Activity (Atividade)
Twenty CRM
Task and Event
1:manyMoskit Activities (tasks, calls, meetings, notes) split into Twenty Tasks and Events based on activity type. Call activities map to Task with a task-subtype call field if Twenty has that field enabled; meeting activities map to Event with start and end timestamps preserved. Note-type activities map to Twenty Note records attached to the parent Person, Company, or Opportunity via ContentDocumentLink. Activity timestamps are preserved exactly as stored in Moskit to maintain the historical timeline.
Moskit
Project (Projeto)
Twenty CRM
Custom Object (Project)
lossyMoskit Projects do not have a direct Twenty equivalent because Twenty ships without a native project module. We create a custom Project object in the Twenty workspace with fields for project name, description, start date, due date, status, and a custom Opportunity link field that holds the migrated deal reference. This requires pre-creating the custom object schema in Twenty before the Project data import, which we do via the workspace schema editor or direct API call.
Moskit
Pipeline Stage
Twenty CRM
Pipeline Stage
lossyMoskit pipeline stages migrate as Twenty pipeline stage values. Each Moskit pipeline becomes a Twenty pipeline, and stage names and order are replicated. Stage probability percentages from Moskit are stored as custom fields in Twenty since the base Opportunity object may not expose probability per stage by default. We configure this during the pre-migration workspace setup phase.
Moskit
User (Usuário)
Twenty CRM
Workspace Member
1:1Moskit Users map to Twenty workspace Members. We extract every distinct user referenced on Contacts, Companies, Deals, and Activities and match by email against Twenty's user table. Any Moskit user without a matching Twenty account is placed in a reconciliation queue so the customer's admin can provision the account before record migration resumes. Inactive Moskit users are migrated with an inactive flag.
Moskit
Custom Property
Twenty CRM
Custom Field
lossyMoskit allows custom fields on Contacts, Companies, Deals, and Activities. These do not enumerate from a single API endpoint, so we query the schema per object type during extraction. We create equivalent custom fields in Twenty's workspace schema editor (or via API) before data migration, mapping Moskit field types (text, number, date, picklist) to the closest Twenty field type. Multi-checkbox picklists in Moskit may need to become multi-select picklists in Twenty, and we flag this type approximation during scoping.
Moskit
WhatsApp Conversation Metadata
Twenty CRM
Note on Person
lossyMoskit's WhatsApp Business integration stores conversation metadata (timestamps, participant count, message count) linked to Contact records, but the actual message content lives in WhatsApp's infrastructure. We import the conversation metadata as a Note attached to the corresponding Person record in Twenty, with a note body that lists the WhatsApp thread reference, date, and message count. Full message history does not migrate from WhatsApp and must be exported separately from WhatsApp's own data export tools.
Moskit
Mass Email Campaign
Twenty CRM
Custom Field + Inventory document
1:1Moskit mass email campaign records and campaign membership data do not have a native Twenty equivalent (Twenty has no built-in mass email campaign module). We export campaign membership as a custom Campaign Membership object in Twenty with a Person lookup and campaign reference fields. Campaign content (templates, send history) is documented in a written inventory for the customer's admin to rebuild using their preferred email sending tool (e.g., Apollo, Instantly, Mailchimp) integrated with Twenty via Zapier or direct API.
| Moskit | Twenty CRM | Compatibility | |
|---|---|---|---|
| Contact (Contato) | Person1:1 | Fully supported | |
| Company (Empresa) | Company1:1 | Fully supported | |
| Deal (Negócio) | Opportunity1:1 | Fully supported | |
| Activity (Atividade) | Task and Event1:many | Fully supported | |
| Project (Projeto) | Custom Object (Project)lossy | Fully supported | |
| Pipeline Stage | Pipeline Stagelossy | Fully supported | |
| User (Usuário) | Workspace Member1:1 | Fully supported | |
| Custom Property | Custom Fieldlossy | Fully supported | |
| WhatsApp Conversation Metadata | Note on Personlossy | Fully supported | |
| Mass Email Campaign | Custom Field + Inventory document1:1 | 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.
Moskit gotchas
No published API rate limit documentation
WhatsApp conversation sync is a linked feature, not standalone data
Deal-to-Project linkage must be explicitly preserved
Custom field definitions vary by object and are not enumerated in bulk
Brazilian Portuguese field labels may cause mapping mismatches
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
Workspace setup and API access validation
We provision the Twenty destination workspace and validate REST API access. For cloud deployments, we generate a bearer token from the Cloud Pro account settings and confirm connectivity to api.twenty.com. For self-hosted deployments, we validate the token endpoint and confirm the instance is running a stable release (v1.x). We simultaneously generate a Moskit API key from the Marketplace module and run a probe request against each object type endpoint (Contact, Company, Deal, Activity, Project) to confirm authentication and measure response shape before full extraction begins.
Schema discovery and field mapping
Moskit does not expose custom field definitions from a single schema endpoint. We run separate schema-discovery requests for each object type (Contact, Company, Deal, Activity, Project) to retrieve the available fields including custom properties. We cross-reference these against Twenty's standard field list and the custom fields we pre-create in the destination workspace. We produce a field-mapping document that specifies the Moskit field name, the Twenty field name, the data type transformation (e.g., Moskit picklist to Twenty picklist, Moskit multi-checkbox to Twenty multi-select), and any field that requires manual post-migration review.
Twenty workspace schema configuration
Before any data import, we configure the Twenty workspace: we create the custom Project object (with Opportunity link field), create any custom fields needed for pipeline stage probabilities and custom deal properties, configure pipeline stages matching the Moskit stage names and order, and provision workspace Members that correspond to Moskit Users matched by email. We run this configuration against a staging or sandbox-like workspace first to validate before production import.
Record extraction and transformation in dependency order
We extract and transform records from Moskit in dependency-safe order: Companies first (since Persons and Opportunities both link to them), then Persons with Account lookups resolved to the new Twenty company UUIDs, then Opportunities with pipeline stage and owner resolved, then Activities as Tasks and Events, then Projects with the deal-link field resolved from the Opportunity mapping. We apply the two-pass deal-ID-to-UUID resolution for Projects. Each extraction phase produces a row-count reconciliation report.
Sandbox migration and reconciliation
We run a full migration into the Twenty production workspace (or a separate staging workspace if the customer requests a dry run) and reconcile record counts, field completeness, and relationship integrity. The customer spot-checks 25-50 records against the Moskit source to confirm accuracy before cutover. Any mapping corrections are made and re-validated before final production migration.
Cutover, delta sync, and automation inventory handoff
We freeze Moskit writes during the cutover window, run a final delta extraction of any records modified during the migration, and import the delta into Twenty. We verify that Person-Company relationships, Opportunity-Company relationships, and Project-Opportunity links are intact after the delta sync. We deliver the written automation inventory (Moskit mass email campaigns, any active workflow-equivalent features, WhatsApp conversation metadata scope) to the customer's admin for rebuild in Twenty's workflow builder. We provide a one-week hypercare window for reconciliation issues raised by the team.
Platform deep dives
Moskit
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 Moskit 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
Moskit: Not publicly documented.
Data volume sensitivity
Moskit 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 Moskit to Twenty CRM migration scoping. Not seeing yours? Book a call.
Walk through your Moskit 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 Moskit
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.