CRM migration

Migrate from Getfly CRM to Twenty CRM

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

Getfly CRM logo

Getfly CRM

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

70%

7 of 10

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

Complexity

BStandard

Timeline

3-5 weeks

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

Moving from Getfly CRM to Twenty CRM is a structural migration that also represents a shift from a Vietnam-centric all-in-one CRM to a self-hosted, open-source platform with a modern data model. Getfly uses a unified Account object that combines organization and person records; Twenty separates these into Company and People objects, requiring a deliberate split design before migration begins. We discover Getfly's custom field schemas by sampling Product and Account records during export (supplemented by a customer-provided field audit), pre-create all fields in Twenty's Data Model before CSV import, and resolve owner references using email-based lookup. Workflow automations built inside Getfly do not export via API and must be rebuilt as Twenty workflows post-migration. PABX call recording URLs are time-limited signed links; we download recordings at export time and re-upload to Twenty to prevent broken links after cutover. Historical activities, pipeline stage configurations, and product catalogs migrate fully. Reports, dashboards, and automations are documented for manual rebuild in Twenty.

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

Getfly CRM logo

Getfly CRM

What's pushing teams away

  • Scaling businesses report that Getfly's feature set plateaus relative to their growth needs, particularly when comparing pipeline customization and advanced analytics to platforms like HubSpot or Pipedrive.
  • International expansion requirements create friction for companies outgrowing a Vietnam-centric CRM, as English-language documentation, multilingual support, and global compliance features are limited.
  • The platform's visual workflow builder lacks the expressiveness of competing tools, leading customers with complex automation requirements to seek alternatives where logic is easier to author and debug.

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

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

Getfly CRM

Account (Customer)

maps to

Twenty CRM

Company and People (split required)

1:many
Fully supported

Getfly Accounts combine organization-level fields (company name, address, phone) and person-level fields (contact name, email, title) in a single object. We split Getfly Accounts into Twenty's Company and People objects at migration time. The organization-level fields from Getfly populate the Twenty Company record; the person-level fields populate a linked People record. We create the Company first, then create the People record with a link to the Company via the personCompanyId field. A custom field original_getfly_account_id__c on both Company and People preserves the source record ID for reconciliation.

Getfly CRM

Product

maps to

Twenty CRM

Product (Custom Object)

1:1
Fully supported

Getfly Products with SKU, pricing, and custom fields migrate to Twenty's custom object capability. We create a Product custom object in Twenty's Settings → Data Model before import, defining fields that match the Getfly Product schema (name, price, sku, and any custom fields). Getfly's detail_custom_fields nested object is flattened into scalar columns. The CSV import creates records in the custom object; all field types (text, number, dropdown, date) are pre-defined to avoid import errors.

Getfly CRM

Pipeline Stage

maps to

Twenty CRM

Opportunity Stage

lossy
Fully supported

Getfly organizes Deals into configurable pipeline stages that are customer-specific. We extract the full stage configuration from Getfly (stage name, order, probability percentage) during export and map each stage to a Twenty Opportunity stage value. Twenty's opportunity model uses a simple stage field; we configure stage values in Twenty's settings to match the Getfly pipeline structure before importing Opportunities.

Getfly CRM

Deal

maps to

Twenty CRM

Opportunity

1:1
Fully supported

Getfly Deals map directly to Twenty Opportunities. We map the Getfly deal name to Opportunity name, deal amount to Opportunity amount, stage to the configured Opportunity stage, and pipeline assignment to a Twenty workspace pipeline identifier. Closed-Lost and Closed-Won reason fields from Getfly custom properties become Opportunity custom fields in Twenty.

Getfly CRM

Activity (Task/Call/Meeting)

maps to

Twenty CRM

Task

1:1
Fully supported

Getfly Activities (tasks, calls, meetings) map to Twenty Tasks. Activity type (task, call, meeting) is preserved in a custom Task field activity_type__c. Activity date and duration transfer directly. Owner assignment resolves via email-based lookup against the Twenty workspace user table. Activities linked to Getfly Accounts resolve to the corresponding Twenty Company and People records created during the Account split phase.

Getfly CRM

User (Owner)

maps to

Twenty CRM

User

1:1
Fully supported

Getfly Users acting as record owners are resolved by email match against Twenty workspace members. We export the full user roster during scoping and match against Twenty users before record import begins. Any Getfly owner without a matching Twenty user is placed in a reconciliation queue for the customer to provision before that phase of migration resumes. Active versus inactive status is preserved in a custom field original_getfly_owner_status__c.

Getfly CRM

Attachment

maps to

Twenty CRM

Attachment (Custom Object or Note)

1:1
Fully supported

Getfly attachments referenced by URL are downloaded to local storage during export and re-uploaded to Twenty. We use Twenty's attachment support to re-associate files with the correct Company, People, or Opportunity record. Original filename and URL reference are preserved in a custom field original_attachment_url__c for audit purposes.

Getfly CRM

Campaign

maps to

Twenty CRM

Task or Custom Object

1:1
Fully supported

Getfly marketing campaigns (name, start/end dates, linked accounts) migrate to Twenty as a custom Campaign object or as tagged Task records depending on the customer's intended use. Campaign membership (which Getfly Accounts were contacted) migrates as tagged Company records with a campaign identifier field. The customer chooses the campaign strategy during scoping.

Getfly CRM

Custom Field

maps to

Twenty CRM

Custom Field (on relevant object)

lossy
Fully supported

Getfly custom fields on Accounts and Products are discovered by sampling Product and Account records during export. Because Getfly has no public field schema registry endpoint, we supplement API sampling with a customer-completed field audit questionnaire run from Getfly's admin panel before migration kickoff. All confirmed custom fields are pre-created in Twenty's Settings → Data Model with type-compatible field definitions before any CSV import begins.

Getfly CRM

Workflow Automation

maps to

Twenty CRM

Workflow (manual rebuild required)

1:1
Fully supported

Getfly Workflow automations are stored as internal platform configuration with no public export endpoint. They do not migrate via API. We deliver a written inventory of every active Getfly Workflow with its trigger conditions, actions, and recommended Twenty workflow equivalent during the post-migration handoff. The customer's admin rebuilds automations in Twenty post-migration. This is documented scope, not migrated scope.

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.

Getfly CRM logo

Getfly CRM gotchas

High

Workflow automations are not exportable via API

Medium

API requires X-API-KEY with subdomain-scoped access

Medium

Custom field schemas vary per customer with no registry endpoint

Low

PABX call recordings are URL-referenced only

Low

No public pricing page requires direct sales inquiry

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

  • Getfly Accounts must split into Twenty Company and People objects

    Getfly's Account object conflates organization and person data in a single record, while Twenty uses separate Company and People objects with an explicit relational link. There is no automated split rule; we design the split during scoping by identifying which Getfly fields are organization-level (company name, address, industry) versus person-level (contact name, email, title). We create the Twenty Company first, then create a linked People record. Skipping this design step results in data being imported as a Company with a blank or incorrectly populated person record, breaking the activity timeline.

  • Twenty requires all fields to exist before CSV import

    Twenty's CSV import creates records but does not create fields. Getfly's custom field schemas vary per customer with no registry endpoint, meaning we discover custom fields by sampling Product and Account records during export, which may miss rarely-used fields. We mitigate this by instructing the customer to run a full field audit report from Getfly's admin panel before migration kickoff. All custom fields confirmed in the audit are pre-created in Twenty's Settings → Data Model with type-matched definitions before any CSV import begins. If a field is missed and the CSV references it, the import will reject those rows.

  • PABX call recordings are URL-referenced with time-limited links

    Getfly's integrated PABX returns call recording URLs rather than the audio file itself. These URLs may be signed or time-limited. We download all recordings at export time to local storage and re-upload to Twenty's attachment support. If the Getfly PABX is also being replaced at migration time, the recording URLs may expire before the migration completes, leaving orphaned links. We flag this as an explicit scoping decision: either renew the PABX subscription during migration or accept that call recording continuity depends on timely re-hosting.

  • Getfly API uses static X-API-KEY tied to subdomain with no OAuth

    Getfly's API authenticates via a static X-API-KEY header scoped to a customer's subdomain. There is no OAuth flow or per-user token rotation. Keys are issued per-org. If the key is rotated mid-migration, we must re-authenticate and resume from the last checkpoint. We request the API key during scoping and use it read-only where possible to minimize exposure. API rate limits are not publicly documented; we implement exponential backoff and chunking to avoid triggering undocumented limits.

  • Twenty workflows and views must be rebuilt manually post-migration

    Twenty's documentation explicitly states that views, workflows, and permissions must be recreated manually after migration. Getfly workflows do not export via API, and even if they did, they would not map to Twenty's workflow syntax. We deliver a written inventory of every active Getfly workflow with trigger, conditions, and actions during handoff, and the customer rebuilds these in Twenty. This is not a limitation of the migration—it is explicit scope that Twenty's own documentation acknowledges requires manual work.

Migration approach

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

  1. Discovery and field audit

    We audit the source Getfly account via API using the X-API-KEY: sampling Products, Accounts, Deals, and Activities to build an initial field schema. We request the API key during scoping. We supply a field audit questionnaire that the customer completes from Getfly's admin panel to capture any custom fields not visible in API sampling. We also document pipeline stage names, owner roster, and active workflow list during this phase. The discovery output is a written migration scope including the Account-to-Company/People split design and a custom field registry for Twenty pre-creation.

  2. Twenty workspace setup and schema pre-creation

    We create all required custom objects and custom fields in Twenty's Settings → Data Model before any CSV import begins. This includes the Product custom object (with fields matching Getfly Product schema), Opportunity stage values (matching Getfly pipeline stages), and any custom fields on Company and People objects. We invite all expected workspace users so that owner email lookups resolve during import. If the customer plans to self-host Twenty, we confirm the deployment is complete and accessible before proceeding.

  3. CSV export sequencing and data transformation

    We export Getfly data in dependency order: Products first (no dependencies), then Accounts (split to Company and People), then Deals (resolving Company and People IDs), then Activities (resolving owner email matches and parent record IDs). Each export produces a type-checked CSV. We transform Getfly date formats, phone number formats, and currency values to match Twenty's expected input. The Account split transform runs as a pre-processing step before CSV generation, generating two CSV files (Company and People) from the single Account export.

  4. Staged CSV import with reconciliation

    We run Twenty imports in dependency order matching the export sequence: Products, Companies, People, Opportunities, Tasks. Each phase emits a row-count and error-rate report. We reconcile row counts against the source Getfly export totals. Any rejected rows are diagnosed (missing required field, invalid field type, unknown picklist value) and corrected before the next phase. Owner email lookups that fail to match are held in a queue for the customer to provision those users in Twenty before resuming.

  5. Attachment and recording download and re-upload

    We download all Getfly-attached files and call recordings to local storage during the export phase. After the primary record migration is validated, we re-upload attachments to Twenty, associating each file with the correct Company, People, or Opportunity record. Recording URLs are validated before re-upload to confirm they have not expired; any expired URLs are flagged for the customer's attention with a note about the PABX subscription status.

  6. Cutover, delta sync, and workflow handoff

    We freeze Getfly writes during the cutover window, run a final delta export of any records modified since the initial export, apply the delta to Twenty, and confirm record counts match. We deliver the workflow automation inventory document to the customer's admin team. We support a one-week hypercare window for reconciliation issues raised by the team. Workflows, automations, and views are documented for manual rebuild in Twenty; this is scope outside the data migration and is not handled as an automated transfer.

Platform deep dives

Context on both ends of the pair

Getfly CRM logo

Getfly CRM

Source

Strengths

  • 14 years of continuous operation with 6000+ SME customers validates long-term viability in the Vietnam market.
  • Mobile-first architecture with full feature parity between web and native apps suits distributed sales teams.
  • Subscription-based pricing with a 30-day free trial provides predictable cost planning and low-risk evaluation.
  • Integrated calling (PABX), KPI tracking, and marketing automation reduce the need for multiple separate tools.
  • Customer-specific subdomain architecture allows white-label deployments for resellers.

Weaknesses

  • Limited documented presence in English-language review ecosystems makes independent quality assessment difficult for international buyers.
  • API rate limits and bulk export capabilities are not publicly documented, requiring direct inquiry to Getfly engineering.
  • No evidence of third-party security certifications (SOC 2, ISO 27001), which may block enterprises with strict compliance requirements.
  • The platform's feature set is anchored to Vietnamese SME workflows and may not map cleanly to international business processes.
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. 2 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 Getfly CRM and Twenty CRM.

  • Object compatibility

    B

    2 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

    Getfly CRM: Not publicly documented — direct inquiry to Getfly engineering required.

  • Data volume sensitivity

    B

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

Estimator

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

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

Can't find your answer?

Walk through your Getfly CRM to Twenty CRM migration with a real engineer — 30 minutes, free, written quote within 24 hours.

Book a free 30 minute consultation

Most Getfly to Twenty migrations land between three and five weeks for accounts under 10,000 Accounts, 2,000 Products, and straightforward pipeline structures. Migrations with large product catalogs, extensive custom field schemas, high-volume activity histories (over 200,000 records), or multiple Getfly pipeline configurations requiring distinct Twenty opportunity setups move to six to nine weeks because of schema pre-creation, the Account-to-Company/People split design, and CSV field matching work.

Adjacent paths

Related migrations to explore

Ready when you are

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