CRM migration
Field-level mapping, validation, and rollback between Tofu and Twenty CRM. We move data and schema; workflows are rebuilt natively in Twenty CRM.
Tofu
Source
Twenty CRM
Destination
Compatibility
6 of 10
objects map 1:1 between Tofu and Twenty CRM.
Complexity
BStandard
Timeline
3-5 weeks
Overview
Moving from Tofu to Twenty CRM is a migration shaped by two constraints: Tofu has no published REST API, and its ABM-centric object model (Accounts, Playbooks, Personas, Audiences, Content Assets) requires deliberate reshaping to fit Twenty's generic CRM schema. We handle export through Tofu's native formats and CSV snapshots, map Tofu Accounts to Twenty Companies, decompose multi-step Playbooks into linear Step records with branching logic preserved as custom properties, and export Persona definitions as structured data attached to Person or Company records. Content Asset binaries require URL re-validation at export time because they live on Tofu's CDN. Twenty's open-source model means no per-seat license cost for self-hosting, but teams need Docker and a hosting provider. We do not migrate Playbook automation logic, ABM campaign targeting rules, or Content Asset binaries as code; these require rebuild in Twenty's workflow builder or manual re-upload post-migration.
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 Tofu 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.
Tofu
Account
Twenty CRM
Company
1:1Tofu Accounts (representing target companies in the ABM model) map directly to Twenty CRM Companies. We export Account name, industry, tier, owner, and any custom enrichment fields. Tofu's account domain or website field maps to Company.websiteUrl. The dedupe key is the account domain. Twenty's Company object requires manual creation of standard fields (industry, domain, address) that may not exist in a fresh Twenty workspace — we add these during schema setup before import. If the Tofu account is linked to a Persona, we attach the Persona data as a custom field on the Company record.
Tofu
Campaign
Twenty CRM
Task (Campaign tracking)
lossyTofu Campaigns (top-level containers for landing pages, email sequences, ads, and collateral) have no direct Twenty CRM equivalent since Twenty lacks native ABM campaign management. We map Campaign records to a custom Task or Note structure where each Campaign becomes a tracking record with Campaign name, status, start/end dates, and owner. Campaign-CampaignLineItem associations (the individual content pieces within a campaign) are stored as related Task records. For teams that need ongoing campaign tracking in Twenty, we recommend creating a Campaign custom object via Twenty's metadata API during schema setup.
Tofu
Playbook
Twenty CRM
Custom Object: Playbook_Step
lossyTofu Playbooks encode multi-step outreach sequences with conditional branching based on prospect engagement signals. Twenty CRM's workflow builder supports linear step sequences with conditions but not the multi-branch logic that Tofu Playbooks use. We decompose each Playbook into discrete Step records in a Playbook_Step custom object we create in Twenty, with fields for Step order, channel (email/call/ad), delay_days, condition_criteria, and the original branching logic stored as a JSON custom field. Any branching conditions that cannot be represented in Twenty's linear workflow model are flagged in the mapping notes for manual rebuild post-migration.
Tofu
Persona
Twenty CRM
Person (custom fields) + Company (custom fields)
1:manyTofu Personas define ICP profiles (industry, role, pain points, messaging tone) used to personalize content. We export persona definitions as structured records and map them to custom fields on Twenty's Person object (role, seniority, pain_points, messaging_tone) and to Company custom fields (target_industries, company_size) if the persona applies at the account level. The Persona-Account linkage migrates as a custom lookup relationship on the Company record. If Twenty lacks a native Person object, we create one via the metadata API before migration.
Tofu
Content Asset
Twenty CRM
Note + ContentDocument
1:1Tofu Content Assets (landing pages, one-pagers, PDFs, ad creative) are platform-hosted binaries on Tofu's CDN. We export asset metadata (asset name, type, version, linked Campaign ID, linked Account ID) and store it as a Note in Twenty CRM with a link to the original Tofu asset URL. We snapshot asset URLs at export time and re-validate each URL in a pre-flight check before the final sync run. Binary re-download and re-upload to Twenty's file storage is out of scope as a standard migration task; we provide a written list of asset URLs for the customer's admin to re-upload manually or via a separate file migration engagement.
Tofu
Audience
Twenty CRM
Person (filtered list)
1:1Tofu Audiences are filtered subsets of Accounts or Contacts used to trigger Playbook activation. We export audience membership as a list of Person records in Twenty with a custom field audience_name__c and the original filter criteria stored as a JSON custom field. The filter criteria themselves (e.g., industry equals SaaS and employee count greater than 50) are documented for manual reconfiguration in Twenty's filtering UI. If the Audience references Accounts, we resolve those to Companies first.
Tofu
Custom Properties (Accounts, Campaigns, Playbooks)
Twenty CRM
Custom Fields
lossyTofu supports custom fields on Accounts, Campaigns, and Playbooks. We detect all non-standard properties during the pre-migration schema scan using Tofu's export format. For each custom property, we create an equivalent custom field in Twenty via the metadata API before import. Field type mapping: text maps to Text, date maps to DateTime, number maps to Number, and checkbox maps to Boolean. Picklist-equivalent fields map to Twenty's select field type. Tofu custom properties that reference other Tofu objects map to lookup fields in Twenty after the referenced object is created.
Tofu
User / Owner
Twenty CRM
WorkspaceMember
1:1Tofu Users assigned as Campaign owners and Playbook creators map to Twenty WorkspaceMembers. We export user email addresses, names, and role assignments and create corresponding WorkspaceMembers in Twenty before any data import. If a matching WorkspaceMember does not exist in Twenty, we flag the user for the customer to provision. Owner references on Accounts and Playbooks are resolved at migration time by matching the email address.
Tofu
Engagement (calls, emails, meetings, tasks)
Twenty CRM
Task / Event
1:1If Tofu surfaces engagement data (calls, emails, meetings, tasks) as a record type accessible via export, we map these to Twenty Task records with channel type stored as a custom field. The original timestamp and owner map to ActivityDate and WorkspaceMember respectively. If Tofu's engagement data is not accessible via export (which is likely given the absence of a public API), we document the gap and recommend manual activity re-entry or a separate engagement capture step post-migration. Notes and attachments migrate as Twenty Note records linked to the parent Person or Company.
Tofu
Campaign Playbook associations
Twenty CRM
Playbook_Step custom object
1:1The relationship between a Tofu Campaign and its associated Playbooks is preserved as a lookup field on the Playbook_Step custom object (campaign_id__c). This allows the customer to understand which Playbook steps belong to which Campaign in Twenty's UI. If the customer used Tofu's Audience-Campaign-Persona segmentation model, we preserve the segment assignments as custom fields on Person records.
| Tofu | Twenty CRM | Compatibility | |
|---|---|---|---|
| Account | Company1:1 | Fully supported | |
| Campaign | Task (Campaign tracking)lossy | Fully supported | |
| Playbook | Custom Object: Playbook_Steplossy | Fully supported | |
| Persona | Person (custom fields) + Company (custom fields)1:many | Fully supported | |
| Content Asset | Note + ContentDocument1:1 | Fully supported | |
| Audience | Person (filtered list)1:1 | Fully supported | |
| Custom Properties (Accounts, Campaigns, Playbooks) | Custom Fieldslossy | Fully supported | |
| User / Owner | WorkspaceMember1:1 | Fully supported | |
| Engagement (calls, emails, meetings, tasks) | Task / Event1:1 | Fully supported | |
| Campaign Playbook associations | Playbook_Step custom object1: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.
Tofu gotchas
No public API documentation or published rate limits
Content Assets are platform-hosted binaries not separately exported
Playbook branching logic maps imperfectly to most destination CRMs
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
Discovery and export capability confirmation
We audit Tofu for all exportable objects: Accounts, Campaigns, Playbooks, Personas, Audiences, Content Asset metadata, Custom Properties, and Users. Since Tofu has no public API, we confirm which export formats are available in the account settings (bulk CSV, JSON, or webhooks) and whether the account supports full-history export or rolling-window export. We also confirm Content Asset CDN access and URL stability. This step produces a written migration scope confirming what data is migratable, what requires manual export, and what requires post-migration rebuild.
Twenty schema design and custom field creation
We set up Twenty's data model before importing any data. This includes creating the Person and Company custom fields that Tofu uses on Accounts and Personas (industry, tier, domain, target_industries, pain_points, messaging_tone, etc.), creating the Playbook_Step custom object via Twenty's /metadata API, adding all required fields with correct types, and creating any workspace-defined lookup relationships. We also invite all team members as WorkspaceMembers during this phase because Owner references on imported records require matching users to exist in Twenty first.
Data export from Tofu
We export all migratable objects from Tofu using the confirmed export formats. Exports run in dependency order: Users first (for owner resolution), then Accounts, Campaigns, Personas, Audiences, Playbooks (decomposed into Steps), and Content Asset metadata. Each export produces a structured CSV or JSON file with external IDs preserved for reconciliation. Content Asset CDN URLs are snapshotted at this point. We run a row-count reconciliation against the source data and flag any export gaps before proceeding.
Data transformation and field mapping
We apply the mapping logic: Tofu Accounts to Twenty Companies, Persona fields to Person and Company custom fields, Playbooks to Playbook_Step records with branching logic in JSON custom fields, and Audiences to Person records with audience_name__c. Custom Properties are mapped to the equivalent Twenty custom fields created during schema setup. Owner references are resolved by email against the Twenty WorkspaceMember table. Any Audience filter criteria are serialized to JSON for storage in a custom field on the Person record.
Staged import into Twenty
We import data into Twenty in dependency order: WorkspaceMembers first (validated), then Companies (Accounts), then Persons (with CompanyId resolved), then Playbook_Step records, then Task records for Campaign tracking. Each phase emits a row-count reconciliation report. Content Asset metadata is imported as Note records with the original Tofu CDN URL preserved. After import, we run a spot-check on 25-50 records per object type against the source Tofu export to verify field-level accuracy before the final cutover.
Cutover, validation, and Playbook rebuild handoff
We freeze writes in Tofu during cutover, run a final delta export of any records modified during the migration window, and import the delta into Twenty. We enable Twenty as the system of record and deliver the Playbook branching inventory document to the customer's admin, noting which conditions are linearized and which require manual rebuild in Twenty's workflow builder. We deliver the Content Asset URL inventory for manual re-upload and the Audience filter criteria for manual reconfiguration in Twenty's filtering UI. We support a one-week hypercare window for reconciliation issues. Workflow rebuild, sequence reconfiguration, and sales engagement tool setup are outside standard migration scope.
Platform deep dives
Tofu
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 Tofu 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
Tofu: Not publicly documented — typical SaaS limits assumed and confirmed during scoping.
Data volume sensitivity
Tofu 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 Tofu to Twenty CRM migration scoping. Not seeing yours? Book a call.
Walk through your Tofu 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 Tofu
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.