CRM migration

Migrate from Kinabase to Twenty CRM

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

Kinabase logo

Kinabase

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

83%

10 of 12

objects map 1:1 between Kinabase and Twenty CRM.

Complexity

BStandard

Timeline

2-4 weeks

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

Kinabase stores data as a flat, user-defined Collection-and-Record model where each Collection is its own entity type with typed Fields and cross-collection references. Twenty CRM uses a conventional CRM object model (People/Contacts, Companies, Opportunities, Tasks, Notes) with a REST API built in TypeScript/Next.js. These architectural differences make the migration structural: every Kinabase Collection must be classified as a standard Twenty CRM object or a custom object, and every Field must be mapped to a typed field or flagged for post-migration rebuild. We export via Kinabase's admin CSV panel or Bearer-token API (100 req/min), resolve linked-collection references in dependency order, evaluate Computed Fields to static values before writing, and deliver a written workflow and automation inventory for the customer's admin to rebuild in Twenty. We do not migrate Views, Filters, or integration configurations (Microsoft 365, Entra ID SSO).

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

Kinabase logo

Kinabase

What's pushing teams away

  • API access is not self-service — Kinabase requires contacting [email protected] to obtain credentials, which adds friction for teams wanting programmatic access or automated migration pipelines.
  • No public pricing — the absence of published tier information makes it difficult to compare cost against alternatives and creates procurement friction, especially for larger teams.
  • Limited ecosystem and community — with no dedicated public forum or large third-party app marketplace, teams cannot easily find plugins, consultants, or peer support when the platform hits its limits.
  • Bulk data operations are slow under the 100 req/min rate limit — exporting or loading large record sets through the API requires throttling logic and pagination handling that adds migration complexity.
  • Workflow automation capabilities may be gated by subscription tier — some advanced automation features referenced in the platform may not be available on lower plans, creating feature surprises during licensing reviews.

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

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

Kinabase

Collection (generic CRM type)

maps to

Twenty CRM

Contact or Company

1:1
Fully supported

A Kinabase Collection whose Fields map to standard contact attributes (name, email, phone, address) maps to Twenty CRM's Person object (API name Person). Collections with company-level attributes (legal name, domain, industry, employee count) map to Twenty CRM's Company. We classify each Collection during the pre-migration field audit and assign a mapping type before any export begins.

Kinabase

Collection (project or deal type)

maps to

Twenty CRM

Opportunity

1:1
Fully supported

Kinabase Collections representing deals, projects, or engagements map to Twenty CRM Opportunity. Stage Fields in the Collection map to the Opportunity stageName field. Amount Fields map to amount, and owner assignment maps to the User resolved from the Collection's assigned-user field.

Kinabase

Collection (custom entity)

maps to

Twenty CRM

Custom Object

1:1
Fully supported

Any Kinabase Collection that does not fit a standard Twenty CRM object maps to a Twenty custom object. We pre-create the custom object schema via the /metadata API (Twenty v0.26+) before migration, including all custom Fields typed as text, number, date, boolean, or relation. Each custom Field gets a unique name matching the source Collection Field with an underscore suffix if a naming conflict exists.

Kinabase

Record

maps to

Twenty CRM

Contact, Company, Opportunity, or Custom Object record

1:1
Fully supported

Individual Kinabase Records migrate as rows in the corresponding Twenty CRM object. We map field values by type: text fields to text, numbers to number, dates to date, and dropdown selections to Twenty's select or multiselect type. Null values and empty strings are handled explicitly to avoid unexpected required-field failures on insert.

Kinabase

Linked Collection Field (cross-collection reference)

maps to

Twenty CRM

Relation field or lookup field

1:1
Fully supported

A Kinabase linked-collection field (e.g., a 'Client' field in a 'Projects' Collection pointing to a 'Clients' Collection record) creates a foreign-key dependency. We export linked Collections in dependency order: parent Collections first, then child Collections. The foreign key value is written as a relation ID in Twenty's custom object relation field. If the target Twenty custom object does not yet exist, the reference is stored as a text field (original_record_id__c) and resolved during a second pass after the parent object is created.

Kinabase

Computed Field

maps to

Twenty CRM

Static text or number field

lossy
Fully supported

Kinabase Computed Fields evaluate a formula expression at display time; the formula itself is not stored data. We evaluate each formula at migration time using the stored operand values and write the resulting scalar value as a static text or number field in Twenty CRM. The formula is not preserved. We flag every Computed Field in the pre-migration audit with a note that the result value transfers but the expression does not.

Kinabase

Activities (email, call, meeting logged as sub-Records)

maps to

Twenty CRM

Task, Note, or TimelineEntry

1:1
Fully supported

Kinabase activity records stored as sub-Records or typed Fields in a Collection (e.g., a 'Interactions' linked Collection or timestamp Fields) map to Twenty CRM Task or Note. Call duration maps to a custom duration field, meeting location maps to a note body, and timestamps are preserved as the ActivityDate on the target Twenty record.

Kinabase

Task (standalone work item)

maps to

Twenty CRM

Task

1:1
Fully supported

Kinabase standalone Tasks map directly to Twenty CRM Task. We preserve assignee, due date, status (open, completed), and any linked-record reference via the Relation field. Task body or description maps to the note field on Twenty Task.

Kinabase

Document (file attachment)

maps to

Twenty CRM

Attachment reference or Note with URL

1:1
Fully supported

File attachments linked to Kinabase Records are exported as filename and reference URL only. Twenty CRM does not include file attachments in CSV imports — they must be re-uploaded manually, migrated via API, or handled through a partner-assisted migration. We export the file association as a text field pointing to the original URL or filename for the customer's admin to re-attach post-migration.

Kinabase

Stage (pipeline status Field)

maps to

Twenty CRM

stageName on Opportunity or status on Custom Object

lossy
Fully supported

Kinabase stage Fields (Draft, In Progress, Approved, Closed) are categorical values. We map them to Twenty's stageName picklist on Opportunity for deal-type Collections, or to a custom status select field on custom objects for non-deal Collections. The stage values are preserved verbatim; the visual pipeline representation does not transfer.

Kinabase

Owner (user assignment)

maps to

Twenty CRM

User

1:1
Fully supported

Kinabase owner fields reference a user in the platform. We match by email against the Twenty CRM workspace User list. Any Kinabase Owner without a matching Twenty User is held in a reconciliation queue for the customer's admin to provision before the record import phase. If a Twenty workspace is self-hosted and has no Users yet, we advise provisioning at least one admin User before migration begins.

Kinabase

Workflow, automation, trigger rule

maps to

Twenty CRM

Written inventory (no automation migration)

1:1
Fully supported

Kinabase Workflows define stage progression, trigger-based rules, and scheduled actions. Twenty CRM does not replicate Kinabase's workflow engine. We capture the full workflow definition — triggers, conditions, actions, and stage maps — as a structured JSON inventory document and deliver it to the customer's admin for rebuild as a documented reference. Automated actions, notifications, and approval gates are not migrated.

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.

Kinabase logo

Kinabase gotchas

High

API access gated behind a support request

Medium

100 req/min rate limit slows large exports

Medium

Computed Field values are not stored data

Medium

Linked collection fields require relationship re-establishment

Low

Only administrators can export all data

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 CRM does not include file attachments in CSV imports

    File attachments associated with Kinabase Records (documents, images, uploaded files) are exported as filename and reference URL only. Twenty CRM's CSV import path does not transfer file bodies. Customers must re-upload attachments manually after migration, use the Twenty API to migrate files programmatically, or engage a partner for file migration assistance. We flag every Record with file attachments in the pre-migration audit and include a separate file-attachment inventory in the migration handoff package.

  • Self-hosted Twenty version updates can blank the workspace

    GitHub issue #14705 on the twentyhq/twenty repository documents that updating a self-hosted instance across minor versions (e.g., 1.3.0 to 1.6.7) can render the workspace largely blank — the CRM appears empty until migrations are re-run. Teams running self-hosted Twenty should snapshot their database before any version update, and migration should target a known-stable version or a fresh staging workspace. We do not execute version upgrades; we work against the running workspace the customer provides.

  • Kinabase API access requires a support request before any migration begins

    Kinabase does not offer a self-service developer portal. Teams must email [email protected] to obtain Bearer token credentials. This adds days to weeks of latency before we can begin API-based export. We initiate the credential request at project kickoff and use the admin CSV export as a fallback data source if credentials are delayed. Projects that do not have an active Kinabase admin contact or cannot reach support risk a stalled export phase.

  • Linked-collection dependency chains must be resolved before insert

    Kinabase linked-collection Fields create cross-Collection foreign-key references that Twenty CRM cannot satisfy at insert time if the referenced record does not yet exist. We export Collections in topological dependency order (parents first) and perform a two-pass approach for complex chains: parent Collections load completely, child Collections with resolved parent references load second, and orphaned references (deleted source records with no valid foreign key) are written to a reconciliation report for the customer's admin to resolve manually.

  • Computed Field formulas do not survive migration

    Kinabase Computed Fields are expressions evaluated at display time — the formula definition is not a stored data value. When migrating to Twenty CRM, which has no native computed-field equivalent, we evaluate each formula using the operand values present at migration time and write the resulting scalar to a static field. The formula is discarded. Any downstream calculation in Twenty must be rebuilt as a custom field expression or a reporting-level calculation by the customer's admin.

Migration approach

Six steps for a successful Kinabase to Twenty CRM data migration

  1. Discovery and Kinabase credential procurement

    We audit every Kinabase Collection in the workspace: record counts, Field types (text, number, date, dropdown, computed, linked collection), and any Workflow definitions. We simultaneously initiate the Kinabase API credential request by emailing [email protected] with the workspace domain and required access scope. If API access is delayed beyond five business days, we confirm admin CSV export is available as the fallback data source. The discovery output is a written Collection inventory with a preliminary object classification (Contact, Company, Opportunity, or custom object) for each Collection.

  2. Twenty CRM schema provisioning

    We verify the Twenty CRM workspace is running a version that supports custom objects (v0.26+). For each Collection classified as custom object, we call the /metadata API to create the object schema with all Fields typed to match Kinabase's field types. We create relation fields for any linked-collection reference and configure the dropdown picklist values for stage and status Fields to match the Kinabase source values. Schema is deployed to a staging workspace first for validation.

  3. Data export in dependency order

    We export Kinabase Collections in topological dependency order: Collections with no linked-collection inbound references export first, then Collections whose linked-collection references point only to already-exported Collections. Each Collection is exported as a separate CSV via the admin panel or paginated API calls (100 req/min rate limit enforced with backoff). Computed Field formulas are evaluated at export time and their resulting values appended as static columns. The export phase emits a per-Collection row count and field count report.

  4. Transformation and field mapping

    We transform each exported CSV against the Twenty CRM target schema: field names are mapped, field types are converted (Kinabase dropdown to Twenty select, Kinabase date strings to ISO-8601 timestamps), linked-collection IDs are resolved to Twenty record IDs from the staging load, and Computed Field result values are written to their designated static fields. Any field that cannot be represented 1:1 in Twenty is flagged in the mapping matrix with a recommendation (custom field, text denormalisation, or skip). Multi-select dropdown values are flattened to Twenty's multiselect format.

  5. Staging migration and reconciliation

    We load the transformed data into a Twenty CRM staging workspace using CSV import or API upsert calls. The customer reconciles record counts, spot-checks 25-50 records against the Kinabase source, and validates that linked-collection relationships appear correctly as relation fields. Any mapping corrections are documented and applied to the production transform before the next phase. The staging phase must complete with sign-off before production migration begins.

  6. Production migration and cutover

    We run production migration in dependency order: standard CRM objects (People/Contacts, Companies, Opportunities) first, then custom objects, then activity and task history. Linked-collection references are resolved against the staging ID map. We freeze writes in Kinabase during the cutover window, run a final delta export of any records modified during migration, and close out the import. We deliver the Workflow inventory document, the file-attachment reconciliation report, and a post-migration validation checklist to the customer's admin. We do not rebuild Kinabase Workflows or automations in Twenty CRM as part of standard scope.

Platform deep dives

Context on both ends of the pair

Kinabase logo

Kinabase

Source

Strengths

  • Highly customisable data model with no fixed object schema
  • Workflow builder with stage progression, triggers, and role-based permissions
  • CSV export by administrators covers all Collections without contacting support
  • Native Microsoft 365 integration (Outlook, SharePoint, Entra ID SSO)
  • Flexible pricing model — starts simple and scales with added features

Weaknesses

  • API access requires a support request, not self-service provisioning
  • Rate limit of 100 requests per minute makes large exports time-consuming
  • No public pricing tiers — procurement and budget forecasting require a sales conversation
  • Limited ecosystem, community, and third-party app support
  • Custom schema means every migration requires field-level mapping rather than a standard object import
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 Kinabase 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

    Kinabase: 100 requests per minute.

  • Data volume sensitivity

    B

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

Estimator

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

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

Can't find your answer?

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

Book a free 30 minute consultation

Small migrations under 5,000 total records across fewer than eight Collections with no complex linked-collection chains typically complete in two to four weeks. Mid-size migrations with fifteen or more Collections, multiple dependency chains, and Computed Field evaluation across large record sets move to five to nine weeks because of schema design, dependency mapping, and staging validation time. The Kinabase API credential procurement window can add three to ten business days to the project timeline before export begins.

Adjacent paths

Related migrations to explore

Ready when you are

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