CRM migration

Migrate from Agillic to Twenty CRM

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

Agillic logo

Agillic

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

83%

10 of 12

objects map 1:1 between Agillic and Twenty CRM.

Complexity

BStandard

Timeline

4-6 weeks

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

Moving from Agillic to Twenty CRM is a structural migration from a Nordic omnichannel marketing automation platform to a modern open-source CRM. Agillic organises data around Recipients with fully custom schemas; Twenty CRM uses Contacts, Companies, and Opportunities with a defined field model. The primary migration challenge is schema enumeration — each Agillic client's recipient property set is unique, and we cannot begin mapping until every active property is captured via the Recipient API or Recipients Export. Activity records (sends, opens, clicks, SMS, events) carry a Flow Execution ID when enabled, which we preserve to allow matching activity records back to specific campaign runs. Agillic Flows (campaign automation) are not exportable as portable definitions; we document every Flow and deliver a written sequence plan for rebuilding in Twenty. We do not migrate Workflows or Forms as code — those require reimplementation in Twenty's interface after migration.

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

Agillic logo

Agillic

What's pushing teams away

  • Rate limits and API quotas are not publicly documented, creating uncertainty for teams planning large-scale data migrations or integrations.
  • The platform's heavy reliance on developer configuration for data synchronisation, custom flow elements, and content templates means marketing teams without technical support encounter bottlenecks.
  • Complex workflow logic built by developers becomes difficult for non-technical marketers to modify independently, limiting operational agility.
  • Exporting Activity data requires external analysis tools; Agillic itself lacks built-in advanced analytics dashboards for post-campaign insight generation.

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

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

Agillic

Recipient

maps to

Twenty CRM

Contact

1:1
Fully supported

Agillic Recipients map directly to Twenty CRM Contacts. The Recipient's email address is the primary dedupe key and maps to Contact.email. All standard recipient fields (first name, last name, phone, address) map to their Twenty CRM equivalents. Each client's custom recipient properties require enumeration before mapping — we extract the full property list via the Recipient API and create matching custom fields in Twenty CRM before import.

Agillic

Recipient

maps to

Twenty CRM

Person (in Company context)

1:1
Fully supported

Agillic Recipients linked to a company context map to a Twenty CRM Person record associated with a Company record. We resolve the company association by extracting any company identifier from the Recipient's custom properties or Global Data Table joins and linking to the Company record during import.

Agillic

Global Data Table

maps to

Twenty CRM

Custom Object

1:many
Fully supported

Agillic Global Data Tables are custom relational structures referenced within Flows. We export table schemas and all row data. Each table maps to a Twenty CRM Custom Object. Table rows import as Custom Object records with lookup relationships to the relevant Contact, Company, or Opportunity where the join logic is resolvable from the source data.

Agillic

Activity: Send

maps to

Twenty CRM

Task (type: email_sent)

1:1
Fully supported

Agillic Activity records of type send (email sends, SMS sends) map to Twenty CRM Tasks with the activity type recorded. The original send timestamp becomes the Task due date or activity date. The Flow Execution ID is preserved as a custom field for audit trail when enabled in Agillic's export settings.

Agillic

Activity: Open

maps to

Twenty CRM

Task (type: email_opened)

1:1
Fully supported

Agillic Activity records of type open map to Twenty CRM Activity timeline entries. The open timestamp preserves the engagement date. Multiple opens per email generate multiple activity entries, each with the original timestamp.

Agillic

Activity: Click

maps to

Twenty CRM

Task (type: email_clicked)

1:1
Fully supported

Agillic Activity records of type click map to Twenty CRM Activity timeline entries with the clicked URL preserved in a custom field if Twenty CRM supports it, or as a text note on the activity record. The click timestamp is preserved.

Agillic

Activity: Bounce

maps to

Twenty CRM

Task (type: email_bounced)

1:1
Fully supported

Agillic bounce Activity records map to Twenty CRM Activity timeline entries with bounce type (hard/soft) and bounce reason preserved. Bounce records flag the Contact's email validity and can trigger an email verification workflow in Twenty post-migration.

Agillic

Activity: SMS Delivery

maps to

Twenty CRM

Task (type: sms_sent)

1:1
Fully supported

Agillic SMS delivery Activity records map to Twenty CRM Tasks. Delivery status (delivered, failed, undelivered) migrates as a custom field or task status. SMS content migrates as a note attached to the activity record.

Agillic

Activity: Event

maps to

Twenty CRM

Task (type: custom_event)

1:1
Fully supported

Agillic custom event Activity records (triggered events, behavioural events, point-of-sale events) map to Twenty CRM Tasks with the event type preserved in a custom field and event metadata stored as a text note. We flag these for manual verification post-migration because event taxonomy varies per Agillic client configuration.

Agillic

Flow Execution History

maps to

Twenty CRM

Custom Field or Tag

1:1
Fully supported

The Flow Execution ID (when enabled in Agillic's Activity Export settings) is preserved as a custom field on the Activity record or as a Tag in Twenty CRM. This enables matching activity records back to specific campaign runs without native Flow integration in the destination platform.

Agillic

Profile

maps to

Twenty CRM

Contact (enriched)

1:1
Fully supported

Agillic Profiles aggregate all known data about a Recipient across touchpoints. We treat Profile data as equivalent to a Contact record enriched with attributes from Activity and Global Data Table joins. All enriched attributes map to Twenty CRM Contact custom fields.

Agillic

Audience Data (Google/Meta)

maps to

Twenty CRM

Segment or Tag

lossy
Mapping required

Agillic audience segments exported to Google and Meta are documented as Segment definitions. We capture the segment membership criteria and recreate them as Tags or Groups in Twenty CRM. The actual audience sync requires rebuilding in Twenty's integrations or a third-party sync tool post-migration.

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.

Agillic logo

Agillic gotchas

High

Undocumented API rate limits complicate bulk migration planning

High

Fully custom schema requires mandatory field enumeration during discovery

Medium

Flows are not exportable as portable workflow definitions

Medium

Activity Export requires explicit Flow Execution ID enablement

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

  • Custom recipient schema requires mandatory enumeration before any mapping

    Agillic allows clients to define arbitrary custom properties on Recipients with no fixed data model. Each client's schema is unique and there is no single documented list of all possible fields. We cannot begin field mapping until we enumerate every active recipient property via the Recipient API or Recipients Export. Missing fields during migration result in silent data loss for those attributes. We implement a mandatory schema discovery step at the start of every Agillic migration: we pull the complete recipient property list, present it to the customer for validation, create matching custom fields in Twenty CRM, and only then proceed to data extraction.

  • Flow Execution ID must be enabled before Activity Export

    The Flow Execution ID is not included in Activity Exports by default in Agillic — it must be explicitly enabled under Settings > System Settings > Export > Activity Exports. If this setting is off during the export period, we lose the ability to tie Activity records to specific campaign runs. We check this setting on both staging and production during discovery and request the client enables it before exporting historical data. Without the Flow Execution ID, journey reconstruction in Twenty CRM requires manual correlation which is impractical for large datasets.

  • File attachments do not migrate via Twenty CRM CSV import

    Twenty CRM's CSV import does not support file attachments. Any Attachments stored on Recipient records in Agillic (for example, signed consent forms, contract PDFs, or images referenced in Activity records) must be re-uploaded manually post-migration, migrated via the Twenty CRM API if available, or handled as a separate document migration task. We document every attachment identified during schema discovery and flag them for the customer's admin to handle manually or via a separate document migration engagement.

  • Agillic Flows are not exportable and require rebuild in Twenty Sequences

    Agillic Flows (campaign automation workflows) are stored as internal execution configurations with no documented export endpoint to retrieve flow logic as a portable file. We can export Flow names, associated trigger events, and Activity history tied to a Flow Execution ID, but the actual branching logic, conditions, and wait-step configurations must be manually recreated in Twenty CRM's Sequences. Twenty CRM Sequences are multi-step sales engagement cadences, which are a different model from Agillic Flows. We deliver a written Flow inventory document describing each Flow's trigger, conditions, and actions, and the customer's team rebuilds them as Twenty Sequences post-migration.

  • Undocumented API rate limits complicate bulk migration planning

    Agillic's REST API is rate limited per production instance per day, but specific thresholds are not publicly documented. During a large-volume migration, exceeding these limits returns 429 errors and stops accepting requests. We handle this by implementing exponential backoff, using WebDAV/SFTP Activity Export endpoints as a parallel ingestion path when API calls are throttled, and requesting Agillic support to confirm current rate limit values before scoping. The undocumented nature of these limits means we always add buffer time to migration timelines for potential throttling-related retries.

Migration approach

Six steps for a successful Agillic to Twenty CRM data migration

  1. Schema discovery and custom property enumeration

    We extract the complete Agillic recipient property list via the Recipient API and cross-reference it against a Recipients Export snapshot. We also enumerate Global Data Table schemas, Flow names, and Activity event types present in the client's instance. This discovery output is a complete entity-relationship diagram and field inventory that we present to the customer for validation. No mapping begins until the customer confirms the schema is complete because missing properties discovered mid-migration require rework.

  2. Twenty CRM schema design and custom field creation

    We design the destination Twenty CRM schema based on the discovered Agillic property list. This includes creating custom fields on Contact (and Company and Opportunity where applicable) to match every active Agillic recipient property. We also design the custom object schema for Global Data Table mappings. Twenty CRM's custom field creation is done via the UI or API before any data import. We document every Agillic Flow as a sequence handoff item for the customer's rebuild.

  3. Data extraction, cleansing, and validation

    We extract Recipients via the Agillic REST API and Recipients Export, Activity data via Activity Export (with Flow Execution ID confirmed enabled), and Global Data Table rows. We run data quality checks: duplicate detection on email address, missing required fields (first name, last name), invalid email formats, and orphaned Activity records (Activities with no valid Recipient reference). We present a data quality report to the customer and resolve cleansing decisions (duplicate merge, field backfill, record exclusion) before any load into Twenty CRM.

  4. Test migration and reconciliation

    We run a test migration into a Twenty CRM staging or development environment using production-like data volume. The customer reconciles record counts (Contacts in, Companies in, Activity entries in), spot-checks 20-30 random records against the Agillic source, and validates that custom fields populated correctly. We correct any mapping errors and validate the Activity timeline ordering before running the production migration. This step is critical for Agillic migrations because the custom schema is unique per client and mapping errors are common on first pass.

  5. Production migration in dependency order

    We run production migration in record-dependency order: Companies first (the foundation for Contact-to-Company relationships), then Contacts (with email dedupe key validated and custom fields populated), then Activity history (Tasks linked to Contact records by email match), then Global Data Table rows mapped to custom objects (last because they may have lookups to Contacts or Companies). Each phase emits a row-count reconciliation report before the next phase begins. We freeze Agillic writes during the cutover window.

  6. Cutover, validation, and Flow rebuild handoff

    We run a final delta migration of any records modified during the cutover window, then enable Twenty CRM as the system of record. We deliver the Flow inventory document describing each Agillic Flow's trigger, conditions, and actions with recommended Twenty Sequences equivalents. File attachment gaps are documented for manual re-upload. We support a one-week hypercare window to resolve reconciliation issues. We do not rebuild Agillic Flows as Twenty Sequences inside the migration scope; that is a separate engagement or an internal admin task.

Platform deep dives

Context on both ends of the pair

Agillic logo

Agillic

Source

Strengths

  • Fully customisable recipient schema with no fixed field constraints.
  • Native omnichannel support: email, SMS, push, print, paid media, and point-of-sale.
  • GDPR compliance built-in with annual independent security audits.
  • Staging and production separation for safe campaign testing.
  • Real-time audience activation to Google and Meta.

Weaknesses

  • API rate limits are not publicly documented, complicating migration planning.
  • Heavy developer dependency for data sync, custom flows, and content templates.
  • No built-in advanced analytics — requires external BI tools for activity analysis.
  • Workflows (Flows) are tightly coupled to Agillic's execution engine, making cross-platform migration requires reimplementation.
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 Agillic 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

    Agillic: Not publicly documented — limited per production instance per day.

  • Data volume sensitivity

    B

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

Estimator

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

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

Can't find your answer?

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

Book a free 30 minute consultation

Most migrations land between four and six weeks for straightforward cases under 10,000 Recipients with a clean custom schema (fewer than 30 recipient properties) and up to two years of Activity history. Migrations with large custom schemas (over 50 recipient properties), multiple Global Data Tables with complex join logic, or Activity histories spanning five or more years move to eight to twelve weeks because of schema discovery time, transform logic per custom property, and Activity timeline reconciliation. Agillic migrations require additional discovery time compared to standard CRM-to-CRM migrations because the custom schema is unique per client.

Adjacent paths

Related migrations to explore

Ready when you are

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