CRM migration

Migrate from Actito to Twenty CRM

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

Actito logo

Actito

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

45%

5 of 11

objects map 1:1 between Actito and Twenty CRM.

Complexity

BStandard

Timeline

2-3 weeks

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

Moving from Actito to Twenty CRM is a platform-type transition from marketing automation with a Profile-centric data model to a relational CRM with a Person-and-Company model. Actito's Profiles (with standard and custom attributes) map 1:1 to Twenty People, and Actito's Custom Tables map to Twenty Custom Objects with their relationship definitions preserved. Entity partitioning in Actito translates to workspace-filtered views in Twenty, and Profile-level subscription preferences migrate as structured opt-in fields on the People record. Multi-channel campaign configurations, push device tokens, and scenario automations do not migrate as functional code; we deliver a written inventory of every campaign and scenario requiring rebuild in Twenty's task-and-activity model. We use Actito's ETL export jobs to overcome the 100-calls-per-minute API rate limit and schedule bulk exports during off-peak hours to keep migration time within the agreed window.

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

Actito logo

Actito

What's pushing teams away

  • Segmentation builder is cumbersome — G2 reviewers consistently flag the segment-building interface as non-streamlined, with multi-step workflows that slow teams down compared to lighter-weight tools like Mailchimp or Brevo.
  • Steep learning curve for non-power users — multiple reviews note the platform is feature-dense and takes time to master, which becomes a problem for teams with high marketer turnover or those who only need surface-level functionality.
  • Pricing is sales-led with no transparent published tiers — buyers comparing Actito against Mailchimp, Brevo, or Customer.io often cite the demo-only pricing path and higher floor as friction during procurement.
  • Integration deployment time — connector configuration and rollout is reported as slow, which pushes teams toward platforms with larger pre-built integration marketplaces (HubSpot, Emarsys) when timelines are tight.
  • Complexity is overkill for small teams — startups and SMBs comparing Actito to Mailchimp or Brevo find the platform's customization depth and entity model unnecessary for simpler email and SMS use cases at a fraction of the cost.

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

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

Actito

Profile

maps to

Twenty CRM

Person

1:1
Fully supported

Actito Profiles map directly to Twenty People. Standard attributes (email, name, phone, address) migrate as typed fields. Custom profile attributes inspect their data type during scoping and map to Twenty's equivalent field type (text, number, date, boolean, or picklist). We preserve the Actito profile identifier in a custom field actito_profile_id__c for audit traceability.

Actito

Company

maps to

Twenty CRM

Company

1:1
Fully supported

Actito Companies (if the licence includes a company attribute on Profile) map to Twenty Companies. Domain becomes the Company website. Address attributes migrate to the Billing Address block. The Company record is created before any Person import so the companyId relationship resolves at insert time.

Actito

Custom Table

maps to

Twenty CRM

Custom Object

1:1
Fully supported

Actito Custom Tables connected to Profiles via relationships migrate to Twenty Custom Objects with equivalent field definitions. We inspect the table schema during scoping, map field types to Twenty equivalents, and recreate the lookup relationships as Twenty field references. Custom table naming convention follows Twenty's API naming rules during schema creation.

Actito

Entity

maps to

Twenty CRM

Workspace View

lossy
Fully supported

Actito Entities partition all resources (data structures, campaigns, scenarios) within a licence. Twenty has workspaces but no entity equivalent. We preserve entity names and scope assignments as workspace-filtered views or as a category field on the Person record, and deliver a written map of which entities map to which views for the customer's admin to configure post-migration.

Actito

Subscription and Preference

maps to

Twenty CRM

Person (structured fields)

lossy
Fully supported

Profile-level opt-in and preference data migrates as structured fields on the Twenty Person record. We create boolean fields for each active subscription channel (email_optin, sms_optin, push_optin) and a multi-select picklist for preference categories. Double opt-in status and consent timestamps migrate to dedicated date and boolean fields for GDPR audit readiness.

Actito

Campaign (multi-channel)

maps to

Twenty CRM

Opportunity

lossy
Fully supported

Actito campaign configurations (name, schedule, targeting criteria, channel assignment) do not have a direct functional equivalent in Twenty. We migrate campaign metadata as Opportunity records named after the Actito campaign, with channel type stored in a picklist field and targeting criteria preserved in a long-text notes field for the admin to reference when rebuilding campaign logic manually in Twenty's activity model.

Actito

Scenario (automated workflow)

maps to

Twenty CRM

Task List (written inventory)

lossy
Fully supported

Actito Scenarios are event-triggered automation workflows with multi-step branching, delays, and channel actions. Twenty has no native scenario or workflow engine. We map scenario logic (trigger conditions, branching rules, action steps) to a written task checklist that the customer's admin uses to recreate the automation logic in their chosen external tool or as a manual process. We do not migrate Scenarios as functional code.

Actito

Channel Configuration (Email, SMS)

maps to

Twenty CRM

Note attached to Person

lossy
Fully supported

Actito channel configurations (sender addresses, DKIM/SPF records, template references) are destination-specific and cannot be transferred. We migrate the template content as a Note attached to the Person record and flag DNS authentication records (DKIM public key, SPF TXT record) that must be reconfigured in the customer's email sending infrastructure before activation in Twenty.

Actito

Campaign Interaction Events

maps to

Twenty CRM

Activity Task

1:1
Not supported

Actito campaign interaction events (opens, clicks, bounces, unsubscribes) generated during campaign execution migrate as Twenty Activity records linked to the Person. The event type (email_open, email_click, sms_delivered, unsubscribe) maps to a Task or Note with a category field, preserving the timestamp and campaign reference. We note that historical reporting will reflect Twenty data only from the go-live date forward.

Actito

Export Definition

maps to

Twenty CRM

CSV Import Configuration

1:1
Fully supported

Actito Export API job definitions (file naming patterns, scheduling, compression type) map to Twenty CSV import configurations. We document the original export schedule and recreate the equivalent import configuration in Twenty's UI for any recurring imports the customer maintains.

Actito

Targeting Criteria

maps to

Twenty CRM

Filter (view-level)

lossy
Mapping required

Actito segment-building rules and Profile selection criteria migrate to Twenty view filters. Complex Actito-specific operators (such as 'is last month' or behavioural event windows) translate to Twenty filter expressions where equivalent operators exist. Operators without a Twenty equivalent are flagged in the mapping document for manual recreation.

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.

Actito logo

Actito gotchas

High

API rate limit of 100 req/min is restrictive for bulk migration

Medium

V4 deprecation overlap requires migration path sequencing

Medium

Push notification migration excludes campaign history

Medium

Maximum 5 API keys per licence constrains parallel migration workers

Low

Excel export row limitation conflicts with large dataset expectations

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

  • Actito API rate limit caps bulk export throughput

    Actito enforces 100 calls per minute and a maximum of 5 concurrent requests per licence during bulk data extraction. For migrations exceeding 50,000 Profiles or multiple Custom Tables, this rate cap significantly extends export time. We address this by routing volume exports through Actito's ETL job system with CSV and GZIP compression rather than looping API calls, scheduling large exports during off-peak hours, and requesting a temporary rate-limit increase through Actito support before migration begins. Without this approach, bulk migrations that rely on the standard API can run two to three times longer than estimated.

  • Twenty lacks an automation or scenario engine

    Actito's Scenario builder creates event-triggered workflows with branching logic, delay actions, and multi-channel outcomes. Twenty CRM has no native workflow, automation, or scenario engine; it is a CRM that manages People, Companies, Opportunities, and Activities without automated triggers. We do not migrate Scenarios as functional code. We deliver a written inventory of every Actito Scenario with its trigger, conditions, actions, and a recommended rebuild approach (manual task process or a third-party automation tool the customer adopts post-migration). Skipping this step leaves the customer's marketing automation logic un-documented in the cutover.

  • Actito campaign history requires manual archiving

    Actito campaign interaction events (opens, clicks, bounces, unsubscribes) are generated by Actito's platform and are available via the API for extraction. However, multi-channel campaign configuration metadata (sender addresses, template content, channel routing rules) is destination-specific and cannot transfer to Twenty's CRM model. We migrate interaction events as Activity records, but the customer must archive Actito campaign performance reports before cutover because those reports reference Actito attribution data that will not be available post-migration.

  • CSV import into Twenty enforces record dependency order

    Twenty's CSV import requires Companies to exist before People are imported so that the companyId reference resolves. Similarly, Custom Objects that have lookups to standard objects must import after the target standard record. We sequence the migration in dependency order: Companies first, People second, then Custom Objects, then Activities. Violating this order produces import errors and orphaned records (People without a linked Company). The Twenty documentation explicitly warns that soft-deleted records count toward uniqueness checks, which can cause silent restore-or-reject conflicts during re-import.

  • File attachments do not migrate via CSV

    Twenty's CSV import function does not include file attachments. Any document, PDF, or image attached to an Actito Profile or Custom Table record must be re-uploaded manually after migration, migrated via the Twenty API, or handled as a separate file transfer engagement. We flag every record with an attachment reference in the migration inventory so the customer's admin can address each one post-migration.

Migration approach

Six steps for a successful Actito to Twenty CRM data migration

  1. Discovery and scoping

    We audit the source Actito portal across licences, entities, Profile schemas (standard and custom attributes), Custom Table definitions and their relationship links, active Scenarios, campaign configurations, and subscription preference datasets. We pair this with a Twenty workspace review to identify which standard fields are available, which custom fields need to be created, and whether the destination workspace is self-hosted or cloud. The discovery output is a written migration scope with record counts per object, a preliminary field mapping matrix, and an identification of any Actito-specific features (push tokens, scenario automations) that fall outside the migration scope.

  2. Schema design and field mapping matrix

    We design the destination schema in Twenty. This includes creating custom fields for Actito custom profile attributes that have no standard Twenty equivalent, setting up Custom Objects for Actito Custom Tables with their field types and lookup relationships, configuring workspace-filtered views to replicate Actito entity partitions, and defining the subscription preference fields (emailOptIn, smsOptIn, pushOptIn, consentDate) on the Person record. The field mapping matrix is reviewed by the customer's admin before any data is extracted.

  3. ETL export jobs and API export setup

    We configure Actito ETL export jobs for volume data (Profiles, Custom Tables) using CSV with GZIP compression, which bypasses the 100-calls-per-minute API rate limit. For smaller datasets and delta exports, we use Actito's REST API with controlled polling intervals and batch sizes of 500 records per request. We request a temporary rate-limit increase from Actito support before the export phase begins. All exports are validated against the source record counts before proceeding to load.

  4. Sandbox migration and reconciliation

    We run a full migration into a Twenty test workspace using production-equivalent data volume. The customer's admin reviews record counts (Companies in, People in, Custom Objects in), spot-checks 25-50 records against the Actito source, and validates that relationship lookups (Person to Company, Custom Object to Person) resolve correctly. Any field mapping corrections, data quality issues, or missing custom field definitions are resolved in this phase before production migration begins.

  5. Production migration in dependency order

    We run production migration in record-dependency order: Companies first (the one side of relationships), People second with companyId resolved from the Company import, Custom Objects third (after their target standard records exist), Activities last (linked to the migrated Person and Company records). Each phase emits a row-count reconciliation report before the next phase begins. We flag any record that fails import validation with a reason code and resolve in a remediation pass before finalising.

  6. Cutover, validation, and automation handoff

    We freeze Actito writes during cutover, run a final delta migration of records modified during the migration window, then enable Twenty as the system of record. We deliver the Scenario inventory document, the campaign configuration map, and the targeting criteria translation guide to the customer's admin team for manual rebuild in Twenty. We support a one-week hypercare window where we resolve any reconciliation issues raised by the customer's team. We do not rebuild Actito Scenarios as automations inside the migration scope; that work requires a separate assessment of the customer's chosen automation tool post-migration.

Platform deep dives

Context on both ends of the pair

Actito logo

Actito

Source

Strengths

  • Customizable Profile data model allows direct mapping of existing schemas without flattening
  • Multi-channel activation across email, SMS, push, print, web, and call center from a single platform
  • Entity-based licence partitioning enables B2C/B2B co-existence without data cross-contamination
  • GDPR compliance and multi-language capabilities are built-in, not add-ons
  • API supports ETLs, webhooks, and bulk exports with configurable compression

Weaknesses

  • Segmentation builder interface is reported as cumbersome and non-streamlined by G2 users
  • Integration implementation time is slow; connectors take time to configure and deploy
  • API rate limits of 100 calls/min and 5 concurrent requests restrict bulk migration throughput
  • Push migration does not include campaign history, requiring manual record-keeping before cutover
  • Deprecated V4 API operations overlap with newer endpoints, requiring careful migration path planning
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 Actito 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

    Actito: 100 requests per minute per licence; 5 concurrent requests maximum; 5 API keys per licence.

  • Data volume sensitivity

    A

    Actito exposes a bulk API — large-volume migrations stream efficiently.

Estimator

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

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

Can't find your answer?

Walk through your Actito 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 10,000 Profiles and 3,000 Companies with no custom tables land between two and three weeks. Migrations with multiple custom tables, relationship hierarchies, large subscription preference datasets (over 50,000 records), or entity-partitioned data requiring view recreation move to five to eight weeks. The Actito API rate limit of 100 calls per minute extends export time for large datasets; we mitigate this by using ETL export jobs with CSV and GZIP compression rather than looping API calls.

Adjacent paths

Related migrations to explore

Ready when you are

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