Skip to content
Get a quote

Migrate to Odoo ERP

Odoo ERP is a module-based, open-source business suite whose migration path rewards teams that pre-stage the chart of accounts, model inventory locations and BOMs against existing modules, and respect platform throughput limits before the first opening balance is posted.

Short answer

FlitStack AI migrates financial, supply chain, and operational data into Odoo ERP from 200+ ERPs, including NetSuite, Atlas ERP, ERPNext, Sage Intacct. Every field is mapped to Odoo ERP's objects, history and associations come across, the Odoo ERP setup is configured alongside, and the whole migration stays reversible in one click.

By

From Any source
DestinationOdoo ERP
NetSuiteAtlas ERPERPNextSage IntacctOdoo Enterprise
200+ sources mapped into Odoo ERP

Systems we move into Odoo ERP

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

What Odoo ERP supports, and where its import tools stop

  • Modular pay-as-you-grow model with 80+ apps under one database — teams start with CRM and add Accounting, Inventory, or Manufacturing without switching platforms.
  • Free Community edition lets businesses validate Odoo fit before committing to Enterprise licensing costs that scale with user count.
  • Lowest per-user pricing among mid-market ERPs, with a published free tier for one app and Standard plans starting around $24.90 per user per month.
  • Native integration between modules — a confirmed Sales Order automatically updates inventory, invoicing, and accounting without manual re-entry.
REST onlyAPI key (Odoo 13+) or username/password via XML-RPC
Rate limitsNot publicly documented by Odoo
ObjectSupportNote
Partners (Contacts/Companies)fullPartners is Odoo's primary contact object. It uses External IDs (e.g. base.us) for cross-reference in imports. We preserve partner categories, addresses, and bank details and map them to the destination CRM's contact schema.
Products (Items)fullProducts include name, type (stockable/consumable/service), list price, standard cost, and variants via attribute combinations. We handle the product.supplierinfo relation for vendor pricing and preserve images via public URL during import.
Inventory (Stock Moves/Quants)mappedStock quants track on-hand quantities per location. We map warehouse locations to destination inventory locations, but lot/serial number traceability may require manual verification post-import due to destination schema differences.
Sales OrdersfullSales Orders link to Partners and Products with order lines. We preserve the full order lifecycle (draft → confirmed → done) and map fiscal positions that affect tax computation on the destination system.
Invoices (Account Moves)mappedOdoo 17+ unified invoices into account.move with move_type (out_invoice, out_refund, etc.). We map to destination invoice records but flag posted invoices as non-editable — they require credit notes for corrections rather than in-place edits.
Chart of AccountsmappedAccounts are tied to fiscal positions and taxes by country. We map the account codes and names, but country-specific tax groups and fiscal position rules require explicit configuration in the destination ERP post-migration.
ProjectsfullProjects in Odoo have a task hierarchy and can belong to multiple stages. We preserve project stage pipelines and map task assignees using Odoo's many2one user reference format.
TasksfullTasks link to Projects, include sub-tasks (parent_id), and track stage, assignee, and deadline. We preserve the task hierarchy and map custom stage names to destination stage pipelines.
Manufacturing Orders (MO)mappedMOs reference Bills of Materials (BoM) with component lines and workorder sequences. We map the BoM structure and MO states, but workorder routing dependencies may require re-sequencing in the destination system.
Bills of Materials (BoM)mappedBoMs define product components and quantities. We preserve the product structure and type (kit, manufactured, phantom), but variant-specific BoMs require mapping to destination product variant IDs.
EmployeesmappedEmployees are in the hr.employee model and linked to Users. We map employee records but note that Employee categories, emergency contacts, and HR-specific fields are Odoo-specific and may not have a direct destination equivalent.
Custom Fields (ir.model.fields)mappedOdoo allows custom fields via Settings → Technical or ir.model.fields. Custom fields added by Odoo Studio are stored with ttype and may have selection options. We preserve custom field definitions and values, but field types not supported by the destination system fall back to text.
AttachmentsmappedAttachments (ir.attachment) store files in binary or as URLs. Large binary attachments should be provided as public URLs for Odoo to download at import time rather than uploaded directly via CSV.
TaxesmappedOdoo defines taxes with scope (sale/purchase), tax_type (percent, fixed, group), and country-specific fiscal positions. We map tax names and rates, but fiscal position automation requires destination-side configuration.

The Odoo ERP migration guide

Why teams migrate to Odoo ERP

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

Odoo S.A. was founded by Fabien Pinckaers in 2005 as TinyERP, rebranded to OpenERP in 2009, then to Odoo in 2014, and is headquartered in Ramillies-Brabant-Wallon, Belgium1. Odoo ERP is the integrated finance, inventory, manufacturing and procurement layer of a suite of around 80 official modules — Accounting, Inventory, Manufacturing, Purchase, Sales, Project, HR — all sharing the same PostgreSQL database and ORM.

The typical Odoo ERP customer is a small-to-mid-market manufacturer, distributor or services business — 25 to 500 users — that wants general ledger plus inventory plus production plus AP/AR under one schema, and is willing to absorb the open-source learning curve for the integration depth2. Compared with SAP Business One or Dynamics 365 Business Central, Odoo positions on per-user cost; compared with NetSuite, on module breadth and a unified data model3.

The shapes of migration that actually land on Odoo ERP tend to fall into four patterns. First, suite consolidation projects: a company replacing a stack of QuickBooks plus a separate WMS plus a spreadsheet-based MRP with the Odoo all-in-one suite. Second, vendor-cost exits from SAP, NetSuite or Oracle where total cost of ownership at 50–400 users no longer justifies the enterprise contract5.

Third, legacy ERP replacements — older OpenERP/TinyERP installs, Sage 50, JD Edwards on-prem, JTL-Wawi, or country-specific country-by-country systems — where the source schema is loose and the project is really a re-architecture against account.move and stock.move6. Fourth, Odoo-to-Odoo version migrations, where a team running Community 15 jumps to 18 or 19, or moves from Odoo.sh Enterprise back to self-hosted Community, with OpenUpgrade carrying the schema7.

Each shape has a different difficulty profile: a QuickBooks-to-Odoo move usually has clean GL parity but messy chart-of-accounts numbering, while a SAP-to-Odoo migration carries rich automation that does not move across at all.

What makes migrating to Odoo ERP 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 records8. Pre-built templates exist for Contacts, Products, Chart of Accounts, Journal Entries and Bills of Materials.

What makes it harder than the average is the Community-vs-Enterprise gap — full Accounting (audit trail, follow-up letters, online bill scanning), Studio, Documents, Marketing Automation and several connector modules are Enterprise-only, and silently disappear if you restore an Enterprise database into a Community container7. The second hard edge is the annual major-version cadence: every 12 months a breaking release ships, which means migration is not a one-time event but a recurring workstream every team plans around11.

Studio customisations, Automated Actions, custom Python modules and country-specific localisations 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, localisations and Automated Actions do not move with a CSV import — they are rebuilt in the destination.

The Odoo ERP data model you need to map into

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

Odoo's ERP is built around a small set of Python models, each declared as a class extending models.Model with attributes that the ORM persists into PostgreSQL12. Finance, inventory and manufacturing sit on top of the same shared res.partner master record and account.account chart of accounts used by 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 ERP migration13.

ObjectWhat it storesRequiredTier
res.partnerMaster record for customers, vendors and employeesname; is_company; customer_rank / supplier_rankAll editions
account.accountChart of Accounts — every GL accountcode; name; account_type (income, expense, asset, liability, equity)Full Accounting in Enterprise; basic Invoicing in Community
account.move / account.move.lineJournal entries — invoices, bills, opening balances, all GL postingsjournal_id; date; line_ids (debit/credit balanced)All editions
account.journalJournals — Sales, Purchase, Bank, Cash, Miscellaneousname; type; codeAll editions
product.template / product.productProduct master and per-variant SKUsname; type (consu / service / product); list_priceAll editions
uom.uom / uom.categoryUnits of Measure (kg, m, box of 6) and their conversion categoriesname; category_id; factorInventory module
stock.location / stock.warehousePhysical and logical inventory locationsname; usage (internal, customer, supplier, inventory)Inventory module
stock.quant / stock.move / stock.lotOn-hand quantities, stock movements, and lot/serial numbersproduct_id; location_id; quantityInventory module
mrp.bom / mrp.bom.lineBills of Materials and their componentsproduct_tmpl_id; product_qty; bom_line_idsManufacturing module
purchase.order / sale.orderPurchase and sales orders with their order linespartner_id; date_order; order_linePurchase / Sales modules
res.currency / res.currency.rateCurrencies and dated exchange ratesname (ISO code); rate; dateAll editions
res.companyLegal entity — drives multi-company isolationname; currency_id; country_idAll editions; Enterprise required for inter-company rules

res.partner is the unifying record — a single row represents a customer, a vendor, an employee, or a contact at any of those, distinguished by the customer_rank and supplier_rank integer counters and linked through parent_id for company-and-contact hierarchies14.

Odoo does not have a single canonical natural-key field on most models. Instead, the import tool uses an XML external ID — a string of the form __import__.123 or your_module.account_4000 — 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.

If you do not supply external IDs, Odoo generates 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. Custom field types determine validation and storage; the catalogue below covers what you can model and the limits you need to plan around12.

Field typeLimitNotes
Char (single-line text)Default size=64, configurableMaps to PostgreSQL varchar; trim before import
Text (multi-line text)Unlimited (PostgreSQL TEXT)Used for descriptions, internal notes
Integer / FloatINT4 / NUMERIC in PostgreSQLFloat defaults to digits=(16,2); override per field for GL precision
MonetaryTied to res.currency precisionUse for amounts; system handles rounding by currency decimals
Date / DatetimeYYYY-MM-DD / YYYY-MM-DD HH:MM:SS in UTCDatetime stored UTC; ISO-8601 strongly recommended
Selection (picklist)Defined as Python tuple listInternal key vs label; import expects the key12
Many2one (foreign key)Single related recordResolves by name OR external ID OR database ID — pick one and be consistent17
One2many / Many2manyInverse / junction relationsMany2many uses comma-separated names on import18
Binary (attachments)64 MiB default on Odoo.sh; 128 MiB on self-hostedStored as ir.attachment records19
Custom fields via Studio21 field-type variants, Enterprise-only UICommunity: edit via Developer Mode → Settings → Technical → Fields20

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 key21. This is configured in fields.py per field, not at the database level you can flip from the UI — and it drives several of the pitfalls in Section 6.

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.fields20. Either way, the model must exist in the database before records of that type can be imported, and the module must be installed before the model is reachable.

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

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 ERP migration is how much work you do on the source side before the first import button is pressed. Odoo's own implementation partners warn that data preparation — not the upload itself — is where most projects lose weeks, 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, currencies resolved to ISO codes that exist in res.currency, GL accounts mapped to the destination chart of accounts, and every row stamped with a stable id column.

Source-side prep

  • Audit and dedup the customer and vendor master in the source system before export. Odoo's Data Cleaning app handles post-import dedup on res.partner matching on email, phone and VAT, but it is much cheaper to dedup on the source than to merge after.
  • Reconcile the source GL to its trial balance before extracting opening balances — every account that does not tie out on the source becomes a manual line item on the Odoo opening journal entry.
  • Normalise dates to YYYY-MM-DD or YYYY-MM-DD HH:MM:SS in UTC. Odoo's importer auto-detects most formats but day/month inversions like 01-03-2016 are ambiguous; use ISO-8601 to remove the guesswork.
  • Convert Selection field labels to internal keys — for account types, journal types, product types, every custom dropdown — Odoo expects the Python key (e.g. asset_receivable, liability_payable, consu, product), not the display label12.
  • 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.account_4000. This is what makes re-runs and reconciliation deterministic.
  • Decide what is in scope for historical transactions. Open AP/AR invoices and the opening trial balance must move; closed prior-year journal entries usually stay in the source as a read-only archive.

Destination-side prep

  • Install the country localisation under Apps → search l10n_ (for example l10n_us, l10n_fr, l10n_de) on a fresh database before any other Accounting setup — the localisation seeds the chart of accounts, taxes, and fiscal positions, and cannot be cleanly applied after journal entries exist27.
  • Create a staging database on Odoo.sh (staging branches are first-class) or duplicate the database on Odoo Online or 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 Accounting, Inventory, Manufacturing and Purchase groups. Owner assignment fails silently if the referenced user does not exist.
  • 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 imported20.
  • Build the chart of accounts, journals, fiscal years, and tax codes in Accounting → Configuration before importing any journal entries — entries targeting a non-existent account or a closed period are rejected.
  • Install required modules first — Accounting, Inventory, Manufacturing, Purchase, Sales, plus any OCA modules (OCA Audit Log, fs_attachment, OpenUpgrade) 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 for finance, longer for inventory if you are recounting — and communicate it to every department that touches the ERP. Train AP clerks on the Odoo vendor bill workflow, warehouse staff on the kanban barcode flow, and accountants on the journal-entry and reconciliation widgets before go-live, not after.

A typical 50-user professional-services Odoo migration runs four to eight weeks of elapsed time end-to-end; a 200-user multi-company manufacturing migration with Studio rebuilds, multi-currency consolidation and historical inventory loads runs three to six months30. Build the human runway accordingly.

Import mechanisms: UI wizard, base_import, and scripted loads

Multiple 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. Scripted loads via the Odoo ORM handle programmatic, repeatable and very large loads. 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, Accounting → Chart of Accounts, Inventory → Products, etc.), click the gear or Actions icon, then Import records → Upload File8. 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 practitioner reports suggest CSV-via-UI is reliable up to roughly 10,000 records per file and starts to hit worker timeouts above 50,000 on Odoo.sh and Online. 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. Re-imports against the same external ID in the id column update existing rows; new external IDs create. Warning: imports are permanent and cannot be undone from the UI — use the created on or last modified filter to locate import-batch rows for archival17.

Scripted loads through the Odoo ORM

Odoo's ORM exposes the same methods as the UI — create, write, search_read, and the bulk-friendly load — and can be driven by scripts running against an Odoo instance. 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 timeouts on Odoo.sh. Model.create() accepts a list of dictionaries — bulk-insert in a single call rather than a loop33.

Choose the scripted 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 throttling 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; 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 editions7. For Odoo Enterprise upgrades, Odoo S.A.'s paid upgrade service handles the schema transformation but is not available to Community users — and the annual major release cadence makes this a recurring cost line rather than a one-time event11.

Mapping your data into Odoo ERP

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

Mapping is where every ERP migration earns its scars. The schema decisions you make in your mapping spreadsheet determine whether the trial balance ties on day one, whether inventory valuation matches on day five, and whether the closing process works at the first month-end after go-live.

Work model by model, top to bottom of the dependency order: res.company and res.currency first, then res.users, then account.account (chart of accounts) and account.journal, then customers and vendors on res.partner, then product.template with uom.uom, then stock.location and on-hand inventory, then mrp.bom, then open AP/AR via account.move, and finally the opening trial balance.

Chart of accounts (account.account)

Install the country localisation module (e.g. l10n_us, l10n_fr, l10n_de) before any chart-of-accounts work — the localisation seeds the legally required CoA structure, default taxes and fiscal positions27. Then map the source CoA to the localised CoA: most projects keep the localised account codes and only add custom accounts for operational tracking (departments, projects, cost centres) that the source had as analytic dimensions.

Common source → account.account mapping
SourceDestinationNote
GL account numbercodeRenumber to fit localised CoA ranges; document the cross-walk
account namenameRequired; keep source name as legacy_name Char if useful
account type / categoryaccount_typeSelection key: asset_current, asset_receivable, liability_current, liability_payable, income, expense, equity27
reconcilable flagreconcileSet True on AR/AP control accounts; required for invoice matching
currency restrictioncurrency_idOnly set if account is restricted to a single non-company currency

GL opening balances (account.move)

Opening balances post as a single Miscellaneous journal entry on account.move dated the day before go-live (e.g. 2026-01-01 entry on a 2026-02-01 cutover), with one account.move.line per account, debits equal to credits35. The exception is AR and AP control accounts — those balances post as individual open invoice and bill records (next subsection), not as a single line, so that future receipts and payments can match by document.

Recommended sequence on the opening entry: assets first (cash, inventory control, fixed assets net of accumulated depreciation), then liabilities (accrued expenses, taxes payable, loans), then equity (retained earnings as the balancing account). The journal must balance to the penny — Odoo rejects unbalanced entries with The total of the debits is not equal to the total of the credits.

Open AP / AR invoices (account.move with move_type)

Open customer invoices import as account.move records with move_type='out_invoice' and state='posted'; open vendor bills use move_type='in_invoice'. Each invoice carries its own due date, partner, lines, tax and amount-residual — and crucially, its own original invoice date so that aging reports work correctly from day one.

Build one row per invoice header plus one row per line item (One2many on invoice_line_ids), with the invoice's external ID repeating on each line. After import, run the Accounting → Reporting → Partner Ledger report and reconcile against the source AR/AP aging — any partner whose balance does not match within rounding tolerance flags a mapping defect to fix before go-live.

Inventory: products, UoM, locations, on-hand quantities

Inventory mapping touches four models in sequence. First, uom.uom and uom.category — every UoM you reference must already exist, and conversions only work between UoMs in the same category (Units, Weight, Volume, Length, Time)36. If you sell in meters and buy in centimetres, both must be in the Length category with the correct factor.

Second, product.template and product.product — the template is the catalogue item, the product.product is the variant (size, colour, configuration). Required fields: name, type (Selection key: consu, service, or product for storable), list_price, uom_id, uom_po_id, and categ_id (product category). Set tracking to lot or serial if the SKU needs lot/serial tracking — this must be decided before the first stock move exists for that product, because Odoo blocks the change once movements have posted37.

Third, stock.warehouse and stock.location — warehouses contain a tree of locations (Stock, Stock/Shelf A, Stock/Quality Control, Customers, Vendors, Inventory adjustment). Each location has a usage (Selection key: internal, customer, supplier, inventory, production, transit).

Fourth, on-hand inventory — the recommended path is Inventory → Operations → Physical Inventory which creates an Inventory Adjustment that posts as a stock.move from the virtual Inventory adjustment location into the real internal location, with the per-product quantity and lot/serial number where applicable. The corresponding GL entry hits the inventory control account on the opening journal entry — do not double-count by posting both the stock.move and a manual GL line for the same value.

Bills of materials (mrp.bom)

BOMs import as mrp.bom headers (one row per assembly) plus mrp.bom.line children (one row per component). The header carries product_tmpl_id, product_qty, code, and type (Selection key: normal, phantom for kit-bill, subcontract). The lines carry product_id, product_qty, and product_uom_id39.

BOM imports are bottom-up: every component product must exist before the BOM that references it, and multi-level BOMs need the sub-assembly's BOM imported before the top-level BOM that includes the sub-assembly. Practitioners report BOM creation is one of the heavier operations because each BOM needs the header create, then one create per line — under Odoo Online's tighter throttling, even a few thousand BOMs becomes hours22.

Multi-currency and historical exchange rates

Multi-currency is enabled in Accounting → Configuration → Settings → Currencies → Multi-Currencies and configured per-company through res.company.currency_id. For historical transactions in foreign currency, you import the original amount and original date in amount_currency and date, and Odoo posts the company-currency equivalent using the rate from res.currency.rate for that date — so the rate table must be populated for every historical date that has a foreign-currency transaction.

Without dated rates, Odoo falls back to the current rate and posts the wrong company-currency value41. Build the rate import as one row per (currency, date, rate) triple and import it before any multi-currency invoices or journal entries. For multi-company setups, each res.company can have its own functional currency, and inter-company transactions revalue automatically.

Fiscal year and period close

Fiscal year is configured in Accounting → Configuration → Settings → Fiscal Periods (last day of fiscal year, lock dates). Set the Journal Entries Lock Date to the day before your opening-balance date so that nobody (including the import job) can post prior-period entries by accident27. After opening balances and open invoices are loaded and reconciled, advance the lock date to the day before the new period — this is how Odoo enforces period close.

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

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

Files, attachments, and audit trail

Attachments in Odoo live on the ir.attachment model and link to any record via res_model and res_id. Default per-attachment cap is 64 MiB on Odoo.sh and Odoo Online (the public reverse proxy enforces this) and 128 MiB on self-hosted instances that override server config19. Supported image formats include JPEG, PNG, GIF, BMP, TIFF, SVG, ICO, WEBP, PSD and EPS42.

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 filesystem43, or (c) scripted upload through the ORM where you load ir.attachment records with datas, name, res_model and res_id set.

Odoo records create_date, create_uid, write_date and write_uid automatically and does not preserve the source record's original creation date during import — create_date stamps to upload time44. If you need the original audit trail, create legacy_create_date (Datetime) and legacy_create_uid (Many2one to res.users) custom fields per model and populate from the source export. Field-change auditing is provided by the Enterprise Accounting Audit Trail feature, and the OCA Audit Log module fills the same role on Community45.

The pitfalls that derail Odoo ERP migrations

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

Validation and cutover

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

Validation is the bridge between the import finishing and users being allowed in. Odoo implementation partners 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 GL balance and stock counts, and a 30-day post-migration data-quality audit. The most reliable signal is having finance, AP, AR and warehouse leads verify their own records against the source.

Build a reconciliation queries spreadsheet that compares source and destination on each of these counts. Anything outside a 0.5 percent variance — or any non-zero variance on the trial balance — gets investigated before users get login access.

  • Trial balance match — run Accounting → Reporting → Trial Balance on Odoo dated the opening-balance date and reconcile every account to the source trial balance. Any non-zero variance is a defect, not a rounding issue.
  • AR aging by partner vs source — run Accounting → Reporting → Partner Ledger filtered to receivable accounts and compare partner-by-partner totals against the source AR aging report.
  • AP aging by vendor vs source — same as AR, against the source AP aging.
  • Stock on hand by warehouse and location vs the source physical count — run Inventory → Reporting → Inventory Valuation and reconcile against the source warehouse management report.
  • Inventory valuation vs the source GL inventory control account — these must tie within rounding; any larger variance indicates a unit-of-measure conversion error or a cost-method mismatch (FIFO/Average/Standard).
  • Open purchase and sales orders vs source — count distinct purchase.order and sale.order in draft or purchase/sale state and verify against the source open-orders list.
  • BOM count and component count — GROUP BY product_tmpl_id on mrp.bom and compare against the source manufacturing master.
  • External-ID uniqueness — query ir.model.data for duplicate (module, name) combinations on your migration namespace; any duplicates indicate the dedup transform missed cases.
  • Multi-company isolation — if multi-company is in scope, query each res.company and confirm account.move rows are scoped to the right company_id.

On top of reconciliation, run a manual spot-check protocol: pick 30 random records across models — five open invoices, five vendor bills, five products with inventory, five BOMs, five sales orders, five journal entries — and verify each field against the source UI. 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 for imports — the documentation is explicit that imports are permanent17. The closest things are the OCA Audit Log module (when configured with the right rules in advance)45, the Enterprise Accounting Audit Trail for journal entries, and Odoo.sh staging branches which let you fork production and roll back at the database level. None is a one-click reversal; all 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 finance, AP, AR and warehouse teams are notified; (2) physical inventory count completes and loads as opening on-hand; (3) final delta export captures everything that changed during the test-import window; (4) delta imports with the same external-ID namespace; (5) trial-balance and AR/AP reconciliation runs; (6) lock dates advance to the day before go-live; (7) users get login access plus a 48-hour hyper-care window; (8) source decommission schedules 90 to 180 days out.

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, and lists 5,000+ partners across 120+ countries on its public directory52. For ERP migrations specifically, partners with explicit SAP-to-Odoo, NetSuite-to-Odoo, Sage-to-Odoo or QuickBooks-to-Odoo practices tend to ship cleaner than generalist shops30. The Odoo Community Association (OCA) maintains modules — Audit Log, OpenUpgrade, fs_attachment — that fill gaps left by Enterprise745.

Cybrosys Technologies, Open Technology Solutions, Synavos, Aspire Softserv, Silent Infotech, Iqra Technology, Softeko, Braincuber, Steersman 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 services30. 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 alternative7.

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 an ERP migration is rarely the migration itself — it is the staging layer, the transformation layer that resolves Selection values and Many2one relations, and the ongoing-sync layer post-cutover.

Managed-migration cost ranges vary widely with user count and module scope. Practitioner pricing for Odoo ERP migrations runs roughly $3,000–$10,000 for small businesses (under 10 users, single-company, standard modules), $20,000–$50,000 for medium businesses (11–50 users, multiple modules with moderate customisation), and $50,000–$100,000+ for large enterprises (50+ users, multi-company, heavy customisation, multiple integrations)30.

Hourly rates for Odoo professional services range $10–$150+ per hour depending on region and partner expertise. The upper end of the curve is driven by user count, the number of modules in scope (Accounting, Inventory, Manufacturing, Purchase, Sales, HR, Project — each adds elapsed time), the depth of historical data, multi-currency or multi-company complexity, and the number of third-party integrations that need rebuilding rather than re-pointed.

For teams that want to outsource the migration end-to-end, FlitStack specialises in Odoo ERP migrations and handles the localisation install, chart-of-accounts cross-walk, opening-balance journal preparation, inventory and BOM load, multi-currency rate population, and validation work described in Sections 5 and 7 of this guide. Pricing is fixed-fee, based on user count, module scope and source platform, with separate line items for multi-company, historical-data depth and custom modules so the scope is transparent before signature.

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

Odoo ERP migration checklist

An exhaustive 8-phase punch list for moving chart of accounts, opening balances, stock, BOMs, multi-currency, and AP/AR into Odoo ERP via base_import.import, XML-RPC, and the ORM load() method. Typical timeline: 8–24 weeks.

0. Decide & Plan12 tasks
  • Decide and document the Odoo deployment target. Choose Odoo Online (SaaS, no custom server-side code, throttled write throughput), Odoo.sh (managed PostgreSQL with staging branches and shell access), or on-premise (full control over filestore, workers, and ir.config_parameter). Each path has different access to shell, database manager, and per-file caps.If skipped: Picking Odoo Online and then discovering you need a custom localization module or server action forces a re-platform mid-project.
  • Decide between Community and Enterprise edition. Community is free but excludes the full Accounting app, Studio, the Documents app, OCR on bills, MRP master production schedule, and several l10n_* localization modules. Confirm which account.*, mrp.*, and stock.* features the target workflow requires before purchase.If skipped: Restoring an Enterprise database into a Community container marks Enterprise modules as 'not installable, skipped' and breaks the Accounting app entirely on Community.
  • 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> became <list> in 18). For migrations between major versions of an existing Odoo database, plan for the OpenUpgrade tooling path rather than treating it as a fresh import.If skipped: Mapping against the wrong major produces import files referencing fields that have been renamed or removed.
  • Pick the l10n_* localization module per country of operation. Each country has a dedicated chart-of-accounts and tax module (e.g. l10n_us, l10n_de, l10n_fr, l10n_in). Choose one per res.company before any account.account record is created — switching the localization after accounts exist is not supported.If skipped: Switching localizations post-load forces a database rebuild because the chart-of-accounts template is one-shot.
  • Define migration scope by Odoo model. List in-scope models explicitly: res.company, res.partner, account.account, account.journal, account.move, account.payment, product.template, product.product, uom.uom, stock.location, stock.warehouse, stock.lot, stock.quant, mrp.bom, mrp.bom.line, res.currency, res.currency.rate. Mark each as in or out of scope.
  • Define the historical-data window for posted journals. Decide how many fiscal years of posted account.move records migrate as posted documents versus collapse into a single opening-balance journal. The standard convention is: prior closed years collapse into one opening journal; the current open year migrates as posted documents.If skipped: Migrating five years of posted journals when only opening balances are needed inflates database size by an order of magnitude and slows every report.
  • Decide the multi-company structure. Map source legal entities to res.company records. Decide whether each company gets its own chart-of-accounts (separate l10n_* installs) or shares one. Document the parent_id hierarchy if companies consolidate.
  • Identify legal, residency, and retention constraints. Confirm the Odoo.sh region matches data-residency obligations. As of 2026, Odoo.sh has seven data center regions: Iowa, Toronto, Saint-Ghislain, Dammam, Mumbai, Singapore, Sydney. Document GDPR data-subject access and erasure procedures against res.partner and account.move. Document audit-log retention for financial records.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 plus a finance approver. Name one accountable owner with authority to cut scope and one finance approver who signs the opening trial balance and the post-load reconciliation in writing.
  • Set the cutover window and source-system freeze date. Pick the cutover datetime in the destination timezone. Align it to a period close in the source so the opening balance has a clean cutoff. Communicate both to all source users at least four weeks in advance.
  • Document the migration success criteria. Write the falsifiable conditions: opening trial balance ties to source to the cent, every open AR/AP invoice exists in Odoo with matching residual, stock-on-hand per stock.location matches source, BOMs explode to the same components, multi-currency unrealized gain/loss reconciles.If skipped: Without explicit success criteria the project never formally closes and finance refuses sign-off.
  • List explicit out-of-scope items. Capture items intentionally excluded (e.g. closed work orders older than three years, deprecated stock locations, retired products with zero on-hand). Out-of-scope items become scope creep without this list.
1. Pre-Migration Prep28 tasks
  • Export baseline record counts per source object. Capture row counts for customers, vendors, products, accounts, journal entries, open invoices, stock locations, stock on hand, BOMs, and currencies. Date-stamp the snapshot.If skipped: Without a baseline count you cannot prove completeness at reconciliation.
  • Run the source-system trial balance and freeze a copy. Pull the trial balance as of the planned cutover date. Print to PDF and capture the CSV. This becomes the target the opening-balance journal in Odoo must tie to.If skipped: Without a frozen source trial balance the reconciliation in Phase 6 has no anchor and finance cannot sign off.
  • Deduplicate source customers and vendors using VAT/tax-ID plus email. Resolve flagged duplicates manually; keep a merge audit log mapping merged-from IDs to surviving IDs. VAT / tax registration ID is more reliable than name for vendor dedup.If skipped: Duplicate vendors in res.partner inflate AP aging and split payment history across two records.
  • 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.
  • Standardize currency codes to ISO-4217 and phone numbers to E.164. res.currency uses three-letter ISO codes (USD, EUR, INR, GBP). Convert source '$' or 'US Dollar' to 'USD'. Pre-normalize phone numbers to '+<country><number>'.
  • Identify products missing required attributes. product.template requires name, type (consumable, service, storable/product), and uom_id. Surface and fix any source product missing these before transform.If skipped: Products with missing required fields fail row-by-row and force a partial re-import.
  • Reconcile source AR and AP aging to the trial balance. Sum open AR invoices and confirm it equals the AR control account in the source trial balance. Same for AP. Resolve any drift before exporting — it does not get easier in Odoo.If skipped: AR/AP that does not tie to the GL in the source will never tie in Odoo no matter how careful the load is.
  • Inventory source custom fields with type and selection options. List every non-standard field with its type, allowed values, required flag, and which records use it. This drives the Phase 1b destination field creation.
  • Archive obsolete and orphaned source records. Products with zero on-hand and no transactions in three years, vendors with no activity in two years, accounts with zero balance and no movement in five years — archive on the source so they do not export.
  • 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 off production. On Odoo Online use 'Duplicate Database' 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 financial data with test rows.
  • Install the country localization module first. Settings → Apps → install l10n_<country> before installing Accounting. The localization creates the country-specific chart-of-accounts template, tax records, and fiscal positions. Installing Accounting first and the localization later leaves you with the generic chart.If skipped: An incorrect chart-of-accounts template at install time cannot be swapped without rebuilding the database.
  • Install Accounting, Inventory, Manufacturing, and Sales/Purchase apps. Settings → Apps → install the core ERP modules in the order: Accounting, Inventory, Purchase, Sales, Manufacturing. Dependencies resolve automatically; installing in this order avoids the 'module not installable' state.
  • Configure res.company and org-level settings before any transactional record. Set legal name, VAT/tax-ID, currency_id, country_id, fiscal_country_id, chart_template_id (auto-set by l10n_*), timezone, language, and tax cash-basis flag on res.company. These propagate defaults across every model and affect how base_import.import interprets dates and numbers.If skipped: Changing res.company.currency_id or timezone after data exists requires reposting every journal and shifts every imported datetime.
  • Create res.users for every employee, salesperson, and accountant who needs access. Settings → Users & Companies → Users. Create each user with the correct access rights (Accounting / Adviser, Inventory / Manager, etc.). Capture each user's login email — this becomes the lookup key during import.
  • Create account.journal records for sales, purchases, bank, cash, and miscellaneous. Accounting → Configuration → Journals. Each journal needs type, code, default debit/credit account, and sequence. Posted account.move records require journal_id.If skipped: Importing posted journal entries without journals pre-created produces a hard foreign-key error on every row.
  • Create the account.fiscal.year records (or set fiscal year range on res.company). Accounting → Configuration → Fiscal Years. Create the closed prior year (for the opening journal) and the current open year. Periods must exist before journal entries can be posted into them.If skipped: Posting journals without a fiscal year defined throws 'no open fiscal year' errors and blocks the opening-balance entry.
  • Configure inventory valuation method per product.category. Inventory → Configuration → Product Categories → Costing Method. Pick Standard Price, Average Cost (AVCO), or First In First Out (FIFO) per category. Switching after stock.quant rows exist requires recomputing valuation across history.If skipped: FIFO retroactively applied to AVCO inventory produces non-deterministic valuation that finance cannot tie back.
  • Create stock.warehouse and stock.location records used by source data. Inventory → Configuration → Warehouses, then Locations. Each warehouse creates its own stock.location tree (Stock, Input, Output, Quality Control). Pre-create supplier, customer, inventory adjustment, scrap, and any custom sub-locations before stock.quant load — stock.quant references stock.location by external ID.If skipped: Missing stock.location records cause every stock.quant row to fail and leave on-hand at zero.
  • Create uom.category and uom.uom records used by source products. Settings → Technical → Units of Measure. Each uom.uom belongs to one uom.category (Weight, Volume, Unit, Length, Time). Conversion ratios are within-category only. Pre-create all custom units before importing products.If skipped: Importing a product against a uom that does not exist defaults it to 'Units' and silently corrupts every subsequent stock movement quantity.
  • Create res.currency.rate seed rows for every currency in scope. Accounting → Configuration → Currencies → Rates. Each foreign currency needs at least one res.currency.rate row dated on or before the earliest historical document. Without a dated rate, journal entries in that currency cannot post.If skipped: Missing res.currency.rate rows block every multi-currency document and force a re-load after rates are seeded.
  • Configure account.tax records via the localization or manually. l10n_* installs the country's standard taxes. Verify rates and accounts, and add any custom taxes (city, state, withholding) before importing invoices that reference them.
  • Create custom fields on the target models 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 100k-row load forces a transform rebuild and re-import.
  • Set ir.attachment storage location and confirm per-file cap. Odoo's default per-attachment cap is 64 MiB on Odoo Online and 128 MiB on on-prem/Odoo.sh. For larger files configure the attachment store on the filesystem and update the limit via ir.config_parameter web.max_file_upload_size.If skipped: Files over the cap fail silently in batch imports and leave records with broken document references.
  • Configure a dedicated migration user account. Create a dedicated user (e.g. 'migration_bot') with admin rights. All bulk-load operations run as this user 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 users can and cannot do during the freeze (no posting invoices, no stock moves, no PO receipts).
  • Schedule role-segmented training on Odoo basics. Accounting (chart of accounts, journals, reconciliation), Inventory (transfers, scrap, lot tracking), Manufacturing (BOMs, work orders), Sales/Purchase (quotations, RFQs). Record each session.
  • Designate first-responder support for the first 72 hours post-cutover. Name one finance, one inventory/ops, and one IT lead on call. Publish the escalation contact and the channel where users report issues.If skipped: Without named responders the inevitable cutover-day questions land in random inboxes and lose audit trail.
2. Source Export16 tasks
  • Export all source customers and vendors with every standard and custom field. Include the source's primary key as a column — this becomes the Odoo external ID. Capture VAT/tax-ID, payment terms, and price list assignment.If skipped: Forgetting the source ID column makes idempotent re-runs impossible and forces full re-imports.
  • Export the source chart of accounts with account code, name, type, and parent. This is the input to mapping into account.account. Capture currency_id per foreign-currency account.
  • Export the closing trial balance as of the cutover cut date. Per-account debit and credit totals for the closing of the period before cutover. This becomes the opening-balance journal entry in Phase 3.If skipped: An unsigned or untimed trial balance produces an opening journal that finance cannot trace back to a source document.
  • Export open AR invoices with line detail. Include invoice number, date, due date, partner, currency, lines with account, tax, and amount, plus current residual. Closed invoices stay in the legacy system unless the historical window says otherwise.
  • Export open AP bills with line detail. Same shape as AR. These become posted account.move records of type 'in_invoice' in Odoo.
  • Export posted journal entries inside the historical window. If the historical-data window in Phase 0 includes posted prior-year journals, export them as account.move plus account.move.line rows. Include journal code, date, partner_id, account code per line, debit, credit, currency.
  • Export products with template, variant, BOM, and routing data. Separate files for product.template, product.product (variants), product.attribute, mrp.bom, mrp.bom.line, and mrp.routing. Capture cost, list_price, uom_id, uom_po_id, and the responsible employee.
  • Export stock-on-hand per location, lot, and serial. This becomes the stock.quant opening file. Each row needs product, location, quantity, lot/serial number (if tracked), reserved quantity, and valuation cost.If skipped: Missing the lot/serial column on a serial-tracked product forces individual quant rows to be split manually post-load.
  • Export bills of materials and BOM lines. mrp.bom (header: product, qty, type) plus mrp.bom.line (component product, qty, uom). Multi-level BOMs export the full tree, not flattened — Odoo recomputes the flatten on demand.
  • Export multi-currency historical exchange rates. Capture dated rate rows per currency for every date that has a transaction in scope. Without these, foreign-currency journal entries cannot post.If skipped: Skipping historical rate export forces a fallback to today's rate and misstates every multi-currency open balance.
  • Export pricelists, payment terms, and tax codes used by source documents. product.pricelist + product.pricelist.item, account.payment.term + account.payment.term.line, account.tax. These are referenced by transactional records and must exist before load.
  • Export attachments as binaries plus a metadata manifest. Download every bill, invoice, contract, and product spec sheet. Produce a manifest CSV with source attachment ID, original filename, MIME type, file size, related model, related record ID.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, the responsible-purchaser lookup, and the ownership assignment.
  • 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 post-cutover.
  • Record the exact timestamp of every export. The delta between export time and cutover time becomes the change set 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 alongside the export. SHA-256 of each CSV and binary. The hash proves you imported the exact bytes you exported during validation.
3. Transform & Map30 tasks
  • Build a master field-mapping spreadsheet keyed on Odoo model. One sheet per Odoo model (res.partner, account.account, account.move, account.move.line, product.template, product.product, uom.uom, stock.location, stock.quant, mrp.bom, mrp.bom.line, res.currency.rate). For each row capture source field, destination field (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 per model. External ID convention: '__export__.<source_system>_<record_id>' (e.g. '__export__.netsuite_12345'). Add an 'id' column to every CSV — Odoo's load() ORM method and base_import.import use 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, to the user's manager, or leave user_id blank. Document the rule and apply uniformly.
  • 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 is 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 misstates posting periods and shifts entire quarters of revenue.
  • 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 in vendor names, addresses, and product descriptions.If skipped: Encoding mismatches surface as mojibake on partner 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 invoice memo bodies split one row into two and shift every subsequent column.
  • Convert booleans to True/False and use explicit blanks for nullable Many2one fields. Odoo's CSV importer accepts True/False, 1/0, and explicit selection values — pick one form and apply uniformly. For nullable Many2one relations use the literal empty cell, not a quoted empty string, since Odoo treats them differently.
  • Truncate source text fields that exceed Odoo column lengths. Most Char fields are sized; product internal reference, partner street, and journal code have practical limits. Truncate and flag with a sidecar column if content was lost.
  • Resolve Many2one references using external IDs, not raw IDs. For every Many2one column (partner_id, account_id, journal_id, currency_id, product_id, location_id, etc.) populate the '<field>/id' column with the target's external ID. This survives database rebuilds; 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.
  • 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 create_date. Odoo lets you set create_date on import only via the ORM with elevated permissions and the Track history during import flag. Decide: preserve the original on the source-system field, or 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 AR aging reports wrong for the first reporting period post-cutover.
  • Decide the record-ownership strategy. Map source owner email → res.users login. For unknown owners pick a single fallback: the migration_bot user, the department manager, or blank. Apply uniformly and document.
  • Decide the file-attachment strategy. Choose: re-upload binaries into ir.attachment (preserves offline access, hits the per-file 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 foreign-key constraints. Required order: res.users → res.company → res.currency → res.currency.rate → uom.category → uom.uom → account.account → account.journal → account.tax → account.payment.term → res.partner (parents first) → product.category → product.template → product.product → stock.warehouse → stock.location → stock.lot → stock.quant → mrp.bom → mrp.bom.line → account.move (opening journal) → account.move (open AR/AP) → ir.attachment.If skipped: Violating load order causes ondelete='restrict' foreign-key errors and leaves every dependent record with a null reference.
  • Map the source chart of accounts to account.account per localization. For each source account map account code, name, account.account.type (e.g. asset_current, liability_current, equity, income, expense), reconcile flag, currency_id (only for foreign-currency accounts). Internal account codes drive sorting and reporting — keep source codes only where they make sense in the destination chart.If skipped: An off-by-one in account.account.type misclassifies expenses as assets and corrupts every report rolled up from account type.
  • Prepare the opening-balance account.move as a balanced journal entry. One account.move with state='draft' containing one account.move.line per chart-of-accounts row carrying a balance, with debit and credit columns populated. Sum of debits must equal sum of credits to the cent before posting. Exclude any current-year YTD net income line that Odoo derives from period close.If skipped: Posting an unbalanced opening journal throws ValidationError and blocks every subsequent posted document.
  • Build the stock.location and stock.quant opening file. stock.quant rows seed opening on-hand per (product_id, location_id, lot_id) tuple. Include quantity, reserved_quantity (typically 0 at cutover), and inventory_quantity for adjustment. Use the inventory adjustment journal pattern, not direct UPDATE on stock.quant.If skipped: Direct writes to stock.quant without the inventory adjustment journal break Odoo's stock valuation reconciliation.
  • Build mrp.bom and mrp.bom.line files with multi-level structure preserved. mrp.bom holds the header (product_tmpl_id, product_qty, type, code). mrp.bom.line holds each component (product_id, product_qty, product_uom_id, bom_id). Phantom (kit) BOMs use type='phantom'; manufacturing BOMs use type='normal'. Do not flatten multi-level BOMs at transform — Odoo explodes them on demand.If skipped: Flattening a multi-level BOM at transform breaks the master production schedule's component requirement calculations.
  • Build the res.currency.rate dated-rows file. One res.currency.rate row per (currency_id, name=date, rate) tuple covering every historical date that has a transaction in that currency. Odoo treats the rate as effective from that date forward until the next dated rate.If skipped: Gaps in dated rates cause Odoo to fall back to 1.0 and value foreign-currency invoices at parity, producing nonsensical residuals.
  • Set fiscal year lock dates to seal closed periods. Accounting → Settings → Lock Dates → Journal Entries Lock Date and Tax Lock Date. Set both to the day before the opening journal date so no one can backdate entries into closed periods. Also set the All Users Lock Date for the prior closed year.If skipped: Without lock dates, a user can post a journal into a closed prior year and silently corrupt the opening balance.
  • Build open AR invoice files as account.move with state='posted'. Each row is one account.move with move_type='out_invoice', partner_id, invoice_date, invoice_date_due, currency_id, plus account.move.line rows for each invoice line (account_id, quantity, price_unit, tax_ids, product_id where applicable). Residual at cutover equals invoice total minus any pre-cutover payments — typically open invoices migrate at full residual since payments before cutover stay in the source.If skipped: Posting open AR with the wrong receivable account routes payments to the wrong GL and breaks AR aging.
  • Build open AP bill files as account.move with state='posted', move_type='in_invoice'. Same shape as AR but with the payable account on each move line. Include vendor bill reference (ref field) so the source bill number survives.
  • Resolve Selection field internal keys versus display labels. Odoo Selection fields (account.account.type, move_type, state) store the internal key but display the label. The importer accepts either, but mixing them 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 and leaves a null value.
  • Map uom.uom conversion ratios within uom.category. Each uom.uom belongs to one uom.category and has factor (smaller→reference) or factor_inv (reference→larger). Verify that 'Box of 12' has the right factor against the reference 'Unit'. Cross-category conversion is not supported.If skipped: Wrong uom factor multiplies or divides every stock movement quantity for that product by an order of magnitude.
  • Map product.template versus product.product split. product.template holds the abstract product (name, list_price, type, category, taxes). product.product holds the variant (template_id, attribute_value_ids, internal_reference). A product with no variants still has one product.product row per template — load both.If skipped: Loading only product.template leaves the catalog technically present but unusable because stock and BOM lines reference product.product.
  • Map account.payment and reconciliation strategy for open invoices. Decide whether partial payments before cutover collapse into the residual on the open invoice (simpler, recommended) or migrate as separate account.payment records reconciled against the invoice (preserves payment history but doubles complexity).
  • Resolve multi-company partitioning on every transactional model. Set company_id explicitly on every model that has it (account.move, product.template, stock.quant, mrp.bom). 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.
  • Decide handling for stock.lot and serial numbers. If products use lot or serial tracking (product.tracking='lot' or 'serial'), every stock.quant row must reference a stock.lot. Pre-create stock.lot records before stock.quant load.If skipped: Missing stock.lot records on tracked products cause every stock.quant for that product to fail and leave on-hand at zero.
4. Sandbox Test Migration16 tasks
  • Refresh the sandbox database from the latest production config. Use 'Duplicate Database' or rebuild the Odoo.sh staging branch from production. Confirm modules, users, l10n_*, account.journal, and stock.warehouse records match.
  • Load a representative 1–5% sample of each model into the sandbox. Use Settings → Apps → Import or the 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.
  • Test the opening-balance journal entry in sandbox. Post the full opening account.move, then run the trial balance report. Debits and credits must equal and tie to the source trial balance to the cent.If skipped: An out-of-balance opening journal blocks every subsequent posted invoice from reconciling cleanly.
  • Test stock.quant load and verify Inventory → Reporting → Stock Valuation. Run the opening stock load, then check stock-by-location reports against the source. Confirm fractional quantities (e.g. 1.36 kg) survive the dot-decimal transform.If skipped: Stock valuation that does not tie post-load forces every product category's costing method to be re-validated.
  • Test BOM explosion against a known finished good. Pick a multi-level BOM. Open Manufacturing → Products → BOM Structure. Expand the tree and compare component quantities to the source BOM.If skipped: A flattened or partial BOM produces incorrect material requirements for every future manufacturing order.
  • Test multi-currency posting against the dated rate. Post a foreign-currency invoice with an invoice_date matching a seeded res.currency.rate row. Confirm Odoo computes the amount_company_signed using the dated rate, not today's rate.If skipped: Wrong rate selection misstates every foreign-currency residual and breaks AR reconciliation.
  • Test field-by-field on 10 random sandbox records per model. Open each in the form view and compare every field to the source. Pay extra attention to Selection fields, dates, Many2one references, and tax_ids on invoice lines.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 accented character in a partner name, and a CJK product description.
  • 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 relationships (res.partner.parent_id, product.product.product_tmpl_id). Load companies first, then contacts. Open a contact and confirm the Company field is populated and clicking through opens the company record. Same for product variants under a template.
  • Test attachment download from imported ir.attachment records. Open a sample of invoices and products with attachments. Click each file and confirm it downloads with 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 and extrapolate to the production cutover budget.If skipped: Skipping a full-volume rehearsal means cutover-day surprises around throttling, timeout behavior, and storage caps.
  • Measure load throughput against the hosting tier. Odoo Online throttles aggressively per session. Plan batch sizes (50–200 records per load() call) accordingly and add exponential backoff on throttle responses. Standard performance ceiling is 2–3 sales orders per second per worker.If skipped: Aggressive parallel writes against Odoo Online trip throttling and stall the load mid-batch.
  • Have a finance domain expert spot-check 25 sandbox journal entries. Pick records they recognize. Ask them to flag anything that 'looks wrong' in account assignment, tax treatment, or currency. 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 journals and force a destructive cleanup.
  • Capture sandbox sign-off in writing before proceeding to Phase 5. Migration sponsor, finance approver, and IT confirm the sandbox passes. Without this gate the production cutover cannot start.
5. Production Cutover17 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. Re-pull the trial balance as of the freeze instant.
  • Disable Odoo automated actions and outgoing mail during the load. Settings → Technical → Automation → Automated Actions: pause every rule on the models being loaded. Disable the outgoing mail server temporarily to avoid notification storms.If skipped: Active automations during bulk load fire thousands of redundant notifications and corrupt computed-field state.
  • 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 configuration records: res.currency.rate, uom.uom, account.account, account.journal, account.tax, account.payment.term. These should already exist from Phase 1b; this step idempotently confirms and adds any new rate rows captured in the delta. Verify journal codes and tax rates against the source one more time before any account.move loads.
  • Load res.partner companies first, then contacts. Companies (is_company=True) before contacts (is_company=False with parent_id). Confirm post-load counts before continuing.
  • Load product.category, product.template, product.product, then stock.warehouse, stock.location, stock.lot. Templates before variants; warehouse and location tree before stock.quant. Pre-create every lot/serial number a tracked product will reference. Use external-ID upsert mode and capture import job IDs.
  • Load mrp.bom and mrp.bom.line. BOM headers before BOM lines. Multi-level BOMs load in topological order: leaf components first, then assemblies that reference them.If skipped: Loading mrp.bom.line before its parent mrp.bom triggers ondelete='cascade' foreign-key violations and discards the line.
  • Post the opening-balance journal entry. Load the opening account.move as draft, run the trial-balance sanity check inside Odoo, then post the entry (write state='posted' or call action_post). Lock the fiscal year for the prior period immediately after posting.If skipped: Posting the opening journal before BOMs and products exist leaves the GL balanced but disconnected from inventory valuation, producing reconciliation drift.
  • Load stock.quant opening on-hand via the inventory adjustment journal. Create one stock.inventory record (or stock.quant inventory_quantity field in 18+) per location-product, then apply to seed on-hand. Do not write directly to stock.quant in production.If skipped: Direct writes break Odoo's stock valuation accounting entries and cause the inventory account to drift from physical on-hand.
  • Load open AR invoices and AP bills as posted account.move records. AR uses move_type='out_invoice' with state='posted' and the receivable account on each line. AP uses move_type='in_invoice' with the payable account. Verify partner_id, account_id, and invoice_date match. Cross-check residual sum against open-AR and open-AP aging from the source.
  • Load posted prior-year journal entries if in scope. If the historical-data window includes posted prior-year journals, load them after the opening journal and against the locked prior fiscal year. Unlock the lock date temporarily for this load, then re-lock.If skipped: Loading prior-year journals without re-locking afterward leaves the prior period writable and exposes the opening balance to drift.
  • Load ir.attachment binaries last. Stream binaries via create() with base64-encoded datas, res_model, and res_id. Throttle to the hosting tier's throughput ceiling. Confirm one sampled file downloads correctly mid-load.If skipped: Pushing attachments above the per-file cap or beyond the hosting throughput ceiling causes silent failures that orphan the parent record.
  • Cross-check destination row counts and totals against source at each step. After every model, run search_count and compare to the export's row count. After the opening journal, run the trial-balance report and tie to source. Investigate any delta before proceeding.If skipped: Cascading row-count and total 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 automation rules and the outgoing mail server. Run one end-to-end test (create vendor bill, post, register payment) to confirm automations fire as expected.
6. Validate20 tasks
  • Reconcile the post-load trial balance to the source trial balance. Accounting → Reporting → Trial Balance for the period ending on the cutover date. Every account balance must tie to the source frozen trial balance to the cent. Investigate any delta of more than rounding.If skipped: Trial balance that does not tie is a hard fail — finance cannot sign off, and the migration is not complete.
  • Compare total record count per model between source and Odoo. Pull search_count from Odoo for res.partner, account.account, account.move, product.template, product.product, stock.quant, mrp.bom, ir.attachment. Compare each to the export row count.If skipped: Skipping count reconciliation lets multi-thousand-row drops go unnoticed until users complain.
  • Reconcile open AR and AP aging source vs Odoo. Accounting → Reporting → Partner Ledger → Receivable and Payable. Compare aging buckets (0–30, 31–60, 61–90, 90+) per partner to the source AR/AP aging.If skipped: AR/AP aging mismatch is the single most-noticed cutover defect by finance and collections.
  • Reconcile stock-on-hand per location to the source. Inventory → Reporting → Stock Valuation and Inventory → Reporting → Stock at Date. Sum stock.quant by product and location, compare to source. Tolerate only fractional-rounding drift on weight/volume UoMs.If skipped: Stock-on-hand mismatch breaks every future picking, MRP run, and inventory-valuation period close.
  • Cross-check 30–50 randomly sampled documents field-by-field. Random sample across account.move (invoices and bills), product.template, stock.quant, and mrp.bom. 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 product variant linkage on a 25-product sample. Open a sampled product.product, confirm product_tmpl_id points to the right template, and attribute_value_ids match the source variant definition.
  • Verify BOM linkage and explosion on a 10-BOM sample. Open Manufacturing → Products → BOM Structure for each sampled finished good. Expand the multi-level tree and verify component quantities match the source BOM.If skipped: Broken BOM linkage produces wrong material requirements on the first manufacturing order and ripples through every PO suggestion.
  • Verify attachment-to-record linkage on a 25-file sample. Open a sampled invoice or product, click each attachment, confirm the file downloads with the right content and is the right size.
  • Verify multi-currency exchange rate selection on a sample of foreign invoices. Open a sampled foreign-currency account.move. Confirm amount_company_signed equals amount_total × dated rate from res.currency.rate, not today's rate.
  • Confirm the historical-timestamp strategy worked. If you preserved create_date during import, confirm a sample shows the legacy timestamp. If you used a custom field, confirm that field is populated.
  • Confirm fiscal year lock dates are set as planned. Accounting → Settings → Lock Dates. Verify Journal Entries Lock Date, Tax Lock Date, and All Users Lock Date are set to the agreed period boundaries.If skipped: Forgotten lock dates leave closed periods writable and let a user backdate entries that corrupt the opening balance.
  • Run a GDPR / data-residency spot-check. Confirm the Odoo.sh region (or Odoo Online 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 an Accounting / User, an Inventory / User, and a Sales / User and confirm each sees only the records permitted by their access group and the multi-company record rule.
  • Run a SOX/SOC2 evidence capture if required. Export the audit log of every user action during the load window. File alongside the sign-off as evidence of who did what.
  • Have 3–5 power users run their daily workflow against migrated data. Accountants reconcile a bank statement against migrated AP. Inventory clerks process a transfer between locations. Manufacturing schedules a work order from a migrated BOM. Sales create a quotation against a migrated product and customer.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. Do not take 'we fixed it' on trust. Have the original UAT user re-test each must-fix issue.
  • Capture written sign-off from the finance approver and migration sponsor. Sign-off names the date, the validated trial-balance reconciliation, the open-AR and open-AP totals, the stock-on-hand totals, 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 when finance has to defend the cutover at year-end audit.
7. Post-Migration Cleanup13 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 modules map to the old workflow' cheat sheet.
  • Run role-segmented training sessions. Accounting (journals, reconciliation, period close), Inventory (transfers, scrap, valuation), Manufacturing (work orders, MPS), Sales/Purchase (quotations, vendor bills), 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: Finance 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.
  • Schedule scheduled actions for the recurring jobs. Settings → Technical → Scheduled Actions for cron jobs (invoice reminders, stock reordering, currency rate refresh from a service). Confirm each runs on the planned cadence.
  • Re-establish integrations to other systems. Banking feeds, payment gateways, EDI partners, shipping carriers, BI tools. Use a dedicated service-account user for access.
  • Disable the migration_bot user. The bulk-load credentials are no longer needed and represent an oversized access surface. Disable the user 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 to the GL.
  • Confirm the period-close workflow for the first cutover-month close. Walk finance through the first end-of-month close in Odoo: lock dates advance, recurring journals post, bank reconciliation completes, financial reports run. Capture issues for the next month.If skipped: An untested first period close becomes a fire drill at month-end and undermines confidence in the migration.
  • Schedule the 30-day post-migration retrospective. Capture what went well, what did not, 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 and at least one full period-close cycle. Capture in the migration record with the named approver. Retain the source database as a read-only archive for the documented audit window (often seven years for financial records).
  • Archive the source-system exports and the migration files to long-term storage. Encrypted cold storage retains the Phase 2 baseline, Phase 5 delta, mapping spreadsheet, and post-load sign-off for the documented retention window. Capture 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 ERP: questions

How long does migration to Odoo ERP take?

A small-business migration with under 5,000 contacts, standard modules and a single company runs four to eight weeks end-to-end including localisation setup and validation. A 200-user multi-company manufacturing migration with Studio rebuilds, multi-currency consolidation and historical inventory loads typically runs three to six months of elapsed time.

Can I migrate from SAP or NetSuite to Odoo ERP?

Yes — SAP-to-Odoo and NetSuite-to-Odoo are common ERP migration shapes. Master data, chart of accounts, products, customers, vendors, open AP/AR and on-hand inventory map cleanly; but SAP ABAP code, NetSuite SuiteScript, workflows and saved searches do not transfer and need to be rebuilt as Odoo Automated Actions, Server Actions and Studio reports.

Can I migrate from QuickBooks or Sage to Odoo ERP?

Yes, and these are usually cleaner shapes because the accounting object model aligns with account.account, account.move and res.partner one-to-one. Watch chart-of-accounts numbering against the country localisation, populate res.currency.rate for every historical foreign-currency date, and import open AP/AR as individual invoices, not as a single opening journal line.

Does Odoo ERP 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 the UI wizard and a scripted ORM load for Odoo ERP?

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. Scripted ORM loads via load() handle larger volumes, custom models and repeatable loads but respect tighter throughput throttling on Odoo Online.

How do I handle opening balances and open AP/AR invoices in Odoo?

Post opening balances as a single Miscellaneous journal entry on account.move dated the day before go-live, with debits equal to credits. Import each open customer invoice and vendor bill individually as account.move with move_type='out_invoice' or 'in_invoice' so future receipts and payments can match by document and aging reports work correctly.

What happens to inventory, BOMs and lot/serial tracking during migration?

Inventory loads as a physical inventory adjustment that posts as a stock.move into each internal location, with lots or serial numbers attached for tracked products. BOMs import as mrp.bom headers plus mrp.bom.line components bottom-up. Decide tracking per product before the first stock.move posts — Odoo blocks the change once movements exist.

Is there an undo or rollback for Odoo imports?

There is no native bulk-undo — Odoo's documentation states imports are permanent. 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 plus an import_batch_id stamp on every row.

Sources

  1. Odoo — Wikipedia
  2. Is Odoo the right ERP for my company? — r/Odoo (50M USD / 400 user evaluation)
  3. SAP wants a 20% price increase — r/NoStupidQuestions (vendor-cost exit)
  4. Replacing our legacy ERP with Odoo Enterprise — r/Odoo (brick-and-mortar SME)
  5. JTL-Wawi to Odoo migration war story — r/Odoo
  6. Migrating from Odoo.sh (Enterprise) to Self hosted (Community) — r/Odoo
  7. Export and import data — Odoo 19.0 documentation
  8. Odoo's annual major releases — r/Odoo (yearly breaking version cadence)
  9. ORM reference — Odoo 19.0 documentation
  10. Get started — Odoo 19.0 Accounting documentation (Chart of Accounts setup)
  11. Managing Parent-Child Relationships Between Partners in Odoo — Odoo Forum
  12. Export and import data — Odoo 14.0 documentation (Country/Database ID/External ID resolution)
  13. Definitive foolproof steps for a successful import — Odoo Forum (Many2many comma-separated)
  14. Upload size limit in Odoo — Odoo Forum (64 MiB Odoo.sh, 128 MiB self-hosted)
  15. Fields and widgets — Odoo 19.0 documentation (Studio)
  16. what is ondelete='cascade' in OpenERP — Odoo Forum
  17. Batch Import — Odoo Forum (Odoo Online throttling)
  18. Chart of Accounts and localisation — Odoo 19.0 Accounting documentation
  19. What Does Odoo Migration Really Cost? Transparent Pricing Breakdown — Aspire Softserv
  20. How to bulk insert record in Odoo — Odoo Forum (Model.create with list)
  21. Error when importing Journal Entry — r/Odoo (unbalanced debits/credits)
  22. Units of measure — Odoo 19.0 Inventory documentation
  23. Units of measure and BOM in Odoo version 18.2 — Odoo Forum (tracking change blocked)
  24. Manufacturing > Bill of Materials in Odoo — Odoo Forum (BOM structure)
  25. Record exchange rates at payments — Odoo Accounting multi-currency documentation
  26. Image file types supported in Odoo — Odoo Forum
  27. Base Attachment Object Store (fs_attachment) — Odoo Apps Store
  28. Import file and retain file date — Odoo Forum (create_date is upload time)
  29. OCA Audit Log — The Odoo Community Association
  30. Cannot import date field — Odoo Forum
  31. Error when importing sample data — Odoo Forum (ondelete restrict)
  32. Resellers and Implementation Partners — Odoo

Get a quote

Moving to Odoo ERP?

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

Get a quote