---
title: "Migrate to Odoo CRM: CRM Migration Guide & Service"
description: "Migrating to Odoo CRM? Import limits, the full migration checklist and every source FlitStack AI moves into Odoo CRM, with history and rollback."
url: "https://flitstack.ai/migrations/crm/odoo-crm"
---

# 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.

![](https://flitstack.ai/images/authors/aditya-kumar.webp)By [Aditya Kumar](https://flitstack.ai/about/aditya-kumar) Updated November 5, 2026

[Get a quote ](https://flitstack.ai/contact) [Odoo implementation service →](https://flitstack.ai/services/odoo-implementation)

![](https://flitstack.ai/images/illustrations/pair-stage.webp)

From Any source ![](https://flitstack.ai/platforms-trim/zoho-crm.webp) ![](https://flitstack.ai/platforms-trim/salesforce-sales-cloud.webp) ![](https://flitstack.ai/platforms-trim/pipedrive.webp)

Destination Odoo CRM ![](https://flitstack.ai/platforms-trim/odoo-crm.webp)

Zoho CRM Salesforce Pipedrive HubSpot Jonas Enterprise Service & Construction Software

850+ sources mapped into Odoo CRM

## Systems we move into Odoo CRM

The CRMs teams most often move from. Each page shows what moves, the field mapping and what to watch for.

[Zoho CRM to Odoo CRM](https://flitstack.ai/migrations/crm/zoho-crm/to/odoo-crm) [Salesforce to Odoo CRM](https://flitstack.ai/migrations/crm/salesforce-sales-cloud/to/odoo-crm) [Pipedrive to Odoo CRM](https://flitstack.ai/migrations/crm/pipedrive/to/odoo-crm) [HubSpot to Odoo CRM](https://flitstack.ai/migrations/crm/hubspot/to/odoo-crm) [Jonas Enterprise Service & Construction Software to Odoo CRM](https://flitstack.ai/migrations/crm/jonas-enterprise-service-construction-software/to/odoo-crm) [Mailchimp to Odoo CRM](https://flitstack.ai/migrations/crm/mailchimp/to/odoo-crm) [SuiteCRM to Odoo CRM](https://flitstack.ai/migrations/crm/suitecrm/to/odoo-crm) [Zendesk Sell to Odoo CRM](https://flitstack.ai/migrations/crm/zendesk-sell/to/odoo-crm) [Act! to Odoo CRM](https://flitstack.ai/migrations/crm/act/to/odoo-crm) [MyCase to Odoo CRM](https://flitstack.ai/migrations/crm/mycase/to/odoo-crm) [Dynamics 365 to Odoo CRM](https://flitstack.ai/migrations/crm/dynamics-365-sales/to/odoo-crm) [![](https://flitstack.ai/platforms-trim/flowlu.webp) Flowlu to Odoo CRM](https://flitstack.ai/migrations/crm/flowlu/to/odoo-crm) [Attio to Odoo CRM](https://flitstack.ai/migrations/crm/attio/to/odoo-crm) [![](https://flitstack.ai/platforms-trim/bitrix24.webp) Bitrix24 to Odoo CRM](https://flitstack.ai/migrations/crm/bitrix24/to/odoo-crm) [Aweber to Odoo CRM](https://flitstack.ai/migrations/crm/aweber/to/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 only** XML-RPC with session authentication; API key available on Enterprise plans

**Rate limits** Not publicly documented; no published rate limit found in Odoo's official developer documentation

| Object                                 | Support | Note                                                                                                                                                                                                                                                                                                                                                                                  |
| -------------------------------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Contacts / Partners                    | full    | Contacts 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.                                                                                          |
| Leads                                  | full    | Leads (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.                                        |
| Opportunities                          | full    | Opportunities 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 Stages                        | full    | Stages 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 Teams                            | full    | Sales 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 / Tasks                     | mapped  | Activities (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) | mapped  | Custom 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.                                                                                |
| Attachments                            | mapped  | Attachments (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.     |
| Tags                                   | full    | Tags (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 Rules                     | none    | Odoo'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)      | none    | CRM 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 Orders               | mapped  | Quotations (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, Belgium[1](https://flitstack.ai/migrations/crm/odoo-crm#source-1). 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 alternative[3](https://flitstack.ai/migrations/crm/odoo-crm#source-3).

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 Community[4](https://flitstack.ai/migrations/crm/odoo-crm#source-4).

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 records[5](https://flitstack.ai/migrations/crm/odoo-crm#source-5) [6](https://flitstack.ai/migrations/crm/odoo-crm#source-6). 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 container[4](https://flitstack.ai/migrations/crm/odoo-crm#source-4). 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 expectations[8](https://flitstack.ai/migrations/crm/odoo-crm#source-8).

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 PostgreSQL[9](https://flitstack.ai/migrations/crm/odoo-crm#source-9). 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 migration[10](https://flitstack.ai/migrations/crm/odoo-crm#source-10).

| Object                             | What it stores                                         | Required                                                | Tier                                 |
| ---------------------------------- | ------------------------------------------------------ | ------------------------------------------------------- | ------------------------------------ |
| res.partner                        | Master record for individuals and companies (Contacts) | name; is\_company flag distinguishes person vs company  | All editions                         |
| crm.lead                           | Leads and opportunities in the pipeline                | name (subject); type ('lead' or 'opportunity')          | All editions (CRM module)            |
| crm.team                           | Sales teams that own pipelines                         | name; member\_ids                                       | All editions                         |
| crm.stage                          | Pipeline stages (Qualified, Proposition, Won)          | name; sequence; team\_id (optional)                     | All editions                         |
| crm.tag                            | Free-form tags on leads/opportunities                  | name                                                    | All editions                         |
| mail.activity                      | Scheduled to-dos: calls, meetings, emails, tasks       | activity\_type\_id; res\_model; res\_id; date\_deadline | All editions                         |
| mail.message                       | Chatter messages, emails, internal notes per record    | model; res\_id; body; message\_type                     | All editions                         |
| calendar.event                     | Meetings synced with Outlook/Google                    | name; start; stop; user\_id                             | All editions; sync setup is per-user |
| product.product / product.template | Sellable items linked to quotes and orders             | name; type; list\_price                                 | All editions                         |
| sale.order / sale.order.line       | Quotations and confirmed sales orders                  | partner\_id; order line products and quantities         | Requires 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` itself[11](https://flitstack.ai/migrations/crm/odoo-crm#source-11).

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 creates[5](https://flitstack.ai/migrations/crm/odoo-crm#source-5).

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 number[12](https://flitstack.ai/migrations/crm/odoo-crm#source-12). Custom field types determine validation and storage; the catalogue below covers what you can model and the limits you need to plan around[9](https://flitstack.ai/migrations/crm/odoo-crm#source-9).

| Field type               | Limit                                                                                      | Notes                                                                                                          |
| ------------------------ | ------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------- |
| Char (single-line text)  | Default size=64, configurable                                                              | Maps to PostgreSQL varchar; trim before import                                                                 |
| Text (multi-line text)   | Unlimited (PostgreSQL TEXT)                                                                | Used for descriptions, internal notes                                                                          |
| Integer / Float          | INT4 / NUMERIC in PostgreSQL                                                               | Float defaults to digits=(16,2); override per field                                                            |
| Date / Datetime          | YYYY-MM-DD / YYYY-MM-DD HH:MM:SS in UTC                                                    | Datetime stored UTC; ISO-8601 strongly recommended[13](https://flitstack.ai/migrations/crm/odoo-crm#source-13) |
| Selection (picklist)     | Defined as Python tuple list                                                               | Internal key vs label; import expects the key[9](https://flitstack.ai/migrations/crm/odoo-crm#source-9)        |
| Many2one (foreign key)   | Single related record                                                                      | Resolves by name OR external ID — pick one and be consistent                                                   |
| One2many / Many2many     | Inverse / junction relations                                                               | Many2many uses comma-separated names on import                                                                 |
| Boolean                  | True/False/1/0                                                                             | Empty cells default to False on import                                                                         |
| Binary                   | 128 MiB default attachment cap[14](https://flitstack.ai/migrations/crm/odoo-crm#source-14) | Base64-encoded on programmatic load; large files belong in filestore                                           |
| Custom fields via Studio | Unlimited count, Enterprise-only UI                                                        | Community: 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 key[15](https://flitstack.ai/migrations/crm/odoo-crm#source-15). This is configured in `fields.py` per field, not at the database level you can flip from the UI.

**128 MiB** Default per-attachment size cap Hard ceiling on `ir.attachment` records via the UI on Odoo Online; cannot be raised on the hosted tier. Self-hosted instances override it in server config — but programmatic writes still reject large binaries unless the limit is patched first[14](https://flitstack.ai/migrations/crm/odoo-crm#source-14).

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.fields` [16](https://flitstack.ai/migrations/crm/odoo-crm#source-16). 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 after[12](https://flitstack.ai/migrations/crm/odoo-crm#source-12). 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 guesswork[13](https://flitstack.ai/migrations/crm/odoo-crm#source-13).
- 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 errors[9](https://flitstack.ai/migrations/crm/odoo-crm#source-9).
- 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 deterministic[5](https://flitstack.ai/migrations/crm/odoo-crm#source-5).
- 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 exist[20](https://flitstack.ai/migrations/crm/odoo-crm#source-20).
- 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 faster[21](https://flitstack.ai/migrations/crm/odoo-crm#source-21). 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 File[6](https://flitstack.ai/migrations/crm/odoo-crm#source-6). 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 out[5](https://flitstack.ai/migrations/crm/odoo-crm#source-5). 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 reliable[5](https://flitstack.ai/migrations/crm/odoo-crm#source-5). 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 UI[22](https://flitstack.ai/migrations/crm/odoo-crm#source-22). 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.

**\~1 req/sec** Odoo Online programmatic-load ceiling Practitioner-observed throughput limit on Odoo Online's programmatic surface. Self-hosted and Odoo.sh have softer ceilings but still throttle under sustained parallel load[8](https://flitstack.ai/migrations/crm/odoo-crm#source-8).

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 editions[23](https://flitstack.ai/migrations/crm/odoo-crm#source-23). For Odoo Enterprise upgrades, Odoo S.A.'s paid upgrade service handles the schema transformation but is not available to Community users.

Under 10,000 records on standard models → UI base\_import wizard. 10,000–100,000 → UI wizard in batched files. Over 100,000, any custom models, or any re-runnable load → XML-RPC / JSON-RPC with chunked load() calls and a back-off loop.

## 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)

| Source                                             | Destination                          | Note                                                                                                            |
| -------------------------------------------------- | ------------------------------------ | --------------------------------------------------------------------------------------------------------------- |
| external ID / source primary key                   | id (XML external ID column)          | The upsert key — re-running with the same id updates[5](https://flitstack.ai/migrations/crm/odoo-crm#source-5)  |
| first\_name + last\_name (person) or company\_name | name                                 | Concatenate for is\_company=False; use company name when is\_company=True                                       |
| is\_organisation flag                              | is\_company                          | Boolean — True for companies, False for individuals                                                             |
| email                                              | email                                | Lowercased; Data Cleaning app can dedup post-import[12](https://flitstack.ai/migrations/crm/odoo-crm#source-12) |
| phone / mobile                                     | phone / mobile                       | Normalise to E.164; both fields exist separately                                                                |
| parent\_account\_id                                | parent\_id (Many2one to res.partner) | Resolve via external ID; import companies first, then employees                                                 |
| vat\_number / tax\_id                              | vat                                  | Format-validated against country rules; strip on import if dirty                                                |
| country / state                                    | country\_id / state\_id              | Many2one — must match an existing res.country / res.country.state record                                        |
| language preference                                | lang                                 | Use 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 ID[11](https://flitstack.ai/migrations/crm/odoo-crm#source-11).

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.

| Source                            | Destination          | Note                                                                                                          |
| --------------------------------- | -------------------- | ------------------------------------------------------------------------------------------------------------- |
| opportunity\_name / lead\_subject | name                 | Required field — never null                                                                                   |
| stage / pipeline\_stage           | stage\_id            | Resolve to existing crm.stage via name or external ID                                                         |
| lead vs opportunity flag          | type                 | Selection: 'lead' or 'opportunity' — use the internal key                                                     |
| amount / expected\_revenue        | expected\_revenue    | Float; default precision (16,2); set company currency\_id                                                     |
| probability                       | probability          | Float 0–100; default driven by stage                                                                          |
| expected\_close\_date             | date\_deadline       | YYYY-MM-DD; ISO-8601 strongly recommended[13](https://flitstack.ai/migrations/crm/odoo-crm#source-13)         |
| owner / salesperson               | user\_id             | Many2one to res.users — pre-provision users first[20](https://flitstack.ai/migrations/crm/odoo-crm#source-20) |
| sales team                        | team\_id             | Many2one to crm.team — defaults from user if omitted                                                          |
| primary contact                   | partner\_id          | Many2one to res.partner; resolves via external ID                                                             |
| tags                              | tag\_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 service[23](https://flitstack.ai/migrations/crm/odoo-crm#source-23).

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](https://flitstack.ai/migrations/crm/odoo-crm#source-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 history[26](https://flitstack.ai/migrations/crm/odoo-crm#source-26).

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 correctly[27](https://flitstack.ai/migrations/crm/odoo-crm#source-27).

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 day[28](https://flitstack.ai/migrations/crm/odoo-crm#source-28). 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 configuration[14](https://flitstack.ai/migrations/crm/odoo-crm#source-14). Supported image formats include JPEG, PNG, GIF, BMP, TIFF, SVG, ICO, WEBP, PSD and EPS[29](https://flitstack.ai/migrations/crm/odoo-crm#source-29).

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 filesystem[30](https://flitstack.ai/migrations/crm/odoo-crm#source-30), 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 time[28](https://flitstack.ai/migrations/crm/odoo-crm#source-28). 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 routing[20](https://flitstack.ai/migrations/crm/odoo-crm#source-20).

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 change[31](https://flitstack.ai/migrations/crm/odoo-crm#source-31). 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 Workspace[32](https://flitstack.ai/migrations/crm/odoo-crm#source-32). 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.*

**high Enterprise modules silently disabled on a Community restore**

Restoring an Odoo.sh Enterprise database into a self-hosted Community container marks Enterprise-only modules — CRM Enterprise, Documents, Social, WhatsApp, Studio, Marketing Automation — as 'installed' but 'not installable, skipped'. The UI then crashes with errors like `View types not defined map found in act_window` and Studio customisations vanish from the form views[4](https://flitstack.ai/migrations/crm/odoo-crm#source-4). Before you switch hosting tiers, list every installed module via Settings → Apps → Installed and confirm each has a Community equivalent or a replacement plan.

**high Selection field label vs internal key mismatch**

Odoo Selection fields — `crm.lead.type`, `crm.lead.priority`, every custom dropdown — store an internal Python key distinct from the UI label. The label is `Opportunity`; the key is `opportunity`. The import wizard rejects label-only payloads with a vague `Unsupported format character` or silently coerces to a default. Build your transform layer against the model's `selection` tuple in code (Developer Mode → Settings → Technical → Fields), never against what an admin sees in the UI[9](https://flitstack.ai/migrations/crm/odoo-crm#source-9).

**high Programmatic throughput ceiling at \~1 request per second on Odoo Online**

Practitioners testing importers on Odoo 17 report the Odoo Online terms of use enforce a throughput ceiling of roughly one programmatic request per second[8](https://flitstack.ai/migrations/crm/odoo-crm#source-8). A migration loop tuned to dozens of parallel workers will throttle, retry, throttle and run for days instead of hours. Drop concurrency to a single worker on Odoo Online and rely on chunked `load()` calls of 100–500 rows; on Odoo.sh and self-hosted, scale parallelism against your server's worker count, not the public ceiling.

**high Date format auto-detect inverts day and month**

Odoo's importer auto-detects date columns but warns that day-month inversions like `01-03-2016` are ambiguous and may be guessed wrong[13](https://flitstack.ai/migrations/crm/odoo-crm#source-13). Worse, error messages from XLSX imports surface as `Column activity_ids/date_deadline contains incorrect values. Error in line 1: unconverted data remains: 2019-12-16` with no field-level hint about what went wrong[33](https://flitstack.ai/migrations/crm/odoo-crm#source-33). Always set the Date Format explicitly in the wizard's Formatting Options to ISO-8601 (`YYYY-MM-DD`), or convert to ISO before export.

**high create\_date cannot be overridden on import**

Odoo does not preserve the original record's creation date during import — `create_date`, `create_uid`, `write_date` and `write_uid` are ORM-managed and stamp to upload time and the import user[28](https://flitstack.ai/migrations/crm/odoo-crm#source-28). Teams discover this on day two when reports filtered by Created Date return everything stamped to import day. The mitigation is to create `legacy_create_date` and `legacy_write_date` custom Datetime fields on every imported model, populate them from the source export, and rewrite all historical-period reports to use the legacy fields.

**medium Many2one resolution by name fails on duplicates**

Many2one fields like `user_id`, `partner_id`, `country_id` can be imported by referencing the target record's `name` or its external ID. Name resolution is fragile: two users called Sales Manager, two countries called Korea, or a partner whose name has trailing whitespace will silently match the wrong record or none. Pick external ID resolution consistently — populate an `id` column on the lookup tables first, then use `field_name/id` in subsequent imports to resolve by the stable key[5](https://flitstack.ai/migrations/crm/odoo-crm#source-5).

**medium Unicode / non-ASCII characters break older importers**

Accented characters in usernames, French/German company names, or smart quotes pasted from Word can throw `UnicodeEncodeError` on Odoo 13 and earlier and `Unsupported format character '{' (0x7b)` in some templated import flows[34](https://flitstack.ai/migrations/crm/odoo-crm#source-34) [35](https://flitstack.ai/migrations/crm/odoo-crm#source-35). Save CSVs as UTF-8 with BOM, prefer XLSX where possible, and run a one-pass `unicodedata.normalize('NFC', value)` over text columns before export. Newer Odoo versions are far more tolerant but older Community installs still bite.

**medium ondelete=restrict blocks model deletion in dependency chains**

Relational fields in Odoo specify `ondelete='cascade'`, `'restrict'` or `'set null'` per field[15](https://flitstack.ai/migrations/crm/odoo-crm#source-15). If you import test data into a sandbox, then try to delete a parent record (a `res.partner` referenced by a `sale.order`), Odoo blocks the delete with `The operation cannot be completed: Another model is using the record you are trying to delete` [36](https://flitstack.ai/migrations/crm/odoo-crm#source-36). Plan archival, not deletion, for parent records — use the `active=False` boolean to soft-delete and let related records keep their references.

**low GDPR data residency on Odoo Online is configured at signup**

Odoo S.A. operates EU and US data centres and is GDPR-compliant by default, but Odoo Online accounts pick a region at signup and changing it later requires a support-managed migration of the database to a different region[37](https://flitstack.ai/migrations/crm/odoo-crm#source-37). If your project requires EU residency and the account was created in the US, plan the regional move before the data migration, or you will move records twice. Self-hosted and Odoo.sh customers control region directly via the cloud provider they select.

## 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 change[31](https://flitstack.ai/migrations/crm/odoo-crm#source-31), 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 shops[21](https://flitstack.ai/migrations/crm/odoo-crm#source-21). 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 set[23](https://flitstack.ai/migrations/crm/odoo-crm#source-23) [31](https://flitstack.ai/migrations/crm/odoo-crm#source-31).

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 services[39](https://flitstack.ai/migrations/crm/odoo-crm#source-39). 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 alternative[23](https://flitstack.ai/migrations/crm/odoo-crm#source-23).

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-pointed[39](https://flitstack.ai/migrations/crm/odoo-crm#source-39).

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)

In this guide

## 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 & Plan 10 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 Prep 23 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 Export 12 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 & Map 28 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 Migration 14 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 Cutover 15 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\. Validate 16 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 Cleanup 11 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.

### [Odoo implementation](https://flitstack.ai/services/odoo-implementation)

[Set up Odoo CRM (pipelines, properties, automation, permissions) and migrate into it as one engagement.](https://flitstack.ai/services/odoo-implementation)

[See the service →](https://flitstack.ai/services/odoo-implementation)

### [All crm migrations](https://flitstack.ai/migrations/crm)

[Every destination we migrate pipelines, contacts, and deals into.](https://flitstack.ai/migrations/crm)

[Back to CRM →](https://flitstack.ai/migrations/crm)

## Sources

1. [Odoo — Wikipedia](https://en.wikipedia.org/wiki/Odoo)
2. [Best Zoho CRM Alternatives for Custom Development and Flexibility — r/CRMSoftware](https://www.reddit.com/r/CRMSoftware/comments/1tn9ear/best_zoho_crm_alternatives_for_custom_development/)
3. [Migrating from Odoo.sh (Enterprise) to Self hosted (Community) — r/Odoo](https://www.reddit.com/r/Odoo/comments/1pzdnpo/migrating_from_odoosh_enterprise_to_self_hosted/)
4. [Export and import data — Odoo 19.0 documentation](https://www.odoo.com/documentation/19.0/applications/essentials/export_import_data.html)
5. [Import products — Odoo 19.0 documentation](https://www.odoo.com/documentation/19.0/applications/sales/sales/products_prices/products/import.html)
6. [Odoo Online programmatic throughput limits — Odoo Forum](https://www.odoo.com/forum/help-1/odoo-online-throughput-limits)
7. [ORM reference — Odoo 19.0 documentation](https://www.odoo.com/documentation/19.0/developer/reference/backend/orm.html)
8. [Odoo CRM application reference — Odoo 19.0 documentation](https://www.odoo.com/documentation/19.0/applications/sales/crm.html)
9. [Managing Parent-Child Relationships Between Partners in Odoo — Odoo Forum](https://www.odoo.com/forum/help-1/managing-parent-child-relationships-between-partners-in-odoo-237999)
10. [Data Cleaning — Odoo 19.0 documentation](https://www.odoo.com/documentation/19.0/applications/productivity/data_cleaning.html)
11. [Datetime field reference — Odoo 19.0 documentation](https://www.odoo.com/documentation/19.0/developer/reference/backend/orm.html#datetime-fields)
12. [Upload size limit in Odoo — Odoo Forum (128 MiB cap)](https://www.odoo.com/forum/help-1/upload-size-limit-in-odoo-221095)
13. [what is ondelete='cascade' in OpenERP — Odoo Forum](https://www.odoo.com/forum/help-1/what-is-ondeletecascade-in-openerp-73895)
14. [Fields and widgets — Odoo 19.0 documentation (Studio)](https://www.odoo.com/documentation/19.0/applications/studio/fields.html)
15. [Configure Salesperson groups for own-documents access in Odoo 18 — Odoo Forum](https://www.odoo.com/forum/help-1/how-can-i-configure-a-salesperson-group-own-documents-that-can-create-edit-and-import-their-own-leads-in-odoo-18-289874)
16. [Manufacturing Company Migrating from Salesforce to Odoo — Odoo Experience 2025](https://www.odoo.com/event/odoo-experience-2025-6601/track/manufacturing-company-migrating-from-salesforce-to-odoo-a-successful-crm-migration-story-7699)
17. [External transports for programmatic loads — Odoo documentation](https://www.odoo.com/documentation/19.0/developer/reference/external_api.html)
18. [Crowdfunding OpenUpgrade for Odoo Community 19.0 — r/Odoo (OCA)](https://www.reddit.com/r/Odoo/comments/1qppbv3/do_you_want_to_migrate_your_odoo_community_instance/)
19. [Activities — Odoo 19.0 documentation](https://www.odoo.com/documentation/19.0/applications/essentials/activities.html)
20. [Communication in Odoo by email — Odoo 19.0 documentation](https://www.odoo.com/documentation/19.0/applications/general/email_communication.html)
21. [Migrate history CRM — Odoo Forum](https://www.odoo.com/forum/help-1/migrate-history-crm-196965)
22. [Import file and retain file date — Odoo Forum (create\_date is upload time)](https://www.odoo.com/forum/help-1/import-file-and-retain-file-date-286676)
23. [Image file types supported in Odoo — Odoo Forum](https://www.odoo.com/forum/help-1/is-image-file-types-supported-in-odoo-if-yes-which-are-225605)
24. [Base Attachment Object Store (fs\_attachment) — Odoo Apps Store](https://apps.odoo.com/apps/modules/16.0/fs_attachment)
25. [OCA Audit Log — The Odoo Community Association](https://apps.odoo-community.org/shop/audit-log-533)
26. [Outlook Calendar synchronization — Odoo 19.0 documentation](https://www.odoo.com/documentation/19.0/applications/productivity/calendar/outlook.html)
27. [Cannot import date field — Odoo Forum](https://www.odoo.com/forum/help-1/cannot-import-date-field-163065)
28. [User and unicode character error — Odoo Forum](https://www.odoo.com/forum/help-1/user-and-unicode-character-error-25775)
29. [unsupported format character on import — Odoo Forum](https://www.odoo.com/forum/help-1/unsupported-format-character-on-import-23376)
30. [Error when importing sample data — Odoo Forum (ondelete restrict)](https://www.odoo.com/forum/help-1/error-when-importing-sample-data-286075)
31. [General Data Protection Regulation (GDPR) — Odoo](https://www.odoo.com/gdpr)
32. [What Does Odoo Migration Really Cost? Pricing Breakdown — Aspire Softserv](https://dev.to/aspire-softserv/what-does-odoo-migration-really-cost-a-transparent-pricing-breakdown-for-2025-48fj)

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](https://flitstack.ai/contact)
