Skip to content
Get a quote

Migrate to Odoo CRM

Odoo CRM is an open-source, module-based pipeline tool whose import path rewards teams that pre-create models, respect platform throughput ceilings, and stage Community-vs-Enterprise feature gaps before the first CSV row is loaded.

Short answer

FlitStack AI migrates pipelines, contacts, and deals into Odoo CRM from 850+ CRMs, including Zoho CRM, Salesforce, Pipedrive, HubSpot. Every field is mapped to Odoo CRM's objects, history and associations come across, the Odoo CRM setup is configured alongside, and the whole migration stays reversible in one click.

By

From Any source
DestinationOdoo CRM
Zoho CRMSalesforcePipedriveHubSpotJonas Enterprise Service & Construction Software
850+ sources mapped into Odoo CRM

What Odoo CRM supports, and where its import tools stop

  • Teams choose Odoo CRM for its modular architecture — one base install with one-click app additions means they can adopt CRM alone and add accounting, inventory, or sales later as the business grows.
  • Small businesses pick Odoo because the Community edition is free and open-source, with no per-user or contact limits, allowing full evaluation before committing to a paid Enterprise tier.
  • The drag-and-drop Kanban pipeline and AI lead scoring are highlighted across G2 reviews as concrete features that make lead management faster and more visual than spreadsheet-based workflows.
  • Odoo's native integration with email, live chat, SMS, VoIP, and WhatsApp means inbound leads from multiple channels feed into a single pipeline without third-party middleware.
REST onlyXML-RPC with session authentication; API key available on Enterprise plans
Rate limitsNot publicly documented; no published rate limit found in Odoo's official developer documentation
ObjectSupportNote
Contacts / PartnersfullContacts and Partners share the same res.partner model in Odoo. Standard fields (name, email, phone, address, company_id) are fully exportable via XML-RPC. We map res.partner records directly to the destination CRM's contact object, preserving the partner_id on any related records.
LeadsfullLeads (crm.lead) are the top-of-funnel records with fields including name, contact_name, email_from, phone, source_id, and stage_id. When a Lead is converted to an Opportunity, it creates a linked crm.lead record with type='opportunity'. We export both types and flag which records originated as Leads vs. converted Opportunities.
OpportunitiesfullOpportunities are crm.lead records with type='opportunity', linked to pipeline Stages and Sales Teams via stage_id and team_id. Key fields include expected_revenue, probability, date_closed, and partner_id (the customer). We preserve the opportunity-to-contact linkage and the pipeline stage ordering.
Pipeline StagesfullStages live in crm.stage and are ordered per team via crm.team.stage.rel. Custom stages added by the customer are included in the export. We sequence the stage order and map stage names to the destination CRM's pipeline stage definitions, flagging any stage that uses Automation rules that may not transfer.
Sales TeamsfullSales Teams (crm.team) group Opportunities and assign Leads to team members via user_id and member_ids. Each team has its own pipeline with independent stage configurations. We export team membership and map it to the destination's equivalent team or user assignment model.
Activities / TasksmappedActivities (mail.activity) are linked to crm.lead records and include type, date_deadline, user_id, and note. Activity history is a key migration concern because it is high-volume and loosely coupled — we export it after leads/opportunities and validate record counts before loading.
Custom Fields (on Leads/Opportunities)mappedCustom fields defined via Odoo's Studio or in custom addons are stored as columns in crm.lead. These are fully exportable, but their field types (selection, many2one, many2many) may not map 1:1 to the destination CRM's custom field system. We flag field-type mismatches during the scoping call.
AttachmentsmappedAttachments (ir.attachment) linked to crm.lead records are stored in the Odoo filestore. Large attachment volumes can bloat exports. We chunk the filestore export separately and remap ir.attachment.res_id/res_model references after target IDs are assigned, using the attachment.res_model + res_id linkage to re-attach them to the correct records in the destination.
TagsfullTags (crm.tag) are applied to crm.lead records via a many2many field. Tag names are preserved as a flat list and mapped to the destination CRM's tagging or label system. Custom tags added by the customer are included in the export.
Lead Scoring RulesnoneOdoo's predictive lead scoring (crm.scoring.rule) is an Enterprise-only feature with a proprietary algorithm that depends on Odoo's AI infrastructure. We do not migrate scoring rules because they have no equivalent in most destination CRMs and the model cannot be reliably reverse-engineered.
Automation Rules (Server Actions)noneCRM automation rules (base.action.rule and ir.actions.server scoped to CRM) are Enterprise-exclusive and tightly coupled to Odoo's action framework. These cannot be migrated to non-Odoo CRMs. We export a plain-English audit of which rules exist so the customer's implementation team can manually reproduce them.
Quotations / Sale OrdersmappedQuotations (sale.order) are linked to Opportunities via create_uid and Odoo-specific relational fields. They carry line items (sale.order.line), pricing, and taxes. We export quotations with their linked partner and opportunity, but note that the full sale.order data model includes accounting fields that may require the Accounting module to be active in the destination.

The Odoo CRM migration guide

Why teams migrate to Odoo CRM

The four shapes an Odoo CRM migration takes, and what makes the platform easier — or harder — than the category average.

Odoo S.A. was founded by Fabien Pinckaers in 2005 as TinyERP, rebranded to OpenERP in 2009, then to Odoo in 2014, and is headquartered in Ramillies-Brabant-Wallon, Belgium1. Odoo CRM is the sales-side application inside a suite of around 80 official modules — Sales, Inventory, Accounting, Manufacturing, HR, Project, Website, eCommerce — all sharing the same PostgreSQL database and ORM.

The typical Odoo CRM customer is a small-to-mid-market team — 10 to 300 users — that wants pipeline plus quoting plus invoicing plus inventory under one schema, and is willing to absorb the open-source learning curve in exchange for the integration depth. Compared with HubSpot or Pipedrive, Odoo positions itself on integrated business operations and Community-edition affordability; compared with Salesforce, it positions on a unified data model and a far smaller per-user cost on Enterprise tiers.

The shapes of migration that actually land on Odoo CRM tend to fall into four patterns. First, suite consolidation projects: a company replacing a stack of Pipeline CRM plus QuickBooks plus a separate inventory tool with the Odoo all-in-one suite. Second, vendor-cost exits from Salesforce or Zoho where total cost of ownership on smaller teams justified an open-source alternative3.

Third, legacy replacements — older OpenERP/TinyERP installs, Sage, Microsoft Dynamics on-prem, or homegrown databases — where the source schema is loose and the project is really a re-architecture against crm.lead and res.partner. Fourth, Odoo-to-Odoo version migration, where a team running Community 15 jumps to 18 or 19, or moves from Odoo.sh Enterprise back to self-hosted Community4.

Each shape has a different difficulty profile: a Pipeline CRM migration usually has clean object parity but messy custom-field labels, while a Salesforce migration carries rich automation that does not move across.

What makes migrating to Odoo CRM easier than the category average is the import tool itself — it accepts CSV and Excel files, auto-detects column types, supports relational fields via XML external IDs, and ships built into every model's list view through Actions → Import records56. Pre-built templates exist for Contacts, Leads, Companies and Products.

What makes it harder than the average is the Community-vs-Enterprise gap, where Studio, advanced reporting, the Marketing Automation app and several connector modules are paid-only and silently disappear if you restore an Enterprise database into a Community container4. The second hard edge is the per-tenant throughput ceiling on Odoo Online of roughly one programmatic request per second — a constraint that catches teams scaling parallelism off database-server expectations8.

Studio customisations, custom Python modules, automated actions and server actions do not move with a CSV import — they are rebuilt as modules and configured in the destination. Teams that scope for that work up front finish on time; teams that assume parity do not.

Studio customisations, custom modules and server actions do not move with a CSV import — they are rebuilt in the destination.

The Odoo CRM data model you need to map into

Models, fields, ondelete semantics, and the external IDs you'll wire on every relational column — the destination schema decoded.

Odoo's CRM is built around a small set of Python models, each declared as a class extending models.Model with attributes that the ORM persists into PostgreSQL9. Sales activity and pipeline behaviour sit on top of the same shared res.partner master record used by Accounting, Sales, and every other Odoo app.

Before you can map a field on the source side, you need to know exactly which destination model the row belongs on, what fields it requires, and which value will serve as its external ID for upsert. The table below summarises the models you will touch in an Odoo CRM migration10.

ObjectWhat it storesRequiredTier
res.partnerMaster record for individuals and companies (Contacts)name; is_company flag distinguishes person vs companyAll editions
crm.leadLeads and opportunities in the pipelinename (subject); type ('lead' or 'opportunity')All editions (CRM module)
crm.teamSales teams that own pipelinesname; member_idsAll editions
crm.stagePipeline stages (Qualified, Proposition, Won)name; sequence; team_id (optional)All editions
crm.tagFree-form tags on leads/opportunitiesnameAll editions
mail.activityScheduled to-dos: calls, meetings, emails, tasksactivity_type_id; res_model; res_id; date_deadlineAll editions
mail.messageChatter messages, emails, internal notes per recordmodel; res_id; body; message_typeAll editions
calendar.eventMeetings synced with Outlook/Googlename; start; stop; user_idAll editions; sync setup is per-user
product.product / product.templateSellable items linked to quotes and ordersname; type; list_priceAll editions
sale.order / sale.order.lineQuotations and confirmed sales orderspartner_id; order line products and quantitiesRequires Sales module

res.partner is the unifying record — a single row represents either a person (is_company=False) or a company (is_company=True), and the parent-child relationship between an employee and their employer is modelled by the parent_id Many2one field on res.partner itself11.

Odoo does not have a single canonical natural-key field like HubSpot's email. Instead, the import tool uses an XML external ID — a string of the form __import__.123 or your_module.contact_acme — stored in the id column on the import spreadsheet. The external ID is the upsert key: re-importing the same row with the same external ID updates; a new external ID creates5.

If you do not supply external IDs, Odoo creates them automatically and you lose the ability to deterministically re-import. For native dedup on res.partner, install the Data Cleaning app and configure dedup rules on email, phone, or VAT number12. Custom field types determine validation and storage; the catalogue below covers what you can model and the limits you need to plan around9.

Field typeLimitNotes
Char (single-line text)Default size=64, configurableMaps to PostgreSQL varchar; trim before import
Text (multi-line text)Unlimited (PostgreSQL TEXT)Used for descriptions, internal notes
Integer / FloatINT4 / NUMERIC in PostgreSQLFloat defaults to digits=(16,2); override per field
Date / DatetimeYYYY-MM-DD / YYYY-MM-DD HH:MM:SS in UTCDatetime stored UTC; ISO-8601 strongly recommended13
Selection (picklist)Defined as Python tuple listInternal key vs label; import expects the key9
Many2one (foreign key)Single related recordResolves by name OR external ID — pick one and be consistent
One2many / Many2manyInverse / junction relationsMany2many uses comma-separated names on import
BooleanTrue/False/1/0Empty cells default to False on import
Binary128 MiB default attachment cap14Base64-encoded on programmatic load; large files belong in filestore
Custom fields via StudioUnlimited count, Enterprise-only UICommunity: edit via Developer Mode → Settings → Technical → Fields

Relationships in Odoo are modelled by relational fields with explicit ondelete semantics: cascade deletes children when the parent is deleted, restrict blocks the parent delete, set null clears the foreign key15. This is configured in fields.py per field, not at the database level you can flip from the UI.

Custom Objects in Odoo are not a separate concept — they are simply new Python models, declared in a custom module's models/ folder, or created via Studio (Enterprise) which writes the same metadata into ir.model and ir.model.fields16. Either way, the model must exist in the database before records of that type can be imported.

Pre-migration prep — the work before you touch Odoo CRM

What must be true on the source, the destination, and across the team before the first row hits the import wizard.

The single best predictor of a clean Odoo CRM migration is how much work you do on the source side before the first import button is pressed. Odoo's own implementation guide warns that data preparation — not the upload itself — is where most projects lose days, and the fix is almost always pre-processing rather than post-cleanup.

The single best predictor of a clean migration is how much work you do before the first import button is pressed.

Treat the source export as raw material that needs to be shaped to Odoo's expected formats — dates rewritten to YYYY-MM-DD (ISO-8601), selection values converted to their internal keys, Many2one relations resolved to either a name string or an external ID, owner emails resolved to existing res.users records, and every row stamped with a stable id column.

Source-side prep

  • Audit and dedup the source database before export — Odoo's Data Cleaning app handles post-import dedup on res.partner, but it is much cheaper to dedup on the source than to merge after12. Match on email, phone, and VAT number.
  • Normalise dates to YYYY-MM-DD or YYYY-MM-DD HH:MM:SS in UTC. Odoo's importer auto-detects most formats but warns that day/month inversions like 01-03-2016 are ambiguous; use ISO-8601 to remove the guesswork13.
  • Convert selection field labels to internal keys — for stage names, lead status, and any custom Selection field, Odoo expects the Python key (e.g. done, cancel), not the display label. Mismatches fail on import with cryptic errors9.
  • Stamp a stable external ID in an id column on every export row — a UUID, the source platform's primary key, or a namespaced string like legacy.contact_42. This is what makes re-runs and reconciliation deterministic5.
  • Decide what is in scope for historical activities. mail.activity and mail.message rows can be imported, but the chatter history from a separate CRM rarely preserves cleanly without custom scripting against the ORM.

Destination-side prep

  • Create a staging database on Odoo.sh (staging branches are first-class) or a duplicate database on Odoo Online/on-prem to dry-run the import end-to-end. Restore a sanitised copy of production into staging weekly during the project.
  • Provision users first under Settings → Users & Companies → Users, assigning each to the Sales/Salesperson groups and a crm.team. Owner assignment fails silently if the referenced user does not exist20.
  • Pre-create every custom field on the right model via Studio (Enterprise) or Developer Mode → Settings → Technical → Fields (Community). Selection fields must have their full key list defined before any value is imported.
  • Build pipelines, stages and teams in CRM → Configuration → Stages and Sales Teams before importing leads — rows targeting a non-existent stage_id fall back to the default stage rather than failing loudly.
  • Install required modules first — Sales, CRM, Contacts, Discuss (for chatter), Calendar (for activities), and any community OCA modules you intend to depend on. Trying to import to a model whose module is not installed throws Model not found.

People prep

Cutover only works if humans cooperate. Lock down a source-system freeze window — typically 24 to 72 hours — and communicate it to every department that touches the CRM. Train sales reps on Odoo's kanban pipeline drag-and-drop, the chatter and activity widgets, and the Discuss inbox before go-live, not after.

A typical small-business migration runs one to two business days; a Salesforce-to-Odoo project with deal history, custom modules and Studio rebuilds runs two to four weeks of elapsed time even when the technical work is faster21. Build the human runway accordingly.

Import mechanisms: UI wizard, base_import, and programmatic loads

Several paths in, each with different limits and shapes. Picking the wrong one is how mid-migrations stall at the throughput ceiling.

Odoo exposes several load paths and the right one depends on dataset size, model mix, and whether you need to re-run idempotently. The UI Import wizard (powered by the base_import module) covers most one-shot migrations under a few hundred thousand records. Programmatic loads handle repeatable and very large volumes. Third-party tools sit on top of both and add staging, transformation and dedup layers.

UI Import wizard (base_import)

The native import lives on every model's list view: open the model (Contacts, Sales → Leads, etc.), click the Actions icon (or the gear menu in older versions), then Import records → Upload File6. The wizard accepts CSV and Excel (XLSX) files, auto-detects column-to-field mapping by name, exposes a Show fields of relation fields (advanced) toggle to see related model fields, and offers a Test mode that validates the file without writing rows.

There is no hard daily row cap in base_import, but Odoo Online and Odoo.sh enforce per-instance memory and CPU limits that practically cap a single import at the low hundreds of thousands of rows before the worker times out5. The right call: UI for one-shot loads under 100k records on standard models, or any time you want a visual mapping review and a Test pass before commit.

For Excel files, save as .xlsx (not .xls) — older formats are less reliable5. Re-imports against the same external ID in the id column update existing rows; new external IDs create.

Programmatic loads — XML-RPC and JSON-RPC transports

Odoo's programmatic load surface has existed since version 6 and exposes the same ORM methods as the UI22. Calls invoke execute_kw(db, uid, password, model, method, args) with methods like create, write, search_read, and the bulk-friendly load.

The load() method is what base_import calls internally — it accepts a list of field names and a list of value rows and applies the same external-ID upsert semantics as the UI wizard. For bulk loads, batch records into chunks of 100 to 500 per create or load call; smaller batches add round-trip overhead, larger batches risk request timeouts on Odoo.sh.

Choose the programmatic path when the load is over 100k records, when custom models are involved, when the migration needs to be repeatable and audit-logged from your side, or when you are syncing from an external warehouse. Wrap calls in a back-off loop on throttle and connection-reset errors.

Third-party staging tools and OpenUpgrade

Tools like Fivetran, Airbyte and Stacksync ship Odoo connectors that sit between the source and the destination. They are commonly used in two ways: (a) reverse-ETL where the source database is loaded into a warehouse, transformed in SQL, then synced into Odoo via XML-RPC; and (b) staging-and-validate, where the tool generates the import CSV, runs type coercion, and feeds the result to the wizard.

For Odoo-version migrations specifically (Community 15 → 18, etc.), the Odoo Community Association's OpenUpgrade project provides the only working open-source upgrade scripts for Community editions23. For Odoo Enterprise upgrades, Odoo S.A.'s paid upgrade service handles the schema transformation but is not available to Community users.

Mapping your data into Odoo CRM

The longest section — because field mapping is where almost every migration that fails actually breaks.

Mapping is where every migration earns its scars. The schema decisions you make in your mapping spreadsheet determine whether reports work on day two, whether automated actions fire correctly on day five, and whether your sales team trusts the data on day thirty.

Work model by model, top to bottom of the dependency order: res.users first (so owners can be referenced), then companies on res.partner (so contacts and leads can associate to them), then individual contacts on res.partner, then crm.lead, then mail.activity and mail.message, then sale.order if you are bringing in quote history.

Contacts (res.partner)

Common source → res.partner mapping
SourceDestinationNote
external ID / source primary keyid (XML external ID column)The upsert key — re-running with the same id updates5
first_name + last_name (person) or company_namenameConcatenate for is_company=False; use company name when is_company=True
is_organisation flagis_companyBoolean — True for companies, False for individuals
emailemailLowercased; Data Cleaning app can dedup post-import12
phone / mobilephone / mobileNormalise to E.164; both fields exist separately
parent_account_idparent_id (Many2one to res.partner)Resolve via external ID; import companies first, then employees
vat_number / tax_idvatFormat-validated against country rules; strip on import if dirty
country / statecountry_id / state_idMany2one — must match an existing res.country / res.country.state record
language preferencelangUse locale code (en_US, fr_FR); language pack must be installed

Companies and parent-child relations

Odoo collapses companies and contacts into the same res.partner table, distinguished by the is_company boolean and linked through parent_id. The clean import order is: companies first with is_company=True and stable external IDs, then individual contacts with is_company=False and parent_id/id pointing to the company's external ID11.

If you are consolidating multiple source systems, run each through a transform step that adds a system prefix to the external ID (hubspot.contact_123, pipedrive.contact_456) so you can re-import deltas from either system without collision.

Leads, opportunities and pipelines (crm.lead, crm.stage)

crm.lead is the single table for both leads and opportunities — the type field stores 'lead' or 'opportunity', and conversion is a state transition rather than a record move. Recreate every pipeline and every stage in CRM → Configuration → Stages before importing — rows referencing a non-existent stage_id will be ignored or fall to the default stage.

If you are consolidating multiple source pipelines into Odoo, the cleanest approach is to keep them as separate sales teams (crm.team) with their own stages for at least 90 days post-migration, then merge once reporting has stabilised.

Common source → crm.lead mapping
SourceDestinationNote
opportunity_name / lead_subjectnameRequired field — never null
stage / pipeline_stagestage_idResolve to existing crm.stage via name or external ID
lead vs opportunity flagtypeSelection: 'lead' or 'opportunity' — use the internal key
amount / expected_revenueexpected_revenueFloat; default precision (16,2); set company currency_id
probabilityprobabilityFloat 0–100; default driven by stage
expected_close_datedate_deadlineYYYY-MM-DD; ISO-8601 strongly recommended13
owner / salespersonuser_idMany2one to res.users — pre-provision users first20
sales teamteam_idMany2one to crm.team — defaults from user if omitted
primary contactpartner_idMany2one to res.partner; resolves via external ID
tagstag_ids (Many2many)Comma-separated names; missing tags are created on import

Custom-field mapping strategy

Resist the urge to map every source custom field one-to-one. Migrate only the custom fields used by an active process, automated action, or report in the last 12 months. Excess fields weaken governance, slow down list views, and make the model harder to upgrade between Odoo versions because every custom field has to round-trip through OpenUpgrade or the paid upgrade service23.

For Selection fields whose source values do not match the destination, either: (1) extend the destination Selection with the missing internal keys via Studio or fields.py, (2) collapse adjacent values during transform, or (3) introduce a parallel legacy_value Char field that holds the source value verbatim. Computed fields (Odoo decorator-based or compute=) do not import — Odoo recomputes them on save — so any source formula must be rebuilt as a computed field on the model or replicated via Server Actions.

Historical activities, notes and chatter

Odoo splits historical engagement across three tables: mail.activity (scheduled to-dos with a date_deadline), mail.message (chatter messages and emails attached to a record), and calendar.event (meetings synced from Outlook/Google)25. mail.message is what shows in the chatter widget on every record's right side, and it is the destination for migrated email and call history26.

Bulk-importing historical chatter is non-trivial because mail.message enforces strict relations on model, res_id, author_id and threading via parent_id. The Odoo forum's general guidance is that note, message and activity history can be imported via the export/import feature, but typically requires a Python script against the ORM to handle threading and author resolution correctly27.

For one-off imports under a few thousand messages, CSV via the wizard works; above that, script against mail.message.create with explicit model='crm.lead' and res_id set to the lead's database ID.

Activities (calls, meetings, to-dos) can be created with a backdated date_deadline and summary, but create_date on the activity itself cannot be overridden — it stamps to import day28. If you need a historical timeline view, store the original timestamp in a custom legacy_date Datetime field on the activity and filter reports off that.

Files and attachments

Attachments in Odoo live on the ir.attachment model and link to any record via res_model and res_id. Default per-attachment size cap is 128 MiB and cannot be increased in Odoo Online; self-hosted instances can raise it in server configuration14. Supported image formats include JPEG, PNG, GIF, BMP, TIFF, SVG, ICO, WEBP, PSD and EPS29.

Bulk attachment import is not part of base_import — the supported path is either (a) the Documents app (Enterprise) which exposes a drag-and-drop bulk uploader, (b) the fs_attachment OCA module which moves the filestore to S3 or an external filesystem30, or (c) scripted upload via the ORM where you base64-encode the binary and create an ir.attachment record with datas, name, res_model and res_id set.

For large attachment estates, most teams adopt: keep originals in S3, install fs_attachment, and only inline-upload the most recent or most-referenced subset.

Audit trail, ownership and original timestamps

Odoo records create_date, create_uid, write_date and write_uid automatically on every model and does not preserve the original file's creation or modification date during import — create_date stamps to upload time28. If you need to preserve the original audit trail, create two custom fields per model — legacy_create_date (Datetime) and legacy_create_uid (Many2one to res.users) — and populate them from the source export.

Owner assignment during import works only if the res.users record exists at the moment of import; rows whose user_id cannot be resolved import with no owner set, which silently breaks team-based record rules and pipeline routing20.

Account-level audit logging is not on by default. The OCA Audit Log module lets you define per-model rules in Settings → Technical → Audit → Rules and writes old/new values for every change31. Without it (or the Enterprise Audit Trail in the Accounting app), there is no out-of-the-box per-field change history.

CRM-specific: lead scoring, email/calendar sync, automated actions

Lead-scoring rules do not import — they are rebuilt in CRM → Configuration → Lead Scoring Rules (Enterprise) or via custom server actions on Community. Plan to recreate the rule logic from your source platform documentation rather than trying to migrate accumulated score values; if you must preserve historical scores, store them in a legacy_score Float field and let the new rules accrue forward.

Email and calendar sync is configured per user under Settings → General Settings → Discuss / Calendar for Outlook (requires an Azure AD App Registration with Application ID and Client Secret) and Google Workspace32. Set this up after user provisioning is complete but before the activity import runs, or you risk duplicate calendar entries when the connector backfills against the same events you are loading.

Automated Actions (the Odoo equivalent of HubSpot workflows) and Server Actions are stored in base.automation and ir.actions.server and do not move with a CSV import — they are rebuilt in the destination by an admin in Settings → Technical → Automation Rules.

The pitfalls that derail Odoo CRM migrations

Nine specific failure modes — ranked by impact, each tied to the exact Odoo mechanism that breaks.

Validation and cutover

What to verify after the import job, in what order — and how to fail safely when something is wrong.

Validation is the bridge between the import finishing and users being allowed in. Odoo implementation guides recommend a three-stage validation: a test load of 10 percent of records with stakeholder spot-checks, the full load with real-time monitoring of record counts and relation integrity, and a 30-day post-migration data-quality audit. The most reliable signal is having department reps verify their own records — they know what right looks like better than any reconciliation script.

Build a reconciliation queries spreadsheet that compares source and destination on each of these counts. Anything outside a 0.5 percent variance gets investigated before users get login access.

  • Total partners imported vs source — split by is_company True/False — minus deliberately excluded rows (role-based emails, bounced lists, opt-outs).
  • Total leads and opportunities per stage per team vs source, plus sum of expected_revenue per pipeline — a non-trivial revenue variance usually signals a stage-mapping error or a currency-precision drop.
  • Activities and messages per record — count mail.activity and mail.message rows against source-derived expectations, and confirm date_deadline and legacy_create_date round-tripped.
  • Parent-child integrity on res.partner — every contact with is_company=False should have a parent_id pointing to a valid is_company=True partner; orphans indicate a broken company-first import.
  • Owner distribution — GROUP BY user_id on crm.lead and confirm no lead landed unowned that should not have.
  • External-ID uniqueness — query ir.model.data for duplicate (module, name) combinations on your namespace; any duplicates indicate the dedup transform missed cases.
  • Attachment counts per record — for migrated ir.attachment rows, count by res_model and compare against the source file inventory.

On top of reconciliation, run a manual spot-check protocol: pick 30 random records across models and verify each field against the source UI. Pick five high-value opportunities and trace the full relation graph — partner, sales team, owner, activities, chatter, attachments, related quotes. If a non-trivial discrepancy shows up in three or more of the 30, halt the load, fix the root cause, and re-import the affected rows by external ID.

Odoo does not ship a native bulk-undo. The closest thing is the OCA Audit Log module (when enabled with the right rules) which captures old/new values per change31, plus the Odoo.sh staging branches feature which lets you fork production and roll back at the database level. Neither is a one-click reversal — both depend on having set them up before the import.

The real rollback strategy remains: take a full PostgreSQL backup via /web/database/manager (pg_dump -Fc plus the filestore directory) before the import starts, stamp every imported row with a custom import_batch_id Char field, and if catastrophe strikes, archive-by-batch and re-import from the cleaned source.

Cutover sequencing: (1) source goes read-only and the team is notified; (2) final delta export captures everything that changed during the test-import window; (3) delta is imported with the same external-ID namespace; (4) reconciliation runs; (5) users get login access and a 48-hour hyper-care window with the migration lead on call; (6) source decommission is scheduled for 30 to 90 days out, never the same day.

Migration partners and tools

Official partners, OCA modules, iPaaS connectors, specialist migration shops — what each is good for and how to choose.

Odoo S.A. runs a tiered partner programme — Gold, Silver and Ready — based on certifications, customer count and recurring Enterprise revenue. For CRM migrations specifically, partners with explicit Salesforce-to-Odoo, Zoho-to-Odoo or Pipeline-CRM-to-Odoo practices tend to ship cleaner than generalist implementation shops21. The Odoo Community Association (OCA) maintains open-source modules — Audit Log, OpenUpgrade, fs_attachment, Data Cleaning OCA forks — that fill gaps left by the Enterprise feature set2331.

Synavos, Aspire Softserv, Silent Infotech, Iqra Technology, Softeko, Braincuber and ECOSIRE are commonly named in the migration corner of the market and each offers fixed-scope or hourly-rate migration packages alongside ongoing managed services39. Odoo S.A. also runs a paid upgrade service for Enterprise customers, which handles version-to-version schema migration but is not available to Community users — for Community, OpenUpgrade is the working alternative23.

On the ETL and iPaaS side, Fivetran, Airbyte and Stacksync ship Odoo connectors, and several Odoo Apps Store extensions (Import Bridge by Axis, base_import_async by OCA) add async-job patterns on top of the wizard.

Their role in a migration is rarely the migration itself — it is the staging layer that lands source data into a warehouse, the transformation layer that converts Selection values and resolves Many2one relations, and the ongoing-sync layer that takes over once the one-time migration is complete.

Managed-migration cost ranges vary widely. Hourly rates for Odoo professional services run $10–$150+ per hour depending on region and partner expertise. A clean Pipeline-CRM-to-Odoo move of under 25,000 contacts with no historical chatter and standard models only often lands in the $3,000–$10,000 range.

A Salesforce-to-Odoo project with opportunity history, Studio customisations, historical activities and Marketing-Automation decoupling typically runs $20,000–$150,000+, with the upper end driven by record count, custom-model complexity, historical-data depth, and the number of integrations that need rebuilding rather than re-pointed39.

Migration-platform tools that scope by record-count tier (free under 100 records, $149 under 5,000, $599 under 25,000, $2,499 under 500,000) sit at the lower end of the curve when the migration is simple and standard-object-only. The price climbs sharply once custom models, historical activities or chatter migration enter scope.

For teams that want to outsource the migration end-to-end, FlitStack specialises in Odoo CRM migrations and handles the external-ID design, Selection-key conversion, res.partner parent-child resolution, historical-data preservation and validation work described in Sections 5 and 7 of this guide. Pricing is fixed-fee, based on record count and source platform, with separate line items for custom models and historical chatter depth so the scope is transparent before signature.

This is one of several legitimate paths — the right choice for any given team depends on whether they want an Odoo Gold Partner, the paid Odoo upgrade service, an iPaaS-first approach, an OCA-and-OpenUpgrade route, or a specialist migration vendor. [Explore FlitStack →](/contact)

Odoo CRM migration checklist

An exhaustive 8-phase punch list for moving contacts, pipeline, activities, and attachments into Odoo CRM using its native import, ORM, and RPC paths. Typical timeline: 4–14 weeks.

0. Decide & Plan10 tasks
  • Decide and document the Odoo deployment target. Choose Odoo Online (SaaS, no custom modules), Odoo.sh (managed PostgreSQL + staging branches), or on-premise (full control). Each path has different access to filestore, database manager, and shell.If skipped: Picking Odoo Online and then discovering you need server-side scripts forces a re-platform mid-project.
  • Decide between Community and Enterprise edition. Community is free but excludes Studio, the Documents app, and several Enterprise-only mail features. Confirm which crm.* and mail.* features the target workflow depends on before purchase.If skipped: Restoring an Enterprise database into a Community container marks Enterprise modules as 'not installable, skipped' and breaks views that reference them.
  • Pin the exact Odoo major version for the cutover. Pin Odoo 17, 18, or 19 before mapping. View XML, model names, and Selection options shift between majors (e.g. <tree> → <list> in 18).If skipped: Mapping against the wrong major produces import files that reference fields renamed in the target version.
  • Define migration scope by Odoo model. List the in-scope models explicitly: res.partner (contacts and companies), crm.lead, crm.team, crm.stage, crm.tag, mail.activity, mail.message, ir.attachment, res.users. Mark each as in or out of scope.
  • Define the historical-data window. Decide how far back leads, opportunities, activities, and messages migrate. Decide whether closed/lost opportunities older than the window stay in the legacy system as a read-only archive.
  • Identify legal, residency, and retention constraints. Confirm the chosen Odoo hosting region (EU vs US vs APAC for Odoo Online) matches data-residency obligations. Document GDPR data-subject access and erasure procedures against res.partner and mail.message.If skipped: Discovering a residency conflict after go-live forces a database export, region re-provision, and re-import.
  • Assign a single Directly Responsible Individual for the migration. Name one accountable owner with authority to cut scope. Capture them in the project charter alongside the executive sponsor.
  • Set the cutover window and source-system freeze date. Pick the cutover datetime in the destination timezone and the source-side freeze instant. Communicate both to all source users at least two weeks in advance.
  • Document the migration success criteria. Write the falsifiable conditions: record counts match within an agreed tolerance, total open pipeline value matches, sampled records reconcile field-by-field, sign-off owners named.If skipped: Without explicit success criteria the project never formally closes and stretches indefinitely.
  • List explicit out-of-scope items. Capture items intentionally excluded (e.g. archived chat threads older than N years, legacy custom modules, deprecated picklists). Out-of-scope items become scope creep without this list.
1. Pre-Migration Prep23 tasks
  • Export current record counts per source object as a baseline. Capture row counts for contacts, companies, leads, opportunities, activities, notes, and files. Date-stamp the snapshot.If skipped: Without a baseline count you cannot prove completeness after cutover.
  • Run deduplication on source contacts using email as the match key. Resolve flagged duplicates manually; keep a merge audit log mapping merged-from IDs to surviving IDs. Email is the most reliable cross-system contact match key.If skipped: Duplicates carried into res.partner inflate counts and split activity history across two records that never get re-merged.
  • Standardize email casing to lowercase across all source contacts. Odoo treats res.partner.email case-insensitively for lookups but stores what you provide; mixed casing breaks downstream upserts keyed on email.
  • Normalize phone numbers to E.164 format. Odoo's phone widget formats on display but stores the raw value. Pre-normalize to '+<country><number>' so search and bulk send work consistently.
  • Standardize country and state values to ISO-3166 codes. res.country expects an ISO code (e.g. 'US', 'DE') for import. Convert source 'United States', 'USA', 'us' to a single 'US' value before transform.If skipped: Mismatched country strings either fail the import row or silently leave country blank.
  • Identify and resolve records missing required fields. crm.lead requires name. res.partner requires name. mail.activity requires res_id and res_model. Surface and fix any source records that would fail these constraints.
  • Archive obsolete and orphaned source records. Records you do not intend to migrate (test leads, cancelled deals older than retention) should be archived on the source so they cannot accidentally export.
  • Inventory source custom fields with type and picklist options. List every non-standard field on the source with its type, allowed values, required flag, and which records use it. This becomes the input to Phase 1b destination field creation.If skipped: Skipping the inventory means custom fields are discovered piecemeal during transform and re-mapping costs days.
  • Provision the production Odoo database. On Odoo Online create the production database via the customer portal. On Odoo.sh create the production branch. On-premise install the matching Odoo version and create the production database via the database manager.
  • Provision a separate sandbox database as a duplicate of production config. On Odoo.sh use a staging branch. On Odoo Online use the 'Duplicate Database' option in the database manager. On-premise restore a fresh blank database with the same module set.If skipped: Skipping the sandbox forces every test against production and contaminates real data with test rows.
  • Install the CRM app and its dependencies. Settings → Apps → install 'CRM'. This pulls in crm.lead, crm.team, crm.stage, crm.tag, and the mail thread mixins required for mail.activity and mail.message.
  • Configure org-level settings before any import. Set company timezone, default currency, language, fiscal year, and country on res.company. These affect how dates, numbers, and selection labels are interpreted by base_import.import.If skipped: Changing the company timezone after import shifts every imported datetime by the offset delta and corrupts activity due-dates.
  • Create res.users for every salesperson and admin who needs access. Create each user with the correct access rights (Sales / User: All Documents vs Own Documents, Settings → Administration). Capture each user's login email — this becomes the salesperson lookup key during import.
  • Configure crm.team records for every sales team in scope. Set team leader, members, alias_name (if email-to-lead is used), and default stage. Teams must exist before crm.lead rows can reference them.If skipped: Importing leads with a missing team_id reference sets every lead to the default team and breaks pipeline-by-team reporting.
  • Configure crm.stage records to match the migrated pipeline shape. Create one crm.stage per stage that will exist post-migration. Set sequence, is_won, fold, and team_ids per stage. Decide whether stages are global or per-team before creating them.If skipped: Mapping source stages to a stage that does not yet exist drops every affected lead to the default 'New' stage and erases pipeline position.
  • Create custom fields on crm.lead and res.partner before import. Use Studio (Enterprise) or developer-mode → Settings → Technical → Fields (Community) to create each custom field with the correct ttype, selection options, and required flag. Importing into a field that does not yet exist silently drops the column.If skipped: Discovering a missing custom field after a 50k-row load forces a transform, file re-build, and re-import.
  • Create crm.tag records used by source leads. Tags must be pre-created or the importer will create new tags with the exact source casing on every import run, fracturing what should be a single tag.
  • Configure mail aliases and incoming mail servers paused. Set up the mail.alias used for email-to-lead but leave the incoming server fetcher disabled until cutover, so test imports do not race against live inbound mail.
  • Set ir.attachment storage location and confirm the per-file cap. Odoo's default per-attachment cap is 128 MiB. For larger files, configure the attachment store on the filesystem (on-prem/Odoo.sh) and update the limit via ir.config_parameter before bulk file load.If skipped: Files over the cap fail silently in batch imports and leave records with broken references.
  • Configure the dedicated migration user account. Create a dedicated user (e.g. 'migration_bot') with admin rights. All bulk writes during load use this account so the audit trail attributes writes correctly.
  • Communicate the source-system freeze window to all users. Send the freeze datetime, the cutover datetime, and the read-only date for the source. State explicitly what they can and cannot do during the freeze.
  • Schedule end-user training on Odoo CRM basics. Run a session covering pipeline (kanban), lead vs opportunity, the chatter (mail.thread), and activities (mail.activity). Record it so post-cutover hires have access.
  • Designate first-responder support for the first 72 hours post-cutover. Name two to three people on call. Publish the escalation contact and the channel (chat, ticketing system) where users report issues.If skipped: Without a named responder, the inevitable cutover-day questions land in random inboxes and frustrate users.
2. Source Export12 tasks
  • Export all source contacts to CSV with every standard and custom field. Include the source's primary key (record ID) as a column — this becomes the basis for the Odoo external ID used in upserts.If skipped: Forgetting the source ID column makes idempotent re-runs impossible and forces full re-imports.
  • Export all source companies/accounts to CSV. Companies map to res.partner with is_company=True. Capture parent-child structure and any company-level custom fields.
  • Export all leads/opportunities to CSV. Include current stage, owner, expected revenue, close date, probability, and the source contact/company IDs to preserve relationships.
  • Export pipeline / stage definitions from source. Capture every stage name, order, and is-closed/is-won attribute. This is the input to the crm.stage mapping table built in Phase 3.
  • Export activities, calls, and tasks as a separate file. These map to mail.activity. Include activity type, due date, assignee, related record id and type, summary, and completion status.
  • Export notes and message history as a separate file. Notes and emails map to mail.message. Capture author, date, body (HTML), related record id and type, message subtype, and any attachment references.If skipped: Mixing activities and messages into one file makes the post-import audit trail impossible to reconstruct.
  • Export file attachments as binaries plus a metadata manifest. Download every file. Produce a manifest CSV with: source attachment ID, original filename, MIME type, file size, related record type, related record ID, uploader email.If skipped: Files without a manifest cannot be re-linked to their parent records and become orphaned uploads.
  • Export the source user list with roles and reporting structure. User → email mapping drives the salesperson lookup and the ownership assignment in Phase 3.
  • Export contact-to-company associations as a separate junction file. If the source allows multi-company contacts or many-to-many tags, export the junction table directly so the relationship survives transform.
  • Capture screenshots and config exports of source automations and reports. Source workflows, dashboards, and reports do not transfer. Document them so they can be rebuilt manually in Odoo post-cutover.
  • Record the exact timestamp of every export. The delta between export-time and cutover-time becomes the source of changes you must re-pull at cutover. Date-stamp every file in its filename.If skipped: Without an export timestamp you cannot compute the delta and risk losing every change made between export and cutover.
  • Hash each exported file and store the hash with the export. SHA-256 of each CSV and binary. The hash proves you imported the exact bytes you exported during validation.
3. Transform & Map28 tasks
  • Build a master field-mapping spreadsheet keyed on Odoo model. One sheet per Odoo model (res.partner, crm.lead, crm.team, crm.stage, crm.tag, mail.activity, mail.message, ir.attachment). For each row capture: source field, destination field (use Odoo's technical name, not the label), transform rule, required flag, default-when-null.If skipped: A mapping kept in heads or chat threads cannot be audited and produces inconsistent transforms across re-runs.
  • Pick the upsert/external-ID key for each model. External ID convention: '__export__.<source_system>_<record_id>' (e.g. '__export__.salesforce_0035i00000abc'). Add an 'id' column to every CSV containing this external ID — base_import.import uses it to upsert.If skipped: Without external IDs, re-running the importer creates duplicate records instead of updating the existing ones.
  • Decide handling for source fields with no Odoo equivalent. Per field decide: drop, concatenate into the chatter as an initial mail.message, or create a custom field via Studio (Enterprise) or developer mode (Community).
  • Decide handling for users present on the source but not in Odoo. Map orphaned ownership to a single 'migration_bot' res.users, or to the user's manager, or set user_id blank. Document the rule and apply it consistently.
  • Convert dates and datetimes to ISO-8601 in the company timezone. Odoo's import wizard parses ISO-8601 reliably; ambiguous DD/MM vs MM/DD formats are guessed and frequently wrong. Force every date to YYYY-MM-DD and every datetime to YYYY-MM-DD HH:MM:SS.If skipped: Day-month inversion on dates produces silently-wrong close_date values that misreport entire quarters.
  • Normalize currency amounts to plain decimals with a period separator. Strip thousand separators and currency symbols. Odoo's Float field accepts '1234.56' not '1,234.56 €'. Capture currency code in a separate currency_id column.
  • Re-encode every text field as UTF-8 without BOM. base_import.import expects UTF-8. Latin-1 or Windows-1252 inputs corrupt accented characters and emoji.If skipped: Encoding mismatches surface as mojibake on contact names that have to be reimported per row.
  • Escape commas, quotes, and newlines in CSV text fields. Wrap any field containing a comma, quote, or newline in double quotes and escape embedded quotes by doubling them. Verify by opening the CSV in a strict parser, not Excel.If skipped: Unescaped newlines in note bodies split one row into two and shift every subsequent column.
  • Truncate source fields that exceed Odoo's column length. res.partner.name is sized but lead.name is unbounded text — others (street, city) do have limits. Truncate to fit and append a flag column if truncation lost content.
  • Convert booleans to True/False strings. Odoo's CSV importer accepts True/False, 1/0, and the explicit values listed in selection fields. Pick one form and stick with it across every file.
  • Replace empty strings with explicit blanks for nullable fields. Some Odoo field types (especially Many2one) treat empty string differently from null. Use the literal empty cell for nullable Many2one relations, not a quoted empty string.
  • Resolve Many2one references using external IDs, not IDs. For every Many2one column (partner_id, user_id, team_id, stage_id, etc.) populate the '<field>/id' column with the target's external ID. This survives database recreation; raw IDs do not.If skipped: Loading raw integer IDs into Many2one columns ties imports to a specific database instance and breaks if you ever rebuild or migrate again.
  • Resolve Many2many references using comma-separated external IDs. For tag_ids and similar Many2many fields, populate '<field>/id' with comma-separated external IDs. Pre-create every referenced tag in Phase 1b.
  • Decide the historical-timestamp strategy for created_date. Odoo only lets you set the 'create_date' field on import with elevated programmatic writes. Decide: (a) preserve original via direct write, or (b) write to a custom field 'x_legacy_created_date' and let Odoo stamp the migration date as create_date.If skipped: Failing to preserve historical timestamps makes age-based pipeline reporting (e.g. 'leads older than 30 days') wrong for the first month post-cutover.
  • Decide the record-ownership strategy. Map source owner email → Odoo user_id. For unknown owners pick a single fallback: the migration_bot user, the team leader, or blank. Document and apply uniformly.
  • Decide the file-attachment strategy. Choose: re-upload binaries into ir.attachment (preserves offline access, hits the 128 MiB cap and storage cost), or keep files in external storage and create ir.attachment rows with type='url' pointing to them.
  • Decide load order to satisfy Odoo's foreign-key constraints. Required order: res.users → crm.team → crm.stage → crm.tag → res.partner (parent companies first, then child contacts) → crm.lead → mail.activity → mail.message → ir.attachment. Violating this order produces ondelete=restrict failures.If skipped: Loading crm.lead before res.partner causes every partner_id reference to fail and every lead to import with a null contact.
  • Build the crm.stage mapping table. For each source pipeline stage map to a target crm.stage external ID. If multiple source stages collapse into one Odoo stage, document the collapse rule. Capture is_won and fold per target stage.If skipped: An unmapped source stage drops every lead in that stage to Odoo's default 'New' stage, erasing forecast position.
  • Resolve Selection field internal keys versus display labels. Odoo Selection fields store the internal key (e.g. 'won', 'lost') but display the label (e.g. 'Won', 'Lost'). The importer accepts either, but mixing the two within one column fails non-deterministically. Always export and import the internal key.If skipped: Importing the human-readable label when the field's internal key differs causes the row to fail silently for that column and leave a null value.
  • Re-derive or null out lead-scoring fields. Odoo's predictive lead scoring (Enterprise) computes scores from the historical conversion data inside Odoo. Source scores are not portable. Either null out the score column or migrate it to a custom field 'x_legacy_score' for reference.
  • Map mail.activity types to existing mail.activity.type records. Pre-create or reuse Odoo's mail.activity.type records (Call, Email, Meeting, To-Do). Map every source activity type to one of these via external ID. Custom activity types must be created in Phase 1b.
  • Reassemble mail.message threading using parent_id. mail.message has parent_id for reply chains and message_id / in_reply_to header values for email threading. Preserve the source reply chain by populating parent_id with the parent message's external ID.If skipped: Without parent_id, the chatter shows a flat list of unrelated messages instead of conversation threads.
  • Re-stamp mail.message author_id to a valid res.partner. mail.message requires either author_id (res.partner) or email_from. Map every source author to a res.partner external ID; for unknown authors use the migration_bot partner.
  • Convert note bodies to sanitized HTML. mail.message.body is HTML. Strip script tags, normalize <br>, and confirm UTF-8 encoding. Plain-text notes must be wrapped in <p>…</p>.
  • Map lost reasons to crm.lost.reason records. Pre-create the lost reasons in Phase 1b and map source 'lost reason' values to the corresponding crm.lost.reason external ID. Unmapped reasons cannot be imported on lost opportunities.
  • Resolve multi-company partitioning. If multiple res.company records exist, set company_id explicitly on every model that has it (crm.lead, res.partner, mail.activity). Leaving it blank assigns to the importing user's default company.If skipped: Misallocated company_id values make records invisible to users in the correct company and trigger record-rule access errors.
  • Build the contact-to-company link via parent_id. Individual contacts (is_company=False) reference their company via parent_id pointing to the company's res.partner external ID. Load companies first, then contacts.
  • Decide handling for source merged-lead records. Source systems often have 'merged' or 'converted' records that no longer represent live data. Decide: skip them, import as archived (active=False), or capture as mail.message on the surviving record.
4. Sandbox Test Migration14 tasks
  • Refresh the sandbox database from the latest production config. Use the Odoo database manager 'Duplicate Database' or, on Odoo.sh, rebuild the staging branch from production. Confirm modules, users, and crm.stage records match.
  • Load a representative 1–5% sample of each model into the sandbox. Use Settings → Apps → 'Import' or the model's list view → Favorites → Import records. Upload the sample CSV and verify the matching screen recognizes every column.If skipped: Loading the full file first burns hours debugging issues a 1% sample would have caught in minutes.
  • Validate field-by-field on 10 random sandbox records per model. Open each in the form view and compare every field value to the source. Pay extra attention to Selection fields, dates, and Many2one references.If skipped: Bulk count matches can mask field-level corruption that only field-by-field comparison surfaces.
  • Test long-string, special-character, and emoji cases explicitly. Include in the sample at least one record per model with: a 4000-character body, embedded commas and quotes, an emoji in the name, and a CJK-character note.If skipped: These edge cases surface encoding and escaping bugs that only fail on the rows your data actually contains.
  • Test NULL handling for every nullable field. Include sample rows where every nullable field is blank. Confirm Odoo accepts the blank without substituting a default or zero.
  • Test parent-child relationship import (res.partner parent_id). Load companies first, then contacts. Open a contact and confirm the 'Company' field is populated and clicking through opens the company record.
  • Test Many2many tag assignment. Load a lead with two tags via comma-separated external IDs. Confirm both tags appear on the lead and clicking the tag filters the pipeline correctly.
  • Test the chatter import on a sample of leads. Open a lead with imported mail.activity and mail.message records. Confirm activities appear in the activity widget with the right due date, and messages appear in the chatter with author, body, and timestamp intact.If skipped: Chatter that imports without author or timestamp is functionally useless and forces a re-load of every message.
  • Test attachment download from imported ir.attachment records. Open a sample of records with attachments. Click each file and confirm it downloads with the correct content and filename.
  • Run a full-volume test if sandbox capacity permits. If the sandbox can hold the full volume, run the entire import end-to-end. Time each model's load step. Extrapolate to production cutover budget.If skipped: Skipping a full-volume rehearsal means cutover-day surprises around throughput ceilings and timeout behavior.
  • Measure write throughput against your hosting tier. On Odoo Online expect tenant-level throttling on bulk writes. Plan batch sizes (50–200 records per call) accordingly and add backoff on throttle responses.If skipped: Aggressive parallel writes against Odoo Online trip platform throttling and stall the load mid-batch.
  • Have a sales-ops domain expert spot-check 25 sandbox leads. Pick records they recognize. Ask them to flag anything that 'looks wrong'. Their tacit knowledge surfaces issues no checklist catches.
  • Re-run the import idempotently to confirm upsert behavior. Run the same file again. Row counts should remain identical, not double. If counts double, the external-ID column is missing or wrong.If skipped: Non-idempotent imports compound every retry into duplicate records and force a destructive cleanup.
  • Capture sandbox sign-off in writing before proceeding to Phase 5. Migration sponsor, sales-ops lead, and IT confirm the sandbox passes. Without this gate the production cutover cannot start.
5. Production Cutover15 tasks
  • Confirm freeze on the source system. Verify with the source system audit log that no writes have occurred in the last 60 minutes. Lock down user permissions on the source if possible.If skipped: Late source writes that arrive after the final export become silent data loss.
  • Take the final delta export from the source. Re-export every in-scope object, capturing only records modified since the Phase 2 baseline timestamp. Hash the export files.
  • Disable Odoo automated actions and email outgoing during the load. Settings → Technical → Automation → Automated Actions: pause any rule that triggers on crm.lead or res.partner create/write. Disable the outgoing mail server temporarily to avoid email storms during mail.message load.If skipped: Active automations during bulk load fire thousands of redundant notifications and inflate the activity log.
  • Take a pre-load backup of the destination database. Database manager → backup, or on Odoo.sh use the auto-snapshot before deploy. Confirm the backup downloads and is restorable to a scratch database.
  • Load res.users first. Upsert users by login email. Confirm row counts match the user export.
  • Load crm.team, crm.stage, crm.tag, and crm.lost.reason. Configuration records before transactional records. These should already exist from Phase 1b; this step idempotently confirms.
  • Load res.partner companies (is_company=True). Use base_import.import with the company CSV. Use external IDs for upsert. Capture the import job ID and error log.
  • Load res.partner contacts (is_company=False) with parent_id set. Contacts after companies so parent_id Many2one resolves. Verify the post-load count.
  • Load crm.lead. Leads after contacts and stages so partner_id, user_id, team_id, and stage_id all resolve. Use the external-ID upsert mode.
  • Load mail.activity attached to crm.lead and res.partner. Activities reference res_model and res_id. The res_id is the destination integer ID — resolve it from the loaded external IDs at runtime, not from the source IDs.If skipped: Hard-coding source IDs into res_id leaves every activity pointing at a non-existent or unrelated record.
  • Load mail.message threaded by parent_id. Load in parent-before-child order so parent_id references resolve. Use a programmatic write rather than base_import for mail.message — it requires fields the CSV importer does not expose.
  • Load ir.attachment binaries last. Stream binaries via the create() ORM call with base64-encoded datas, res_model, and res_id. Throttle to your hosting tier's throughput ceiling. Confirm one sampled file downloads correctly mid-load.If skipped: Pushing attachments above 128 MiB or above the throughput ceiling causes silent failures that orphan the parent record.
  • Cross-check destination row counts against source at each step. After every model's load, run a search_count and compare to the export's row count. Investigate any delta before proceeding to the next model.If skipped: Cascading row-count drift across models compounds and becomes unprovable later.
  • On any partial-load failure, stop, diagnose, and re-run idempotently. Do not push through with partial data. The external-ID upsert key makes safe re-runs possible — use it.
  • Re-enable automated actions and outgoing mail after all loads complete. Restore the automation rules and outgoing mail server. Run one end-to-end create-lead test to confirm automations fire as expected.
6. Validate16 tasks
  • Compare total record count per model between source and Odoo. Pull search_count from Odoo for res.partner (companies + contacts), crm.lead, mail.activity, mail.message, ir.attachment. Compare each to the export's row count. Investigate any delta.If skipped: Skipping count reconciliation lets multi-thousand-row drops go unnoticed until users complain.
  • Reconcile total open pipeline value source vs Odoo. Sum crm.lead.expected_revenue where stage is not won/lost. Compare to the source's equivalent. Tolerance for currency-conversion rounding only.If skipped: Pipeline value mismatch is the single most-noticed cutover defect by sales leadership.
  • Reconcile open-pipeline count by stage. Group crm.lead by stage_id and compare each bucket to the source pipeline. Catches stage-mapping errors that the global total hides.
  • Cross-check 30–50 randomly sampled records field-by-field. Random sample across res.partner, crm.lead, and mail.activity. Compare every field including custom fields between source and Odoo.
  • Verify every custom field value migrated on a 25-record sample. Custom fields are the most common silent-drop category. Confirm Selection internal keys map to the right labels in the UI.
  • Verify parent-child relationships on a 25-contact sample. Confirm each sampled contact's parent_id points to the right company, and clicking through opens that company.
  • Verify activity-to-lead linkage on a 25-activity sample. Confirm mail.activity.res_id and res_model resolve to the expected crm.lead and the activity appears in that lead's activity widget.
  • Verify mail.message threading reconstructs correctly. Open a lead with multi-message history. Confirm replies thread under their parent in the chatter rather than appearing as a flat list.If skipped: Broken threading forces a re-load of mail.message after go-live and pollutes the chatter with duplicate ungrouped messages.
  • Verify attachment-to-record linkage on a 25-file sample. Open a sampled record, click each attachment, confirm the file downloads with the right content and is the right size.
  • Confirm the historical-timestamp strategy worked. If you preserved original create_date via direct write, confirm a sample of records shows the legacy timestamp. If you used a custom field, confirm that field is populated.
  • Run a GDPR / residency spot-check. Confirm the Odoo Online region (or Odoo.sh region, or on-prem host country) matches the documented residency requirement from Phase 0. Capture the region as evidence in the migration record.
  • Confirm record-rule access works for each role. Log in as a Salesperson with 'Own Documents Only' and a Salesperson with 'All Documents' and confirm each sees the expected subset of crm.lead.
  • Have 3–5 power users run their daily workflow in Odoo against migrated data. They should be able to open today's pipeline, log a call as a mail.activity, send an email from the chatter, and convert a lead to an opportunity. Document any friction.If skipped: Without UAT, the first day post-cutover surfaces issues that should have been caught before users got the keys.
  • Document every UAT issue and triage to fix-before-go-live or fix-after. Decide which issues block go-live and which can ship after. Capture in a tracked list with named owners and target dates.
  • Re-validate the issues fixed before go-live. Don't take 'we fixed it' on trust. Have the original UAT user re-test each must-fix issue.
  • Capture written sign-off from the migration sponsor and sales-ops lead. Sign-off names the date, the validated record counts, and the known-issue list ship-ready for Phase 7. File it with the migration record.If skipped: Verbal sign-off creates downstream disputes about what 'done' meant.
7. Post-Migration Cleanup11 tasks
  • Send go-live communication to all end users. Include Odoo login URL, password-reset instructions, the first-responder contact for issues, and a one-page 'how the new pipeline maps to the old one' cheat sheet.
  • Run role-segmented training sessions. Sales users (pipeline, chatter, activities), sales managers (forecast reports, team views), admins (Settings, Studio if Enterprise, user provisioning). Record each session.
  • Set the source system to read-only. Strip write permissions for all users. Communicate the read-only date in writing. Keep read access during the post-migration safety window.
  • Rebuild reports and dashboards inside Odoo. Source reports do not transfer. Use Odoo's pivot, graph, and list views with saved Favorites. Enterprise users can also build dashboards via the Spreadsheet app.If skipped: Sales leadership without their reports stops trusting the migrated data even when it is correct.
  • Rebuild source automations as Odoo automated actions. Settings → Technical → Automation → Automated Actions for trigger-based rules. Settings → Technical → Server Actions for code-based logic. Test each rule before enabling.
  • Re-establish integrations to other systems. Calendar sync (Google/Outlook), email integration, marketing platform feeds, BI tools. Use a steady-state service account, not the migration_bot.
  • Disable the migration_bot user or rotate its credentials. The bulk-load credentials are no longer needed and represent an oversized access surface. Disable the user or rotate the credentials to lock it out of routine use.If skipped: Active migration-tier credentials become the path of least resistance for accidental or malicious bulk writes.
  • Schedule the 30-day post-migration retrospective. Capture what went well, what didn't, what would change. File the notes with the migration record so the next migration starts ahead.
  • Document the source-system decommission date. Typically 90 days after cutover, after the final retention/audit window. Capture in the migration record with the named approver.
  • Archive the source-system exports to long-term storage. Encrypted cold storage retains the Phase 2 and Phase 5 deltas for the documented retention window. Capture the storage location and access process.
  • Close the migration project formally. Final status report, lessons-learned document, project closure note. Reassign the DRI back to their regular role.

Questions, answered

Migrating to Odoo CRM: questions

How long does migration to Odoo CRM take?

A small-business migration with under 5,000 contacts and standard models runs one to two business days end-to-end. A mid-market project with custom models, historical activities and Studio rebuilds runs two to four weeks of elapsed time, including preparation, staging dry runs, validation, training and a 48-hour hyper-care window.

Can I migrate from Salesforce to Odoo CRM?

Yes — Salesforce-to-Odoo is one of the most common shapes. Standard objects map cleanly into res.partner and crm.lead, but Apex triggers, Flows, Process Builder and Reports do not transfer and need to be rebuilt as Odoo Automated Actions and Studio reports. Plan for Selection-key conversion and user-ID mapping.

Can I migrate from Zoho or Pipedrive to Odoo CRM?

Yes, and these are usually cleaner shapes because the object models align with crm.lead and res.partner one-to-one — leads, contacts, organisations, deals, activities and notes correspond directly. Watch Selection-field casing, normalise dates to ISO-8601, and rebuild Zoho or Pipedrive workflows as Odoo Automated Actions from scratch.

Does Odoo CRM preserve original timestamps on import?

No. create_date, write_date, create_uid and write_uid are ORM-managed and stamp to upload time, not the source record's date. To preserve audit history, add custom legacy_create_date and legacy_write_date Datetime fields to each imported model, populate from the source export, and point all historical reports at the legacy fields.

What's the difference between using the UI wizard and programmatic loads for Odoo?

The base_import UI wizard accepts CSV and XLSX, auto-maps columns, and is best for one-shot loads under 100,000 records with a visual Test pass before commit. Programmatic loads handle larger volumes, custom models and repeatable migrations but respect a roughly one-request-per-second ceiling on Odoo Online.

Can I migrate custom models or fields to Odoo CRM?

Yes — define the custom model in a Python module (Community) or via Studio (Enterprise), install it in the destination database, and import records of that type using the same external-ID upsert pattern. Studio writes to ir.model and ir.model.fields, so Community admins can edit the same metadata via Developer Mode.

What happens to lead history and pipeline stages during migration?

Recreate every crm.team and crm.stage in Odoo before importing leads — rows referencing a non-existent stage_id silently fall to the default stage. Stage transition history is not auto-preserved; if you need it for reporting, export stage-change timestamps from the source and store them in custom Datetime fields like stage_entered_date.

Is there an undo or rollback for Odoo imports?

There is no native bulk-undo. The OCA Audit Log module captures old/new values per change when configured in advance; Odoo.sh staging branches let you fork and restore. The standard fallback is a full PostgreSQL backup before import, plus an import_batch_id stamp on every imported row for batch archival.

Sources

  1. Odoo — Wikipedia
  2. Best Zoho CRM Alternatives for Custom Development and Flexibility — r/CRMSoftware
  3. Migrating from Odoo.sh (Enterprise) to Self hosted (Community) — r/Odoo
  4. Export and import data — Odoo 19.0 documentation
  5. Import products — Odoo 19.0 documentation
  6. Odoo Online programmatic throughput limits — Odoo Forum
  7. ORM reference — Odoo 19.0 documentation
  8. Odoo CRM application reference — Odoo 19.0 documentation
  9. Managing Parent-Child Relationships Between Partners in Odoo — Odoo Forum
  10. Data Cleaning — Odoo 19.0 documentation
  11. Datetime field reference — Odoo 19.0 documentation
  12. Upload size limit in Odoo — Odoo Forum (128 MiB cap)
  13. what is ondelete='cascade' in OpenERP — Odoo Forum
  14. Fields and widgets — Odoo 19.0 documentation (Studio)
  15. Configure Salesperson groups for own-documents access in Odoo 18 — Odoo Forum
  16. Manufacturing Company Migrating from Salesforce to Odoo — Odoo Experience 2025
  17. External transports for programmatic loads — Odoo documentation
  18. Crowdfunding OpenUpgrade for Odoo Community 19.0 — r/Odoo (OCA)
  19. Activities — Odoo 19.0 documentation
  20. Communication in Odoo by email — Odoo 19.0 documentation
  21. Migrate history CRM — Odoo Forum
  22. Import file and retain file date — Odoo Forum (create_date is upload time)
  23. Image file types supported in Odoo — Odoo Forum
  24. Base Attachment Object Store (fs_attachment) — Odoo Apps Store
  25. OCA Audit Log — The Odoo Community Association
  26. Outlook Calendar synchronization — Odoo 19.0 documentation
  27. Cannot import date field — Odoo Forum
  28. User and unicode character error — Odoo Forum
  29. unsupported format character on import — Odoo Forum
  30. Error when importing sample data — Odoo Forum (ondelete restrict)
  31. General Data Protection Regulation (GDPR) — Odoo
  32. What Does Odoo Migration Really Cost? Pricing Breakdown — Aspire Softserv

Get a quote

Moving to Odoo CRM?

Tell us where your data lives today and roughly how much there is. We scope the migration and the Odoo CRM setup with you, then send a quote.

Get a quote