CRM migration

Migrate from Spark CRM to Twenty CRM

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

Spark CRM logo

Spark CRM

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

100%

12 of 12

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

Complexity

BStandard

Timeline

48–72 hours

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

Spark CRM is an email-first contact management tool that stores contacts, companies, deals, and activities primarily around email engagement data. Twenty CRM is an open-source relational CRM built on TypeScript and PostgreSQL with a standardized People-Companies-Opportunities object model, REST and GraphQL API access at 100–200 requests per minute, and custom object support via its Metadata API. We map Spark contacts to Twenty's People object (resolving the company link via companyId), Spark companies to Twenty's Companies object, and Spark deals to Twenty's Opportunities object with stage value mapping. Spark's owner field resolves to Twenty's WorkspaceMember records by email match. Spark custom fields migrate as custom fields in Twenty, created via the Metadata API before data lands. Spark notes become Twenty notes with original timestamps. Spark tasks migrate as Twenty tasks linked to their parent records. Workflows, email sequences, and automation logic do not transfer — we export the definitions as a rebuild reference for Twenty's workflow builder. The migration runs via Twenty's REST API with batch processing to stay within rate limits, followed by a delta pickup window to capture any in-flight changes during cutover. File attachments in Spark require separate handling since CSV exports do not include binary files.

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

Spark CRM logo

Spark CRM

What's pushing teams away

  • Limited independent customer review footprint — vendor relies on self-published claims (e.g., 'instantly boost ROI by 87%') rather than third-party validation.
  • Pricing transparency is partial — Business plan at $199/month plus 1.5% platform fees published, but other tiers/limits are not fully disclosed, surprising operators as transaction volume scales.
  • Confusion with the unrelated Spark CRM real-estate product (spark.re) and other 'Spark' branded CRM platforms creates procurement friction.
  • No specific implementation timeline or support structure published, making delivery risk hard to scope for buyers.
  • Payment-orchestration-first positioning may not suit teams seeking a general-purpose CRM, since the value prop is tightly tied to transaction approval rates.

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

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

Spark CRM

Contact

maps to

Twenty CRM

People

1:1
Fully supported

Spark contacts map 1:1 to Twenty's People object. The contact's name, email, phone, job title, and custom properties migrate directly. The company association requires a companyId lookup — Spark contacts without a linked company land in Twenty with no companyId and can be linked manually or via a post-migration script.

Spark CRM

Company

maps to

Twenty CRM

Companies

1:1
Fully supported

Spark companies map to Twenty's Companies object. Company name, domain/website, industry, employee count, and annual revenue migrate directly. Spark company hierarchies (parent/child) map to Twenty's Parent CompanyId field if present. Multi-company associations on a single contact collapse to one primary companyId in Twenty — the most recently modified or primary-flagged company becomes the linked record.

Spark CRM

Deal

maps to

Twenty CRM

Opportunities

1:1
Fully supported

Spark deals map to Twenty's Opportunities object. Deal name becomes the Opportunity name, deal amount maps to amount, and close date maps to closeDate. Spark deal stage names require value mapping to Twenty's opportunity stage pick-list — we capture the mapping in the migration plan before data lands. Deals without a linked company or contact attach to the Opportunity record without a foreign key; post-migration linking is available.

Spark CRM

Note

maps to

Twenty CRM

Note

1:1
Fully supported

Spark notes migrate as Twenty notes. The note body maps to the Body field, and original create/update timestamps are preserved as custom datetime fields (CreatedAt__c and UpdatedAt__c) since Twenty's native timestamp reflects migration time. Notes linked to contacts or companies retain their parent record association via the Note's relationId field.

Spark CRM

Task

maps to

Twenty CRM

Task

1:1
Fully supported

Spark tasks migrate as Twenty tasks. Task title becomes the Subject field, due date maps to dueDate, and completion status maps to status (completed/incomplete). Assigned owner resolves to a Twenty WorkspaceMember by email match. Tasks linked to contacts, companies, or deals carry their relationId forward so the task appears on the correct record in Twenty.

Spark CRM

Owner

maps to

Twenty CRM

WorkspaceMember

1:1
Fully supported

Spark's owner field (user/rep assigned to a contact, company, or deal) resolves to Twenty WorkspaceMembers by email address. Unmatched owners are flagged before migration — your team either creates the Twenty user first or assigns records to a default owner. This step runs before any data migration so every record lands with a valid owner reference.

Spark CRM

Custom Field (on Contact)

maps to

Twenty CRM

Custom Field (on People)

1:1
Fully supported

Spark custom fields on contacts require Twenty custom field creation via the Metadata API before migration begins. We create the field in Twenty matching the Spark field type (text, number, date, picklist) and then migrate values row-by-row. Picklist fields in Spark require value-by-value mapping to Twenty's select field options — we document this mapping in the pre-migration plan.

Spark CRM

Custom Field (on Deal)

maps to

Twenty CRM

Custom Field (on Opportunity)

1:1
Fully supported

Spark custom fields on deals migrate as Twenty custom fields on Opportunities. The same Metadata API field creation process applies. For numeric custom fields (deal score, probability override), we preserve the raw value as a Twenty number field. Date custom fields map to Twenty date fields with original dates intact.

Spark CRM

Tag

maps to

Twenty CRM

Custom Multi-Select Field

1:1
Fully supported

Spark's tag field (contact tags, company tags) requires transformation into Twenty's multi-select field type. We create a custom multi-select field called Tags__c on the People or Companies object and populate it with Spark's comma-separated tag values. If Spark has multiple tag fields, each becomes a separate multi-select field in Twenty.

Spark CRM

Attachment/File

maps to

Twenty CRM

Manual Re-Upload Required

1:1
Fully supported

Spark file attachments are not included in CSV exports and cannot be migrated programmatically via Twenty's current import API. We document the attachment list (record + filename) in a reference CSV so your team can manually re-upload files to the correct Twenty records, or use Twenty's API to upload files post-migration if the attachment volume is manageable.

Spark CRM

Pipeline / Deal Stage

maps to

Twenty CRM

Opportunity Stage

1:1
Fully supported

Spark deal stages map to Twenty's opportunity stage pick-list via value-by-value mapping. We capture every unique Spark stage name, map it to a Twenty stage with matching semantics (e.g., 'Closed Won' → 'Won'), and apply the mapping during the Opportunity migration. Stage order and probability mapping are documented for your Twenty admin to configure post-migration.

Spark CRM

Activity History (calls, emails, meetings)

maps to

Twenty CRM

Tasks and Notes

1:1
Fully supported

Spark's activity history (logged calls, emails, meetings) migrates as a combination of Twenty tasks and notes. Call logs become tasks with Type='Call' and the call outcome in the task body. Email subjects become task subjects. Meeting records become tasks with a note attachment containing meeting details. Original activity timestamps are preserved in custom datetime fields.

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.

Spark CRM logo

Spark CRM gotchas

High

Multiple unrelated 'Spark CRM' products exist

High

Platform fee on top of monthly subscription affects long-term TCO

High

Payment-orchestration data is tightly coupled to Spark's runtime

Medium

Limited public review footprint for due diligence

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 CSV import enforces strict load order — Companies must land before People

    Twenty's import mechanism validates foreign keys at upload time: a People record with a companyId reference fails if the target Companies record does not already exist in Twenty. This means the migration must sequence as Companies → People → Opportunities — a constraint that compounds with data volume. Spark contacts linked to non-existent or deleted Spark companies require either creating placeholder company records in Twenty or migrating without the company link and linking manually post-migration. We document all orphan contacts (contacts with stale or deleted company references) before the migration run so you can decide how to handle them.

  • Spark file attachments do not export via CSV — manual re-upload required

    Twenty's CSV import does not support binary file imports, and Spark's CSV export does not include attachment blobs. Any files attached to Spark contacts, companies, or deals must be re-uploaded manually to Twenty after migration or uploaded programmatically via Twenty's API post-migration. For large attachment volumes, we generate a reference CSV listing each record's attachment filenames and sizes so your team can prioritize re-uploads. This is a data reference gap, not a data loss — the attachments still exist in Spark and can be downloaded before account deprecation.

  • Twenty's API rate limits cap batch migration throughput at 100–200 requests/minute

    Twenty's free cloud tier limits API calls to 100 per minute; the paid Organization tier raises this to 200 per minute. For migrations exceeding 10,000 records with custom field writes, this rate limit extends migration wall-clock time significantly. We implement exponential backoff with jitter to respect rate limit headers (X-RateLimit-Remaining, X-RateLimit-Reset) returned by Twenty's API, and we batch records into chunks of 50–100 to minimize per-record API call overhead. Migrations approaching the 20,000-record CSV import limit should use Twenty's native CSV import UI for the bulk load and reserve the API for custom field population and delta updates.

  • Spark workflow definitions and email sequences have no migration path to Twenty

    Spark's workflow automation rules and email sequence definitions are not exportable in a format that Twenty's workflow builder can consume. Twenty's workflow system uses a different trigger-action model (event-driven with conditions and background jobs) that requires manual rebuild. We export Spark workflow definitions as a structured reference document — your Twenty admin or implementation partner uses this to recreate the logic in Twenty's workflow builder. The data (contacts, companies, deals, activity history) that would have triggered those workflows is fully migrated, so the workflow rebuild starts with a complete dataset.

  • Spark tags collapse into a single multi-select field in Twenty — not a native tag object

    Twenty does not have a native tag object equivalent to Spark's flexible tagging model. Spark contacts and companies can have multiple independent tag fields (e.g., 'Segment', 'Source', 'Priority'). In Twenty, we create a single multi-select custom field per Spark tag dimension. If Spark uses more than five distinct tag fields on a single object, the migration plan flags this and your admin chooses whether to create all of them as separate custom multi-select fields or consolidate related tags into fewer fields to avoid field sprawl on the Twenty record layout.

Migration approach

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

  1. Audit Spark data and map to Twenty schema

    FlitStack AI connects to Spark via scoped read access to enumerate all contacts, companies, deals, activities, custom fields, and tags. We generate a data inventory report: record counts per object, custom field names and types, unique deal stage values, unique owner email addresses, and attachment counts. We then map every Spark object and field to its Twenty equivalent using the mapping tables above and flag any objects that cannot migrate automatically (attachments, workflows). This audit output becomes the migration plan reviewed by your team before any data moves.

  2. Create Twenty schema for custom fields and custom objects

    Before data can land, FlitStack AI creates the custom fields and custom objects in Twenty via the Metadata API. This includes custom fields for Spark properties that have no direct Twenty equivalent (tags as multi-select, original timestamps as datetime fields, source system IDs for traceability). We also create any custom objects in Twenty that mirror Spark custom objects, using the relationship model Twenty supports (one-to-many via foreign key, many-to-many via junction object). This step runs first so that the field definitions exist when data validation begins.

  3. Resolve Spark owners to Twenty WorkspaceMembers by email

    FlitStack AI extracts every unique owner email address from Spark contacts, companies, and deals and matches them against existing Twenty WorkspaceMember records by email. Unmatched owners are flagged with a list of Spark records assigned to them. Your team either creates the missing Twenty users before migration or designates a fallback owner. No record migrates without a valid Twenty WorkspaceMember reference — this prevents orphaned records that show no owner in Twenty's UI.

  4. Migrate Companies, then People, then Opportunities in correct load order

    FlitStack AI sequences the migration respecting Twenty's foreign-key constraints: Companies (the 'one' side of the relationship) migrate first via Twenty's REST API or CSV import. People records migrate second, resolving companyId lookups against the now-populated Companies table. Opportunities migrate third, resolving companyId and personId lookups against both Companies and People. Each batch processes in groups of 50–100 records with exponential backoff to stay within Twenty's API rate limits. Original create dates, update timestamps, and source system IDs are written to custom fields so Twenty's native audit trail reflects migration time rather than source-system time.

  5. Run sample migration with field-level diff before full commit

    A representative slice of 100–500 records — spanning contacts, companies, deals, and activities across multiple owners — migrates first into a staging area or a test Twenty workspace. FlitStack AI generates a field-level diff comparing source Spark values against the migrated Twenty values, so you can verify that email addresses, company links, deal amounts, stage values, and custom field values landed correctly before the full run commits. Any mapping errors are corrected in the migration plan, and the sample is re-run until the diff passes your team's validation criteria.

  6. Execute full migration with delta pickup window for in-flight changes

    The full migration runs against Twenty with a delta pickup window (typically 24–48 hours) that captures any records created or modified in Spark during the cutover window. Your team continues working in Spark during the migration — FlitStack AI uses scoped read access and does not modify Spark data. An audit log records every operation (records created, updated, skipped, or errored) with row counts and error details. One-click rollback is available if reconciliation fails. Post-migration, we deliver a summary report showing record counts, attachment reference list, and workflow export bundle for your Twenty admin.

Platform deep dives

Context on both ends of the pair

Spark CRM logo

Spark CRM

Source

Strengths

  • AI-powered payment orchestration tightly integrated with CRM data
  • Smart-decline salvage and automatic transaction retry
  • Store/checkout builder and one-click upsell for rapid DTC funnel creation
  • 160+ native integrations with 2-day SLA for new connectors
  • Subscription management and chargeback prevention bundled

Weaknesses

  • Limited independent review and customer-reference footprint
  • 1.5% platform fee on top of monthly subscription inflates TCO at scale
  • Name collision with multiple unrelated 'Spark CRM' products
  • DTC-focused positioning narrows fit for non-e-commerce buyers
  • No public implementation timeline or support structure published
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 Spark 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

    Spark CRM: Not publicly documented on sparkcrm.io.

  • Data volume sensitivity

    B

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

Estimator

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

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

Can't find your answer?

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

Book a free 30 minute consultation

Most Spark CRM to Twenty CRM migrations complete in 48–72 hours of clock time for under 25,000 total records. Larger datasets with 250,000+ records or complex custom-object structures extend to 5–10 days, primarily due to API rate limit management and the enforced import load order (Companies → People → Opportunities). Pre-migration schema setup for custom fields via Twenty's Metadata API adds 2–4 hours of planning time before data moves.

Adjacent paths

Related migrations to explore

Ready when you are

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