CRM migration

Migrate from Moskit to Twenty CRM

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

Moskit logo

Moskit

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

50%

5 of 10

objects map 1:1 between Moskit and Twenty CRM.

Complexity

BStandard

Timeline

4-6 weeks

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

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.

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

Moskit logo

Moskit

What's pushing teams away

  • Weak analytics — G2 and SoftwareWorld reviewers consistently flag that 'the analytics are not good' compared to international competitors, pushing data-driven sales teams toward HubSpot, Pipedrive, or Salesforce.
  • Feature gaps versus mature CRMs — reviewers note 'a few features that you can find on others CRMs missing on Moskit', so growing teams that hit a missing-feature wall migrate out.
  • Limited international presence — Moskit is concentrated in Brazil with Portuguese-first support and documentation; multi-country sales operations expand to Pipedrive, Zoho CRM, or HubSpot for global team coverage.
  • Narrow integration ecosystem versus international leaders — beyond WhatsApp, email, and Brazilian payment/telephony, the third-party connector library is meaningfully thinner than HubSpot's or Pipedrive's marketplaces.
  • Competitive Brazilian field — Atendare, Upsales, and Teamgate are cited as direct Moskit competitors in the Brazilian SMB space, so buyers comparison-shop heavily and Moskit loses deals where competitors offer slightly broader analytics or integration depth.

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

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)

maps to

Twenty CRM

Person

1:1
Fully supported

Moskit 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)

maps to

Twenty CRM

Company

1:1
Fully supported

Moskit 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)

maps to

Twenty CRM

Opportunity

1:1
Fully supported

Moskit 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)

maps to

Twenty CRM

Task and Event

1:many
Fully supported

Moskit 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)

maps to

Twenty CRM

Custom Object (Project)

lossy
Fully supported

Moskit 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

maps to

Twenty CRM

Pipeline Stage

lossy
Fully supported

Moskit 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)

maps to

Twenty CRM

Workspace Member

1:1
Fully supported

Moskit 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

maps to

Twenty CRM

Custom Field

lossy
Fully supported

Moskit 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

maps to

Twenty CRM

Note on Person

lossy
Fully supported

Moskit'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

maps to

Twenty CRM

Custom Field + Inventory document

1:1
Fully supported

Moskit 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.

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.

Moskit logo

Moskit gotchas

High

No published API rate limit documentation

Medium

WhatsApp conversation sync is a linked feature, not standalone data

Medium

Deal-to-Project linkage must be explicitly preserved

Low

Custom field definitions vary by object and are not enumerated in bulk

Low

Brazilian Portuguese field labels may cause mapping mismatches

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

  • Twenty requires Cloud Pro tier for production REST API access

    Twenty's REST API is not publicly accessible without a bearer token. The Cloud Pro tier ($9/user/month) is required for API access on the cloud deployment. Self-hosted deployments provide API access without additional cost, but the team must provision a token from their self-hosted instance. We include a token validation check in our pre-migration setup; if the token cannot be generated or validated, we surface this before extraction begins. This gotcha is a scoping blocker that must be resolved before extraction starts.

  • Moskit has no published bulk export endpoint

    Moskit's public API uses paginated query endpoints per object type. There is no documented bulk export capability. We implement paginated extraction with cursor-based or offset-based pagination (depending on Moskit's API response shape), probe at conservative intervals, and back off exponentially on any 429 response. For migrations with over 100,000 records, this adds extraction time compared to platforms with a bulk export endpoint, and we account for it in the timeline estimate.

  • Twenty multi-select field migration requires field type confirmation

    A reported GitHub issue in the Twenty repository notes that updating multi-select fields can result in a 'Migration execution failed' error. Before importing records with multi-select picklists (mapped from Moskit multi-checkbox custom fields), we verify that the Twenty version deployed (cloud or self-hosted) supports the multi-select field type being used. If the issue is present, we fall back to a text field with comma-separated values or defer the multi-select field to a post-migration manual update batch.

  • Projects must be imported after Opportunities to preserve deal linkage

    Moskit Projects carry a reference to the originating Deal. In Twenty, we re-create Projects as a custom object with a custom Opportunity link field. We import Deals first, capture the new Twenty Opportunity UUIDs, then import Projects and remap the deal reference. If Projects are imported before Opportunities, the Opportunity link field will be null or will reference a non-existent record, breaking the relationship silently. We use a two-pass approach to resolve this: first pass extracts source deal IDs, second pass injects destination UUIDs into the Project records.

  • Moskit WhatsApp message content cannot be extracted from the API

    Moskit's WhatsApp Business integration stores conversation references and metadata but not message content. The actual messages remain in WhatsApp's infrastructure. We import conversation metadata (thread timestamp, participant, message count) as a Note on the Person record but do not extract message bodies. Customers who need full WhatsApp conversation history should run a separate WhatsApp data export and link it to the migrated Person records manually or via a post-migration integration.

Migration approach

Six steps for a successful Moskit to Twenty CRM data migration

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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.

  6. 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

Context on both ends of the pair

Moskit logo

Moskit

Source

Strengths

  • Native WhatsApp Business integration with automatic conversation sync
  • 5000+ integrations available via Zapier, Make, and Pluga
  • AI-powered Smart Fields that extract deal information automatically
  • Meeting recording and transcription linked directly to CRM records
  • Mass email campaigns with personalization at scale

Weaknesses

  • API documentation is not publicly rate-limited; migration tooling must probe and adapt dynamically
  • Limited public review corpus makes it hard to surface common migration pain points from user forums
  • No publicly documented bulk export endpoint; migrations rely on paginated API queries
  • Pricing is in Brazilian Real (R$) only, which may complicate international cost analysis
  • Project module is deal-centric; standalone project management without a deal link is not supported
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 Moskit 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

    Moskit: Not publicly documented.

  • Data volume sensitivity

    B

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

Estimator

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

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

Can't find your answer?

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 consultation

Migrations under 10,000 Contacts, 3,000 Deals, and no Projects typically complete in four to six weeks. Migrations with large activity histories (over 200,000 activity records), multiple Moskit pipelines, custom field schemas across all four object types, or Projects requiring deal-link remapping extend to ten to fourteen weeks. The most significant timeline driver is Moskit's paginated API extraction (no bulk endpoint) combined with the undocumented rate limit, which requires conservative request pacing.

Adjacent paths

Related migrations to explore

Ready when you are

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