CRM migration
Field-level mapping, validation, and rollback between HoneyBook and Odoo CRM. We move data and schema; workflows are rebuilt natively in Odoo CRM.
HoneyBook
Source
Odoo CRM
Destination
Compatibility
9 of 12
objects map 1:1 between HoneyBook and Odoo CRM.
Complexity
BStandard
Timeline
3-5 weeks
Overview
Moving from HoneyBook to Odoo CRM is a client-centric-to-partner-model migration with a significant data-extraction constraint: HoneyBook exposes no public REST or GraphQL API, so all extraction relies on CSV downloads and structured scraping of the web interface. We sequence the migration around this constraint, running authenticated export sessions and reconstructing project and invoice history from HoneyBook's internal data views before loading into Odoo via Odoo's XML-RPC API. HoneyBook's Client object maps to Odoo res.partner (distinguishing individuals from companies via is_company), HoneyBook Projects map to crm.lead with pipeline stage and timeline preserved in custom fields, and Invoices map to account.move records. We do not migrate HoneyBook Automations (email triggers, questionnaire flows, booking confirmations) as there is no export mechanism; we deliver a written inventory of every active automation for your admin to rebuild in Odoo. Odoo's modular ERP architecture means CRM sits alongside Accounting, Inventory, and Project modules; if your migration scope extends to accounting data, we coordinate account.move records with your chart of accounts configuration during the schema design phase.
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 HoneyBook object lands in Odoo 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
Odoo CRM
res.partner
1:1HoneyBook Contacts export as a CSV via Clients > Contacts and include name, email, phone, address, notes, and creation date. We map each row to Odoo res.partner, setting is_company = False and using the contact_id as an external identifier for future sync. If the CSV contains both individual clients and company records, we split them by the presence of a company_name field and set is_company = True for the latter group. Phone numbers are stored as char fields in Odoo, so we preserve the original format without reformatting to avoid breaking downstream integrations.
HoneyBook
Project
Odoo CRM
crm.lead (Opportunity)
1:manyHoneyBook Projects are the primary business record containing inquiry details, pipeline stage, custom fields, files, and associated contacts. Odoo has no native project object, so we reconstruct project metadata as custom fields on crm.lead (Opportunity): hb_project_id (char), hb_pipeline_stage (char), hb_created_date (datetime), hb_inquiry_type (char), and hb_notes (text). The project pipeline stage migrates to crm_stage via the stage name match, and the associated client contact resolves to res.partner.id for the Opportunity's partner_id. Projects without an associated contact are held in a reconciliation queue.
HoneyBook
Invoice
Odoo CRM
account.move
1:1HoneyBook Invoices include line items, payment status, amounts, and client associations. We extract invoice records via the dashboard export or by scraping the invoice list view, then map to Odoo account.move with move_type = 'out_invoice'. Open invoices retain payment_status = 'posted' and are reconciled against the mapped res.partner. Historical invoices are loaded as out_invoice with payment_status = 'posted' and reconciled against the partner's account move lines. Odoo's account_id must be resolved to the customer's account.move record.
HoneyBook
Contract
Odoo CRM
ir.attachment + crm.lead custom field
1:1HoneyBook Contracts are template-based documents with client associations and signature status. We extract contract metadata (client, template name, status, date) and map the metadata to a custom field contract_status__c on the related crm.lead. The contract PDF itself cannot be downloaded via API because HoneyBook file URLs are session-bound; we attempt download during the authenticated export session and attach the resulting file to the Opportunity record using Odoo's ir.attachment model. Any undownloadable files are flagged in the handoff document.
HoneyBook
Proposal
Odoo CRM
crm.lead custom field + ir.attachment
1:1HoneyBook Proposals are project-level documents combining scope, pricing, and terms. We extract proposal records and map scope and pricing terms to custom fields on the crm.lead (hb_proposal_scope__c, hb_proposal_value__c). The proposal PDF, if accessible during the authenticated session, attaches to the Opportunity via ir.attachment. Proposals with no corresponding project record are loaded as standalone Opportunities with proposal_type__c flagged.
HoneyBook
Pipeline Stage
Odoo CRM
crm.stage
lossyHoneyBook pipeline stages (Inquiry, Follow Up, Proposal Sent, Booked, Completed, Declined) map to Odoo crm_stage records by name matching. Each stage gets a probability percentage matching HoneyBook's close-rate data. We configure stages under the relevant crm_team so that Opportunities are scoped to the correct team pipeline. Custom stage names in HoneyBook are preserved verbatim and created as new crm_stage records if no match exists. The migration assigns stage_ids after stage creation to maintain ordering.
HoneyBook
Payment
Odoo CRM
account.move.line
1:1HoneyBook Payment records include amount, method, status, and processing date. We extract payment history via the dashboard export and map completed payments to Odoo account.move.line entries reconciled against the corresponding invoice account.move. 'Payment Attempted' statuses (bank transfers taking 7-8 days) are preserved with their original HoneyBook timestamp as the payment date to avoid misrepresenting a pending payment as completed. Refunded payments are loaded as credit account.move.line entries.
HoneyBook
Team Member
Odoo CRM
res.users
1:1HoneyBook distinguishes between collaborators (external, limited project access) and team members (internal). We export team member records including roles and permissions, then map to Odoo res.users by email match. Collaborators without a corresponding Odoo user are flagged for the admin to provision as portal users if external access is required. The migration holds any owner_id references on crm.lead until user provisioning is confirmed.
HoneyBook
Custom Field
Odoo CRM
ir.model.fields (custom)
lossyHoneyBook supports custom fields on contacts and projects. We identify all active custom fields during discovery, capture their types (text, number, date, checkbox, dropdown), and create matching custom fields on the Odoo res.partner or crm.lead model before migration using ir.model.fields. Dropdown-style custom fields map to Odoo selection fields; checkbox fields map to boolean fields. All custom field values migrate as column data alongside the parent record.
HoneyBook
Questionnaire
Odoo CRM
crm.lead custom field + mail.message
1:1Client questionnaires are linked to projects in HoneyBook and serve as intake forms. We export questionnaire structure and response history as structured key-value data, mapping each question and answer pair to a custom field on crm.lead (e.g., hb_intake_budget__c, hb_intake_timeline__c). Long-form responses or multi-question forms are stored as a mail.message with body = JSON of the full response, linked to the Opportunity via res_id and model = 'crm.lead'.
HoneyBook
File and Template
Odoo CRM
ir.attachment
1:1HoneyBook stores files in a library (images, PDFs, brand assets) and uses templates for contracts and proposals. File URLs are session-bound and not publicly accessible. During the authenticated export session, we attempt to download available files and attach them to the corresponding res.partner (for brand assets) or crm.lead (for project files). Files that cannot be retrieved are logged with their HoneyBook URL in the handoff document for manual download.
HoneyBook
Automations
Odoo CRM
(no migration — inventory only)
1:1HoneyBook Automations (email triggers, questionnaire delivery, follow-up reminders, booking confirmations) are rule-based and stored server-side with no export mechanism. These cannot be migrated programmatically. We deliver a written inventory of every active HoneyBook Automation with its trigger conditions, actions, and delay logic. The customer's Odoo admin or an Odoo partner rebuilds them using Odoo's Automated Actions (ir.cron), Studio workflows, or custom Python code. Automations are out of scope for standard migration.
| HoneyBook | Odoo CRM | Compatibility | |
|---|---|---|---|
| Contact | res.partner1:1 | Fully supported | |
| Project | crm.lead (Opportunity)1:many | Fully supported | |
| Invoice | account.move1:1 | Fully supported | |
| Contract | ir.attachment + crm.lead custom field1:1 | Fully supported | |
| Proposal | crm.lead custom field + ir.attachment1:1 | Fully supported | |
| Pipeline Stage | crm.stagelossy | Fully supported | |
| Payment | account.move.line1:1 | Fully supported | |
| Team Member | res.users1:1 | Fully supported | |
| Custom Field | ir.model.fields (custom)lossy | Fully supported | |
| Questionnaire | crm.lead custom field + mail.message1:1 | Fully supported | |
| File and Template | ir.attachment1:1 | Fully supported | |
| Automations | (no migration — inventory only)1:1 | Not 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.
HoneyBook gotchas
No public bulk API forces manual data export
Payment processing fees apply to every transaction
Bank transfers take 7–8 days to process
HoneyBook Balance is a separate banking product
Limited international availability affects data residency
Odoo CRM gotchas
Odoo.sh version gating blocks assisted migrations from trial
Enterprise modules fail to install on Community after database restore
Custom module view inheritance breaks between Odoo major versions
Custom fields risk losing their application context on Community
API access for Community is gated behind the Custom Plan
Pair-specific challenges
Migration approach
Discovery and data audit
We run an authenticated export session against the customer's HoneyBook account, download the contact CSV from Clients > Contacts, and capture internal data views for projects, invoices, contracts, proposals, pipeline stages, and payments. We count records by type, identify custom fields, flag any automations and workflows, and assess data quality (duplicates, missing required fields, inconsistent formats). The discovery output is a written migration scope with a record count table, a list of HoneyBook objects we can extract and those we cannot, and a timeline estimate based on the extraction complexity.
Odoo schema design and stage configuration
We design the destination schema in Odoo before any data moves. This includes creating custom fields on res.partner (for client metadata and contact-level custom fields), creating custom fields on crm.lead (for project metadata, proposal details, and questionnaire responses), configuring crm_stage records to match HoneyBook pipeline stages by name, setting stage probabilities, and assigning stages to crm_team. We also configure the account.chart template if invoice migration requires it. Schema is deployed to a staging database via XML-RPC for validation before production.
Staging migration and reconciliation
We run a full migration into an Odoo staging environment using production-like data volume. The customer's admin reviews record counts (partners in, opportunities in, invoices in, payments in), spot-checks ten to twenty records against the HoneyBook source, and validates that stage assignments and owner lookups resolve correctly. Any field mapping corrections, missing custom fields, or stage mapping adjustments are made in the staging schema before production migration begins. No production data is touched until staging sign-off is received.
Owner and user provisioning
We extract every distinct HoneyBook owner referenced on project, invoice, and payment records and match by email against the Odoo destination's res.users table. Any HoneyBook owner without a matching Odoo user goes to a reconciliation queue for the customer's admin to provision. Collaborators without Odoo user accounts are flagged for portal access if external client access is required. Migration cannot proceed past this step because Opportunity and partner records require a valid create_uid.
Production migration in dependency order
We run production migration in record-dependency order: res.partner records first (from HoneyBook contacts and companies), then crm.lead with stage_id and partner_id resolved (from HoneyBook projects), then account.move for invoices, then account.move.line for payment reconciliation. Custom field values load alongside parent records. Files are attached via ir.attachment as they become available from the authenticated session. Each phase emits a row-count reconciliation report before the next phase begins. HoneyBook writes are frozen during the production migration window.
Cutover, validation, and automation handoff
We run a final delta migration of any records created or modified in HoneyBook during the production migration window. We validate record counts, spot-check key Opportunities, and enable Odoo as the system of record. We deliver the automation inventory document listing every HoneyBook Automation with its trigger, conditions, and recommended Odoo Automated Action equivalent. We do not rebuild HoneyBook Automations as Odoo rules inside the migration scope; that work is handled by the customer's admin or an Odoo partner. We provide a one-week hypercare window for reconciliation issues raised by the team.
Platform deep dives
HoneyBook
Source
Strengths
Weaknesses
Odoo 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 HoneyBook and Odoo 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
HoneyBook: Not publicly documented.
Data volume sensitivity
HoneyBook 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 HoneyBook to Odoo CRM migration scoping. Not seeing yours? Book a call.
Walk through your HoneyBook to Odoo 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 HoneyBook
Other ways to arrive at Odoo 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.