CRM migration

Migrate from HoneyBook to Twenty CRM

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

HoneyBook logo

HoneyBook

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

36%

4 of 11

objects map 1:1 between HoneyBook and Twenty CRM.

Complexity

BStandard

Timeline

3-5 weeks

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

Moving from HoneyBook to Twenty CRM is a data-centric migration from a clientflow platform to a relationship-focused CRM. HoneyBook organizes around client-centric Projects that bundle inquiries, contracts, invoices, and pipeline stages together; Twenty CRM uses a normalized People-and-Companies model with Opportunities, Tasks, and Notes as first-class objects. We extract HoneyBook data through CSV exports and web-interface scraping, then map Projects to Opportunities with linked People records, preserve Invoice and Contract metadata as custom field blocks on the Opportunity, and flag HoneyBook's Automations as non-migratable since Twenty explicitly requires manual rebuild of workflows and views post-import. HoneyBook Balance (the checking account product) falls outside migration scope and requires direct coordination with HoneyBook support to close or transfer.

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

HoneyBook logo

HoneyBook

What's pushing teams away

  • HoneyBook executed significant price increases in 2025 — Starter nearly doubled from $19 to $36/month and Premium jumped to $129 — prompting customers on fixed margins to evaluate alternatives.
  • The platform has no bulk export or documented public API, making programmatic data extraction time-consuming and forcing users into manual CSV downloads that miss project history and attachment metadata.
  • HoneyBook lacks native SMS capabilities and has limited email marketing features — users who need rich formatted email campaigns must integrate a separate tool like Flodesk or Mailchimp.
  • The onboarding process, particularly template setup and document customization, is described as steep by new users who lack design or legal background.
  • Some advanced CRM needs — custom objects, complex lead scoring, multi-tier pipelines — are not well supported, pushing growing agencies toward more flexible platforms.

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

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

HoneyBook

Contact

maps to

Twenty CRM

Person

1:1
Fully supported

HoneyBook contacts export as a CSV from Clients > Contacts and include name, email, phone, address, notes, and creation date. We ingest this CSV and map each row to a Twenty Person record, preserving the original HoneyBook contact ID in a custom field hb_contact_id__c for audit and cross-reference. Any contact records with duplicate emails are flagged during scoping for manual resolution before import.

HoneyBook

Project (Inquiry)

maps to

Twenty CRM

Opportunity

1:1
Fully supported

HoneyBook projects represent client inquiries and contain pipeline stage, custom fields, associated contacts, and project metadata. We extract project metadata from HoneyBook's pipeline view and map each project to a Twenty Opportunity record. The HoneyBook pipeline stage becomes the Opportunity stage, with a custom field hb_project_id__c and hb_pipeline_stage__c preserving the original HoneyBook stage name and move timestamp for historical accuracy.

HoneyBook

Project Pipeline Stages

maps to

Twenty CRM

Opportunity Stage

lossy
Fully supported

HoneyBook's configurable pipeline stages (Inquiry, Follow Up, Proposal Sent, Booked, etc.) with stage-move timestamps are mapped to Twenty Opportunity stage values. We configure Twenty's opportunityPipeline setting to mirror HoneyBook's stage names and probabilities, and we preserve the stage history as a JSON array in a custom field hb_stage_history__c on the Opportunity.

HoneyBook

Invoice

maps to

Twenty CRM

Custom Object: Invoice (linked to Opportunity)

1:many
Fully supported

HoneyBook invoices include line items, payment status, amounts, and client associations. We extract invoice records via CSV export or HoneyBook's invoice list view, then create a custom Invoice object in Twenty with fields for invoice_number, amount, status, line_items (JSON), and linked_hb_project_id. Each invoice links to the corresponding Opportunity via a custom lookup field. Open invoices requiring continued payment processing are flagged separately.

HoneyBook

Contract

maps to

Twenty CRM

Custom Field Block on Opportunity

lossy
Fully supported

HoneyBook contracts are template-based documents with client associations and e-signature status. We extract contract metadata (client, template name, status, date, signature status) and store it as a structured custom field block on the linked Twenty Opportunity: hb_contract_status__c, hb_contract_template__c, hb_signed_date__c, hb_signature_provider__c. The actual contract PDF requires separate file handling (see Files note).

HoneyBook

Proposal

maps to

Twenty CRM

Custom Field Block on Opportunity

lossy
Fully supported

HoneyBook proposals are project-level documents combining scope, pricing, and terms. We extract proposal records and map them to the linked Opportunity's custom fields: hb_proposal_status__c, hb_proposal_amount__c, hb_proposal_sent_date__c, hb_proposal_response__c. Proposal documents themselves require separate file migration handling.

HoneyBook

Payment

maps to

Twenty CRM

Custom Field Block on Invoice

lossy
Fully supported

HoneyBook payment records include amount, method, status, and processing date. We extract payment history and map to the custom Invoice object with fields for amount, method, status (Completed, Pending, Refunded), and processing_date. We preserve the original HoneyBook timestamp for bank transfers (which carry a 7-8 day clearing window) rather than the settlement date to avoid conflating Payment Attempted with Completed status.

HoneyBook

Custom Fields

maps to

Twenty CRM

Custom Fields on Person and Opportunity

lossy
Mapping required

HoneyBook supports custom fields on contacts and projects. We identify all active custom fields during discovery, export their values alongside the parent record, and create matching custom fields in Twenty via Settings → Data Model before import. Custom fields must exist in Twenty before CSV import begins; import will reject records referencing non-existent fields.

HoneyBook

Team Members

maps to

Twenty CRM

WorkspaceMember

1:1
Mapping required

HoneyBook distinguishes collaborators (external, limited project access) from team members (internal). We export team member records including roles and permissions, then map internal team members to Twenty WorkspaceMembers. Collaborators without a Twenty user account are mapped to a custom field hb_collaborator__c on the relevant records. The customer provisions Twenty users before migration so that Owner and assignee lookups are satisfied at import time.

HoneyBook

Automations

maps to

Twenty CRM

Not Migrated

1:1
Not supported

HoneyBook automations (email triggers, questionnaire flows, booking confirmations) are rule-based and stored server-side with no export mechanism. Twenty CRM's own migration documentation explicitly states that views, workflows, and permissions must be recreated manually after import. We do not migrate automations as code. We deliver a written inventory of every active HoneyBook automation with its trigger conditions, actions, and recommended manual rebuild steps for Twenty. This inventory is provided as a handoff document for the customer's admin.

HoneyBook

Files and Attachments

maps to

Twenty CRM

Custom Field (file references)

lossy
Fully supported

HoneyBook stores files in a library (images, PDFs, brand assets) and attaches them to projects and contracts. File URLs are session-bound and not publicly accessible. We handle file migration by downloading attachments during an authenticated session and storing them in a customer-provided storage location (S3, Google Drive, Dropbox), then recording the file URL in a custom field on the relevant Twenty record. File migration is scoped separately from record 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.

HoneyBook logo

HoneyBook gotchas

High

No public bulk API forces manual data export

Medium

Payment processing fees apply to every transaction

Low

Bank transfers take 7–8 days to process

Medium

HoneyBook Balance is a separate banking product

Medium

Limited international availability affects data residency

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

  • HoneyBook CSV export covers contacts only

    HoneyBook's only native bulk export is a contact CSV from Clients > Contacts. All other records — projects, invoices, contracts, proposals, pipeline history — have no bulk export and must be extracted from HoneyBook's web interface. We mitigate this by running an authenticated export session, scraping the project list view, extracting invoice records from the invoice panel, and reconstructing pipeline history from the pipeline view. This manual extraction phase adds scoping time and cost compared to migrations from platforms with public APIs, and some attachment metadata may not be recoverable if it was only stored in HoneyBook's session-scoped file URLs.

  • Twenty self-hosted requires Docker and ongoing server maintenance

    Twenty CRM's self-hosted deployment requires Docker, a compatible host (Linux with at least 4 GB RAM), and regular container updates. GitHub issue #13221 documents a case where a self-hosted Twenty instance became inaccessible after a period of inactivity, resolving to a bad gateway error that restarting containers did not fix. We flag self-hosted versus Cloud Pro as a migration decision upfront. If the customer chooses self-hosted, we document the hosting requirements and recommend a hosting plan with managed container updates or a DevOps contact for ongoing maintenance.

  • Twenty workflows and automations require manual rebuild post-migration

    Twenty CRM's own migration documentation explicitly states that views, workflows, and permissions must be recreated manually after import. This is not a limitation of our migration — it is a platform design decision. We do not rebuild HoneyBook automations as Twenty workflows. We deliver a written automation inventory document that the customer's admin uses to recreate automations manually in Twenty. Teams relying heavily on HoneyBook's automation engine should account for 2-4 weeks of admin time to rebuild their automation flows after migration.

  • HoneyBook Balance checking account falls outside migration scope

    HoneyBook Balance is a checking account product tied to the HoneyBook subscription (pending eligibility). It is a separate external bank account that some HoneyBook customers may have connected within the platform. We flag this during scoping and advise customers to coordinate directly with HoneyBook support to close or transfer the Balance account, as it is not a standard HoneyBook platform record and falls outside the scope of standard record migration.

  • Twenty API support is limited compared to established CRMs

    Third-party comparisons (Groundhogg vs Twenty CRM) note that Twenty's REST API has limited support for features like webhooks (requires Zapier), UTM parameter tracking, developer hooks and filters, and white labeling. Teams with heavy integration requirements should validate that their specific integration use cases are supported before committing to Twenty. Our migration uses Twenty's standard REST API for record creation; custom integrations may require additional scoping.

Migration approach

Six steps for a successful HoneyBook to Twenty CRM data migration

  1. Discovery and data audit

    We audit the HoneyBook account for record volume across contacts, projects, invoices, contracts, proposals, pipeline stages, team members, and custom fields. We assess which HoneyBook export paths are available (contact CSV confirmed; project and invoice data requires web-interface extraction) and document any HoneyBook Balance checking account that requires separate handling. We confirm the customer's intended Twenty deployment (self-hosted or Cloud Pro) and provision a Twenty workspace for migration with custom objects and fields pre-created per our schema design.

  2. Schema design and custom field creation

    We design the Twenty destination schema based on the HoneyBook data audit. This includes creating custom fields on Person (for contact-level HoneyBook custom fields and collaborator flags), creating the custom Invoice object with all required fields and a lookup to Opportunity, and configuring the Twenty opportunityPipeline to mirror HoneyBook's pipeline stage names and probabilities. We also create the hb_contact_id__c, hb_project_id__c, hb_pipeline_stage__c, hb_stage_history__c, and other audit fields. The customer provisions Twenty users before import so that Owner lookups are satisfied.

  3. Data extraction from HoneyBook

    We run an authenticated extraction session against the HoneyBook account. Contacts export as a direct CSV download. Project metadata is scraped from the pipeline view in batches to avoid interface timeouts. Invoice records are extracted from the invoice panel, and contract and proposal metadata are scraped from their respective list views. We flag any records with missing required fields (e.g., contacts without email) for the customer's review before import. File attachments are downloaded during the authenticated session and staged in a customer-provided storage location.

  4. Data transformation and staging

    We transform the extracted HoneyBook data into staging CSVs compatible with Twenty's import format. Contact records are deduplicated by email, and any duplicates are written to a reconciliation report for the customer to resolve. Project records are mapped to Opportunities with the original HoneyBook stage history preserved as hb_stage_history__c. Invoice records are created as custom Invoice objects with a lookup to the parent Opportunity. We validate field formats (phone numbers, dates, currency codes) against Twenty's requirements and flag any records that require format correction.

  5. Staging migration and reconciliation

    We run a full migration into a Twenty staging environment (or the production instance if self-hosted) using the transformed staging CSVs. The customer reconciles record counts and spot-checks 25-50 records against the HoneyBook source. Any mapping corrections, custom field additions, or stage configuration adjustments happen in this phase. We do not proceed to production migration until the customer signs off on the staging reconciliation.

  6. Production cutover and automation handoff

    We freeze writes in HoneyBook during cutover and run a final delta migration of any records created or modified during the migration window. We enable Twenty as the system of record and deliver the automation inventory document listing every HoneyBook automation with its trigger, conditions, and recommended manual rebuild steps for Twenty. We support a one-week hypercare window for reconciliation issues. We do not rebuild HoneyBook automations or configure Twenty workflows as part of the standard migration scope.

Platform deep dives

Context on both ends of the pair

HoneyBook logo

HoneyBook

Source

Strengths

  • Combines CRM, invoicing, contracts, and payment processing in a single subscription for service businesses.
  • Automations handle client-facing touchpoints like reminders, questionnaires, and booking confirmations without manual work.
  • Pipeline view gives a clear visual of inquiry status from first contact through project completion.
  • Strong customer support with 7-day-a-week availability and a community of professional users.
  • Mobile app available on iOS with full feature parity for on-the-go client management.

Weaknesses

  • No public bulk API or documented export endpoints — all data extraction relies on manual CSV downloads or screen scraping.
  • Significant 2025 price increases (Starter nearly doubled) have driven churn among cost-sensitive freelancers.
  • Limited international support — platform primarily designed for U.S. and Canadian businesses.
  • No native SMS capability and restricted email marketing features compared to dedicated marketing tools.
  • Steep onboarding curve for template setup and document customization without third-party assistance.
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 HoneyBook 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

    HoneyBook: Not publicly documented.

  • Data volume sensitivity

    B

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

Estimator

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

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

Can't find your answer?

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

Book a free 30 minute consultation

Migrations under 5,000 contacts and 500 projects with no complex custom fields land between three and five weeks. Migrations with large invoice histories, contract attachment handling, multiple pipeline stages, or a self-hosted Twenty destination requiring Docker and hosting configuration move to eight to twelve weeks. The primary timeline variable is HoneyBook's limited export surface — extracting project, invoice, and contract data from HoneyBook's web interface takes longer than API-based extractions from platforms with public APIs.

Adjacent paths

Related migrations to explore

Ready when you are

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