Skip to main content
All In One Import — Partner, Product, Sales, Purchase, Accounts, Inventory, BOM, CRM & Project — A made-to-order Odoo module  — 1/1Illustrative preview

A made-to-order Odoo module that bulk-imports partners,

products, sales, purchases, accounting entries, inventory, BOMs, CRM leads and projects from CSV/Excel — with validation, mapping and rollback.

ECOSIRE scopes, builds, installs and supports it for your database.

What is All In One Import — Partner, Product, Sales, Purchase, Accounts, Inventory, BOM, CRM & Project?

A made-to-order Odoo module that bulk-imports partners, products, sales, purchases, accounting entries, inventory, BOMs, CRM leads and projects from CSV/Excel — with validation, mapping and rollback. ECOSIRE scopes, builds, installs and supports it for your database. Built to order by ECOSIRE for Odoo 17, 18, 19 — indicative price from $999.00 USD; request a quote for a scoped proposal.

Key Features

Wizard-driven importer built as a `models.TransientModel` with OWL/XML views, mapped to the exact models you need (`res.partner`, `product.template`, `sale.order`, `purchase.order`, `account.move`, `stock.quant`, `mrp.bom`, `crm.lead`, `project.task`)
Accepts CSV and Excel `.xlsx` uploads with configurable delimiter, encoding and sheet selection, plus header-row detection
Per-model column-to-field mapping profiles you can name, save and reuse across recurring imports
Many2one resolution by external ID (`ir.model.data`), database ID, or configurable name/reference matching with a clear fallback policy
Dry-run / preview mode that reports rows that would be created vs updated, plus every validation error, without writing to the database
Idempotent upsert by external ID or a chosen unique key so re-running a corrected file updates records instead of duplicating them
Batched, savepoint-wrapped ORM transactions (`create`/`write`) so a bad batch rolls back cleanly and computed/`@api.depends` fields recompute correctly
Configurable missing-master handling: skip, raise an error, or auto-create the referenced partner, product or BOM component
Accounting-aware import respecting journals, taxes and analytic accounts, with the option to leave `account.move` entries in draft or post them
Inventory quantity loading via inventory adjustments (not direct `stock.quant` writes) so valuation and moves stay consistent
BOM import that resolves components, quantities and operations, including multi-level structures
Row-level audit log (`ir.logging`-style record) capturing status, target record and error reason per row, exportable to CSV
Access controlled via `ir.model.access.csv` and record rules so only authorized roles can run imports
Optional XML-RPC / JSON-RPC entry point so imports can be triggered from an external ETL pipeline or scheduled `ir.cron` job
Built and tested against your target Odoo 17.0, 18.0 or 19.0 (Community or Enterprise)

Built to order, done for you

No DIY setup — a working app, built, installed and supported by ECOSIRE.

  1. 1

    You order

    Start with a one-time build price. We scope it with you at kickoff.

  2. 2

    We build & install

    ECOSIRE builds, configures and installs it on your Odoo.

  3. 3

    Go live + support

    You go live in about one working week, with two weeks of go-live support. Defects in the code we deliver are fixed free of charge.

Technical Specifications

Odoo Compatibility
Odoo 17, Odoo 18, Odoo 19
Editions
Enterprise & Community
License
Licence confirmation required
Python Requirement
Python 3.10+
Database
PostgreSQL 12+

About this Product

Every Odoo rollout, migration or seasonal data load eventually hits the same wall: getting large volumes of real-world data into the system cleanly. Odoo's native import (the "Import records" action backed by base_import) is fine for a single tidy model, but it struggles the moment you need to load related records across res.partner, product.template/product.product, sale.order, purchase.order, account.move, stock.quant, mrp.bom, crm.lead and project.project/project.task in one coordinated pass. External IDs drift, many2one lookups fail silently on fuzzy names, tax and UoM columns don't map, and a half-imported batch leaves your ledger in a state nobody wants to unwind by hand. Spreadsheets from suppliers, legacy ERPs and marketplaces rarely match Odoo's expected column shapes — so the "quick data load" turns into weeks of manual cleanup.

This is a build-to-order module that ECOSIRE designs, builds and installs specifically for your database and your file formats. It is not an existing apps.odoo.com download — we scope it to the exact models, fields and edge cases you actually import. Technically, we ship a wizard-driven importer (models.TransientModel wizards with OWL/XML views) that accepts CSV and Excel (.xlsx) uploads, lets you map source columns to target fields per model, resolves many2one references by external ID, database ID or configurable name-matching, and validates every row against the target model's constraints before committing. Under the hood it uses the ORM (create/write in batched, savepoint-wrapped transactions) rather than raw SQL, so computed fields, @api.depends recomputes, sequences and access rules all fire correctly. Access is governed by ir.model.access.csv plus record rules so only authorized users run imports, and each run writes an audit log with per-row status and error reasons you can export.

The workflow is built for messy real data: dry-run/preview mode that reports what would be created or updated without writing; upsert by external ID or a chosen unique key so re-running a corrected file updates instead of duplicating; configurable handling for missing masters (skip, error, or auto-create the partner/product/BOM component); and per-model field maps you can save and reuse. For accounting imports we respect journal, tax and analytic requirements and can post or leave entries in draft; for inventory we can load on-hand quantities via inventory adjustments; for BOMs we resolve components and operations; for CRM and projects we map stages, teams and assignees. We build against your target release — Odoo 17.0, 18.0 or 19.0 — and account for Community vs Enterprise differences (some accounting and MRP behaviors differ), and we can expose the same import logic over XML-RPC/JSON-RPC if you need to trigger loads from an external pipeline.

Delivery is made-to-order. It starts with a short scoping call to confirm exactly which models, source file layouts and matching rules you need, followed by a fixed written quote. We then build on a copy of your data, run UAT on a staging database with your real files, and only deploy to production once you sign off — with a rollback plan in place. Typical delivery is one working week from confirmed scope, depending on how many models and how much field-mapping complexity is involved. Pricing starts from $999 (indicative, single-company base scope covering a core set of models); multi-company setups, large or multi-format source files, deep localization/tax requirements and high data-migration volumes increase the quoted scope. You receive the full installable source, documentation and a support window after go-live.

What you get

  • Installable Odoo module source code for your version (17.0 / 18.0 / 19.0), including `__manifest__.py`, models, views, security and access files
  • On-site or remote installation and configuration on your Odoo instance, including field-mapping profiles for your source files
  • Technical documentation covering module architecture, model coverage, mapping rules and how to extend it
  • User guide plus a live training session for the staff who will run imports
  • Post-go-live support window for bug fixes and mapping adjustments
  • UAT on a staging database using your real files, with a documented rollback plan before production deploy
  • Git repository handover with full commit history and release tags
  • Reusable saved import profiles for your recurring data loads

Who this is for

ERP implementation & migration lead

Running an Odoo go-live or moving off a legacy ERP, and needs to load partners, products, open orders, opening balances, stock and BOMs reliably from exported spreadsheets — with validation and rollback, not hand-keying.

Finance / accounting manager

Needs to bulk-import `account.move` journal entries, opening balances and reconciliation data with correct journals, taxes and analytic accounts, and wants a dry-run and audit trail before anything posts.

Operations / inventory & manufacturing manager

Regularly loads product catalogs, supplier price data, on-hand quantities and multi-level BOMs from supplier or marketplace files, and needs upserts that update rather than duplicate.

Odoo administrator / internal IT

Owns the database day to day and wants a governed, access-controlled import tool with saved mappings and an optional API entry point, instead of ad-hoc native imports run by whoever has the file.

How All In One Import — Partner, Product, Sales, Purchase, Accounts, Inventory, BOM, CRM & Project Compares

CriterionECOSIRECustom BuildCompetitorOdoo Native
Model coverageMulti-model in one coordinated pass, scoped to your needsWhatever you build and maintain in-houseFixed set of models, take it or leave itOne model per import action
Cross-record referencesExternal ID, DB ID or name matching with configurable fallbackDepends on your build effortBasic name/ID lookup, limited fallbackManual external-ID prep required
Validation & previewDry-run preview reports create/update and errors before writingOnly if you build itOften commit-then-failErrors surface mid-import
Re-run safetyIdempotent upsert by unique key, savepoint rollbackYour responsibilityVaries; duplicates commonEasy to duplicate on re-run
Audit & access controlRow-level audit log + `ir.model.access.csv` and record rulesBuild it yourselfLimited loggingNo per-run audit trail
Fit to your dataBuilt for your exact file formats and edge casesFully bespoke but you own all the workGeneric; you adapt files to itYou reshape every file to Odoo's format
Version & editionBuilt and tested for your 17/18/19, Community or EnterpriseYou handle upgradesDepends on vendor supportShips with core
Support & ownershipPost-go-live support window + full source and git handoverIn-house onlyVendor-dependent, no sourceCommunity/support channels only

Frequently Asked Questions about All In One Import

Is this an existing app I can download and install today?

No. This is a build-to-order module. ECOSIRE scopes it to your specific models, file layouts and matching rules, then builds, installs and supports it for your database. You receive the full installable source and a git repository at handover.

How long does delivery take?

Typical delivery is one working week from confirmed scope. Simple single-company imports covering a few models land toward the shorter end; broad multi-model, multi-company or heavy field-mapping work takes longer. We confirm a timeline in the written quote after the scoping call.

How does pricing and scoping work?

Pricing starts from $999 as an indicative single-company base scope. After a short scoping call we send a fixed written quote for your exact requirements. Multi-company, large or multi-format source files, deep localization/tax needs and high data volumes increase the quoted scope.

Which Odoo versions and editions do you support?

We build against Odoo 17.0, 18.0 or 19.0, on Community or Enterprise. We account for edition differences — some accounting and manufacturing behaviors differ between Community and Enterprise — and confirm your target during scoping.

What happens to support and updates after go-live?

Every engagement includes a post-go-live support window for bug fixes and mapping adjustments. Because you own the source and git repo, you can maintain it yourself afterward, or we can quote an ongoing support/version-upgrade retainer.

How do you avoid a half-imported database or duplicate records?

The importer runs in batched, savepoint-wrapped ORM transactions with a dry-run preview first, so you see exactly what would be created or updated before committing. Upsert by external ID or a unique key updates existing records instead of duplicating, and every run writes a row-level audit log.

Can it import related data across modules in one pass, not just one model?

Yes — that is the point of the build. We map and sequence the models you need (partners, products, sales, purchases, accounting, inventory, BOMs, CRM and projects) so references resolve correctly across them, with configurable handling when a referenced master record is missing.

Request a quote

All In One Import

A made-to-order Odoo module that bulk-imports partners, products, sales, purchases, accounting entries, inventory, BOMs, CRM leads and projects from CSV/Excel — with validation, mapping and rollback. ECOSIRE scopes, builds, installs and supports it for your database.

  • Wizard-driven importer built as a `models.TransientModel` with OWL/XML views, mapped to the exact models you need (`res.partner`, `product.template`, `sale.order`, `purchase.order`, `account.move`, `stock.quant`, `mrp.bom`, `crm.lead`, `project.task`)
  • Accepts CSV and Excel `.xlsx` uploads with configurable delimiter, encoding and sheet selection, plus header-row detection
  • Per-model column-to-field mapping profiles you can name, save and reuse across recurring imports
  • Many2one resolution by external ID (`ir.model.data`), database ID, or configurable name/reference matching with a clear fallback policy

Request a Quotation

Tell us about your All In One Import requirements and we'll send pricing, licensing options and a tailored proposal — usually within one business day.

No payment now. This sends a quote request to our team — we'll follow up by email with pricing and next steps.