Skip to content
Get a quote

Migrate to Dolibarr ERP

Dolibarr is an open-source PHP/MySQL ERP+CRM whose migration model rewards teams that toggle the right modules, design Extra fields before import, and respect the dol_import predefined dataset layout before the first CSV is mapped.

Short answer

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

By

From Your system
DestinationDolibarr ERP
200+ sources mapped into Dolibarr ERP

What Dolibarr ERP supports, and where its import tools stop

  • Free open-source core with no per-user license fee makes it the lowest-cost entry point for small teams needing ERP and CRM in one package.
  • Self-hosted deployment gives full data ownership and eliminates vendor lock-in, especially attractive to businesses with compliance requirements.
  • Modular architecture means teams enable only the features they use, keeping the interface uncluttered and reducing learning curve.
  • Fast installation with no technical knowledge required — one reviewer set up multiple businesses in minutes using their own hosting.
REST onlyNo documented public REST API in the core product
Rate limitsNot publicly documented
ObjectSupportNote
Third Parties (Contacts, Customers, Suppliers)fullDolibarr's core contact entity stores contacts, companies, and suppliers in the same llx_societe and llx_socpeople tables. All standard fields (name, email, phone, address, country) are available and export cleanly via the predefined export profile.
Products and ServicesfullProducts and services are separate object types in llx_product with type=0 for products and type=1 for services. Pricing fields, stock levels, and VAT rates export correctly; custom fields on products are stored in extraoptions and require JSON deserialization.
Commercial Proposals (Quotes)fullProposals live in llx_proposal and link to third parties and lines. Status codes (draft, validated, signed, refused) are integer values that must be mapped to the destination system's lifecycle states.
Customer OrdersfullOrders are in llx_commande with a similar structure to proposals. Order lines reference product/service IDs that must be preserved or remapped if product catalog is not migrated in the same job.
InvoicesmappedInvoices (llx_facture) include complex relationships: lines, payments (llx_paiement), payment-to-invoice links (llx_paiement_facture), and bank transaction references. We preserve all relationships and flag any unreconciled open invoices for manual review.
Bank Accounts and TransactionsmappedBank accounts and their transaction rows (llx_bank) are migratable but Dolibarr's reconciliation state depends on matching payment records. We export all transactions with their reconciliation flags and leave unmatched items visible for post-migration cleanup.
Projects and TasksfullProjects (llx_projet) and tasks (llx_projet_task) export cleanly. Task assignees and time budgets are stored in separate tables and are included in the migration scope.
Agenda/EventsmappedCalendar events in llx_actioncomm export with date, owner, and linked objects. Recurring event rules and third-party associations are preserved; fullcal integration metadata is not migrated.
Stock/MaterialsmappedStock levels in llx_product_stock are migrated alongside product records. Warehouse locations (llx_entrepot) and stock movement history (llx_stock_mouvement) require separate export profiles and careful sequencing to avoid negative stock alerts.
Users and PermissionsmappedUser accounts (llx_user) and permission profiles (llx_rights_def) are available but password hashes are salted bcrypt — we migrate user metadata and leave passwords to be reset at destination. Active vs. disabled status is preserved.
Custom Fields (ExtraFields/ExtraOptions)mappedAny custom fields added via Dolibarr's extrafields system are stored as JSON in an extraoptions column on the parent table. We deserialize each object's extraoptions and write them as native custom properties at the destination. We flag any field-type limitations (file attachments stored as paths, not data) upfront.
AttachmentsnoneDolibarr attachments are stored as files on the filesystem with references in llx_document. We do not migrate binary file attachments as part of the standard migration scope; we export the file path references and provide a file-copy script for post-migration synchronization.
Leave Requests and HR RecordsmappedHR modules including leave requests (llx_holiday) and expense reports (llx_deplacement) are available if enabled. These are migrated with effective-dated rows and approval status flags, but HR-specific permission sets require manual reconfiguration at destination.

The Dolibarr ERP migration guide

Why teams migrate to Dolibarr

The four shapes a Dolibarr migration takes, and what makes this open-source PHP/MySQL stack easier — or harder — than the category average.

Dolibarr ERP CRM is an open-source PHP/MySQL business suite released under GPL, originally authored by Laurent Destailleur in 2003 and now governed by the Dolibarr Foundation with an active French-led international community1. The same code base ships ERP, CRM, billing, accounting, inventory, manufacturing, POS, HR and project modules — every feature is a module the administrator toggles on or off.

The typical Dolibarr customer is a small or mid-sized business — 1 to 200 employees — that wants ERP, invoicing and basic CRM without the licence cost of Odoo Enterprise, Acumatica or Microsoft Dynamics. Compared with Odoo, Dolibarr positions on a flatter learning curve, no compulsory subscription and lower hardware demands; compared with ERPNext, it positions on a much shallower PHP/MySQL stack that any LAMP-fluent administrator can self-host.

The shapes of migration that actually land on Dolibarr fall into four patterns. First, spreadsheet exits: a business graduating from Excel and Access books into a single relational database that can issue compliant invoices. Second, legacy ERP replacements — Sage 50, EBP, Ciel, QuickBooks Desktop or aging Odoo 8/10 installs — where licence renewal triggers a re-platform.

Third, multi-tool consolidation, where a small business runs a separate billing tool, CRM, stock tool and shared mailbox, and wants one system. Fourth, open-source migrations between FOSS stacks — usually from ERPNext, Odoo Community or a custom PHP app — where the project is really a re-architecture against Dolibarr's module map. A QuickBooks exit has clean third-party and product parity but messy account numbering; an Odoo migration has rich automation that does not move across.

What makes migrating to Dolibarr easier than the category average is the Module Imports tool, which accepts CSV and Excel against predefined datasets for every standard object and runs a dry-run simulator before any row is written to the database2. Direct MySQL/MariaDB access is also legitimate — practitioners routinely script the llx_* tables when the import module is too slow3.

What makes it harder than the average is the module-toggle architecture: until a module is enabled, its tables, menus and import datasets do not exist, which means import order is dictated by module activation order, not data dependency alone. The platform also relies on the Extra fields system for any custom data, which behaves differently from native fields during import and is easy to forget when sizing the project.

Workflows, scheduled jobs, ECM document trees and accounting binding rules do not import — they are rebuilt from documentation. Teams that scope for that work up front finish on time; teams that assume parity with a commercial ERP do not.

Until a module is enabled, its tables, menus and import datasets do not exist — import order in Dolibarr is dictated by module activation, not data dependency alone.

The Dolibarr data model you need to map into

Objects, Extra fields, llx_ tables, and the import-key column you'll wire on every record — the destination schema decoded.

Dolibarr's data model is a set of business objects backed by the llx_* MySQL tables — llx_societe for third parties, llx_product for products, llx_facture for customer invoices, and so on. Each object has a small set of native fields and an optional Extra fields layer for custom data3. Modules turn on additional objects; until you enable the Stock module, for example, llx_entrepot and llx_product_stock are not part of your effective schema.

Before you map a field on the source side, you need to know which destination object the row belongs on, which module owns it, what fields are required, and which value will serve as your match key on re-import. The table below summarises the objects you will touch in a Dolibarr ERP migration.

ObjectWhat it storesRequiredTier
Third parties (Societe)Customers, prospects, suppliers — one record can be all threeName, country; client/supplier flagThird Parties module (core)
Contacts / AddressesIndividual people attached to a third partyLast name; linked third-party IDThird Parties module
Products & ServicesSellable items and labour linesRef, label, type (0 = product, 1 = service)Product / Service module
Customer Invoices (Facture)Sales invoices with lines and paymentsThird party, date, lines, statusInvoices module
Supplier InvoicesAP invoices from vendorsSupplier, ref_supplier, date, linesSupplier Invoices module
Sales Orders / ProposalsQuotes and customer ordersThird party, date, linesProposals + Orders modules
Stock (Warehouses, Movements, Lots)Inventory levels, batches, serial numbersWarehouse, product, qty, movement typeStock + Product Lots modules
Bills of Materials & MOsManufacturing BOMs and Manufacturing OrdersParent product, child lines, qty, UoMBOM + Manufacturing Orders modules
General Ledger (Accounting)Chart of accounts and journal entriesAccount code, journal, debit/credit, dateDouble-entry Accounting module
Projects & TasksProjects with assignable tasks and time spentRef, label, third party (optional)Projects module

Third parties use the code_client and code_fournisseur properties as your two natural business keys — these can be auto-generated or supplied by the import5. Products use ref as the canonical reference. Invoices use ref (the document number) plus the third-party link.

For deterministic re-runs, every import dataset exposes an import_key column you populate with a value of your choice — usually a batch identifier or the source primary key. The import_key is stored alongside the record and is what lets you bulk-roll-back a specific import without affecting other data5. Plan to use it on day one of the project.

When you import, the Dolibarr import module operates in Insert or Insert-or-Update mode against the chosen dataset2. Insert-or-Update needs a column flagged as the update key on each row. Direct SQL imports bypass the module entirely and demand that you handle constraints, triggers and entity (multi-company) values yourself. Custom data lives in the Extra fields system — the catalogue below covers the types you can model and the limits to plan around.

Field typeLimitNotes
Text (varchar)255 chars by defaultStored in the object's _extrafields table
Text (long)65,535 chars (MySQL TEXT)Use for note-style fields; not indexed
Integer / DoubleConfigurable precisionSet decimal places in field definition
Date / DatetimeMySQL DATETIME rangeImport requires YYYY-MM-DD or YYYY-MM-DD HH:MM:SS22
Select listComma-separated value listInternal code differs from display label
Sellist (from table)Linked to llx_c_* dictionaryReference an existing dictionary table by foreign key
Checkbox / RadioBoolean or single-pick setStored as 0/1 or string token on import
Link (other object)ID of target llx_* tablePre-import the parent so the foreign key resolves
Computed (PHP expression)Server-side evaluatedDoes not import — recomputes from source extrafields

Relationships in Dolibarr are modelled as foreign-key columns on the child object plus, for some pairings, an llx_element_element link table that records contextual associations between two arbitrary objects. Third parties support an explicit parent / child hierarchy on parent for company groups and branches7, and contacts attach to third parties through llx_socpeople.

There is no native master-detail cascade-delete; deleting a third party leaves its invoices intact (and indeed Dolibarr blocks the delete if any non-draft document references it). The platform also supports multi-entity (multiple legal companies on one install) — every llx_* table has an entity column, and any import script that ignores it will silently load rows into entity 18.

Pre-migration prep — the work before you touch Dolibarr

What must be true on the source, the destination, and across the team before the first CSV is fed to the Dolibarr import wizard.

The single best predictor of a clean Dolibarr migration is how much work you do on the source side before the first CSV is selected in the import wizard. Practitioners on the Dolibarr forum consistently report that import failures trace to source-side data issues — bad date formats, missing dictionary codes, decimal commas instead of points — far more often than to bugs in the importer1022.

The single best predictor of a clean Dolibarr migration is how much work you do before the first CSV hits the import wizard.

Treat the source export as raw material that needs to be shaped to Dolibarr's expected formats — dates rewritten to YYYY-MM-DD, numerics with point decimal separators (not European commas), country codes resolved to Dolibarr's llx_c_country rowid or ISO code, currencies normalised to the entity's base currency or to a column the multi-currency module recognises2230.

Source-side prep

  • Audit and dedup the source database before export — duplicate third parties are the single most common post-import cleanup. Use exact-email and fuzzy name+address matching, and resolve before exporting.
  • Normalise dates and numerics — Dolibarr's import expects ISO dates and dot-decimal numerics. European comma decimals are silently truncated in some stock movement flows and break amounts in others22.
  • Map source dictionary values to Dolibarr dictionaries — payment terms, payment modes, countries, languages, VAT rates and units of measure all live in llx_c_* dictionaries. Either match by code or pre-insert any missing rows8.
  • Stamp a stable external ID on every record in the source export and plan to load it into the import_key column so re-runs and reconciliation are deterministic5.
  • Decide what is in scope for historical documents. Invoices and orders can be imported with their original dates, but every line counts as a row and Dolibarr's accounting binding has to run after the load if you want them in the GL.

Destination-side prep

  • Spin up a staging Dolibarr instance that mirrors production — DoliCloud trial, a Docker container, or a DoliWamp install on a workstation. A staging instance is non-negotiable for a dry-run9.
  • Enable every module you intend to use before importing — Stock, Product Lots, BOM, Manufacturing Orders, Multi-currency, Double-entry Accounting. The module's tables and import datasets only appear after activation.
  • Pre-create users, groups and permissions under Users & Groups → Permissions — owner assignment fails silently if a referenced user does not exist, and triggers tied to permissions will misfire6.
  • Define every Extra field on the right object with the right type — Setup → Dictionaries → Extra fields. Adding fields later forces a second import pass per row.
  • Set up the chart of accounts, fiscal year, journals and VAT rates in the Accounting module before any invoice load — invoices imported against an empty CoA cannot be bound and you will have to re-run the binding job after.

People prep

Cutover only works if humans cooperate. Lock down a source-system freeze window — typically 24 to 72 hours for a small business, longer for a multi-entity ERP — and communicate it to every department that touches invoicing, stock or purchasing. Train accounting on the journal binding flow, sales on the quote-to-invoice pipeline, and warehouse staff on the Stock movement screen before go-live. A typical SMB migration runs four to eight weeks of elapsed time including audit, mapping, dry-run and acceptance.

Import mechanisms: Module Imports, dol_import, CRUD classes, and SQL

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

Dolibarr exposes several load paths and the right one depends on dataset size, object mix, and whether you need to re-run idempotently. The Module Imports wizard covers most one-shot SMB migrations. The PHP CRUD classes handle programmatic, repeatable loads. Direct MySQL INSERT is legitimate and common when the wizard is too slow. Third-party tools sit on top and add staging or warehouse-first patterns.

Module Imports wizard

The native importer lives under Home → Tools → New import, with the Imports module enabled by default on most installs2. The wizard walks five steps: choose a predefined dataset (Third parties, Products, Customer invoices, Supplier invoices, Stock movements, etc.), pick CSV or Excel as the format, upload the source file, map each source column to a target field, then run the simulator that validates the load without writing to the database214.

Limits are infrastructure-driven, not licence-driven. The hard ceiling is PHP's upload_max_filesize, post_max_size, memory_limit and max_execution_time plus MySQL's max_allowed_packet and wait_timeout. Defaults are around 2 MB upload and 128 MB memory; large loads need 64 MB upload and 512 MB-plus memory in php.ini21. The wizard is comfortable up to roughly 20,000 to 50,000 rows per object on a tuned LAMP host before the user runs out of patience.

PHP CRUD classes

The PHP CRUD classes (Societe, Product, Facture) are available to anyone writing a script directly on the Dolibarr server: they call fetch(), mutate the object, then call create() or update() and run all business triggers correctly3. This is the safe programmatic path because it runs the same business-rule validation as the UI.

The throughput ceiling is your PHP-FPM worker count and MySQL connection pool, not any platform-imposed limit. For loads above a few tens of thousands of records, parallelise across multiple worker processes against a tuned PHP-FPM pool and respect max_input_vars.

Direct MySQL / MariaDB SQL

Direct database access is the fast path for very large loads. The official wiki explicitly endorses it: "Direct database access to read the data" is listed as one of the three legitimate methods on the Mass imports page3. The cost is that you bypass all business triggers — accounting binding, stock movement side effects, document number generation — so you must reproduce those steps yourself or run the matching reconcile scripts after the bulk load.

Third-party staging tools

Airbyte ships a Dolibarr connector; LibreOffice can write directly to the Dolibarr MySQL database via its built-in database front-end, a pattern documented on the Dolibarr wiki3. For larger projects, teams adopt a warehouse-first pattern: source data lands in PostgreSQL or BigQuery via Airbyte/Fivetran, gets transformed in SQL, then the cleaned tables drive either the PHP CRUD classes or a direct MySQL load against llx_*.

Mapping your data into Dolibarr

The longest section — because chart of accounts, opening balances, inventory and fiscal cutover are 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 trial balance ties on day two, whether stock reports match the warehouse on day five, and whether your accountant trusts the books on day thirty.

Work object by object, top to bottom of the import order: dictionaries first (countries, currencies, VAT, payment terms), then chart of accounts and fiscal year, then third parties, then products and stock, then open AP/AR, then GL opening balances, then historical documents if any.

Third parties (customers and suppliers)

Common source → Dolibarr Societe mapping
SourceDestinationNote
customer_id / supplier_idcode_client / code_fournisseurOr let Dolibarr auto-generate and store source ID in import_key
company_namenomRequired; stored in llx_societe.nom
countryfk_paysResolve to llx_c_country.rowid by ISO code8
vat_numbertva_intraStored verbatim; not auto-validated against EU VIES
customer / supplier flagclient / fournisseur (0,1,2,3)0=none, 1=customer, 2=prospect, 3=both customer+prospect
parent accountparent (llx_societe.parent)Set parent rowid; pre-import parents in a first pass7

Chart of accounts (CoA) and GL opening balances

Dolibarr ships several chart-of-accounts templates — French PCG, Belgian PCMN, Spanish PGC, a generic English template and others — installed via Accounting → Setup → Chart of accounts. Pick the template that matches your fiscal jurisdiction before you import anything that posts to the GL. The CoA lives in llx_accounting_account and is keyed on account_number (the natural account code), so your import file maps source account → Dolibarr account_number directly.

Opening balances are posted as a single journal entry on the fiscal year's opening date, debiting and crediting the right balance-sheet accounts so that trial balance equals the source on day one. The cleanest mechanism is the Manual journal entries screen (or a programmatic load against the AccountingJournal and AccountingEntry classes), with one balanced batch per fiscal year you carry forward. Do not import opening balances as customer or supplier invoices — those will inflate AR/AP aging and double-count revenue.

Open AR and AP — customer and supplier invoices

Open invoices migrate as Dolibarr customer invoices (Facture) and supplier invoices (FactureFournisseur) in draft → validated state with original issue and due dates. Each invoice imports as a header plus line rows. The trick is the ref column: invoices use auto-numbering by default, but you usually want to preserve the source document number — set the module's number mask to allow free-form references, or stamp the original number into ref_customer and let Dolibarr generate a fresh ref.

For partial-paid invoices, import the invoice with its full original amount, then post a payment for the already-collected portion against the invoice so the residual matches the source aging report exactly. Do not adjust the invoice line amounts to reflect the residual — that breaks VAT and revenue reconciliation.

Products, services, units of measure and lots

Common source → Dolibarr Product mapping
SourceDestinationNote
sku / part_numberrefRequired; unique within entity
name / descriptionlabel / descriptionlabel is required; description is long text
product typefk_product_type0 = stockable product, 1 = service
uomfk_unitResolve to llx_c_units rowid; enable Units module
selling priceprice (HT) + price_ttc + tva_txUse point decimals, not commas
cost / weighted avgpmp (Prix Moyen Pondéré)Recomputed by Dolibarr from stock movements

Stock-on-hand does not import directly into a quantity column — Dolibarr derives current stock by summing llx_stock_mouvement rows. The supported path is to enable the Stock module, create your warehouses, then post a single Stock Correction movement per product per warehouse to seed quantities to the cutover number. For product lots / batches and serial numbers, enable the Product Lots module first and stamp lot or serial onto the movement rows themselves.

European users repeatedly warn about decimal comma vs point: stock corrections accept fractional quantities for some products but silently round to integer on others, depending on UoM and Dolibarr version, and any value entered with a comma is ignored — the validation passes but no movement is written28.

Bills of Materials and Manufacturing Orders

If manufacturing is in scope, enable the BOM and Manufacturing Orders modules. A Bill of Materials is a header row (parent product, quantity, UoM) plus child component lines (component, quantity per parent, UoM). Import BOM headers first, capture the resulting rowid, then load component lines with fk_bom populated. Manufacturing Orders consume BOMs and post stock movements automatically — do not import historical MOs as discrete records; recreate open ones and let Dolibarr post the movements29.

Multi-currency, exchange rates and historical FX

Multi-currency is a separate module that must be enabled before any document references a non-base currency30. Once enabled, each third party can have a default currency, and each invoice carries multicurrency_code, multicurrency_tx (the rate at document date) and multicurrency_total_ht. For historical invoices migrated mid-year, store the original rate on each row — Dolibarr does not back-fill historical FX from any rate provider, so leaving the rate column empty defaults to today's rate and silently misstates revenue.

Fiscal year and period close

Define the fiscal year under Accounting → Setup → Fiscal year before posting any journal entries. Closed periods block posting for that range, so the sequence is: open the new fiscal year, load opening balances dated to the opening date, load open AR/AP at original dates, run the binding job to push invoices into the journal, then close prior years. Do not close before validation finishes — re-opening is a manual llx_accounting_fiscalyear UPDATE.

Historical activities, ECM documents and attachments

Events and the Agenda do not have a published bulk-import dataset; the practitioner pattern is a direct insert into llx_actioncomm against the source object's rowid10. Documents and attachments live on the Dolibarr server's /documents/ directory tree, organised by object type. Inline upload via CSV is not supported — write a script that places files under the right subfolder and inserts an llx_ecm_files row. Per-file size is gated by upload_max_filesize, often raised to 50–100 MB31.

Audit trail, ownership and original timestamps

Standard datec (creation date) and tms (modification timestamp) on most llx_* tables are writable from import datasets and from programmatic loads, so original dates can be preserved — unlike many SaaS ERPs. The fk_user_author / fk_user_modif columns hold creator and modifier user IDs; pre-provision the matching users so historical ownership lands correctly. If a referenced user does not exist at import time, the row lands with NULL ownership — fine for queries but it breaks reports that filter by user.

The pitfalls that derail Dolibarr migrations

Eight specific failure modes — ranked by impact, each tied to the exact Dolibarr 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. Practitioners running Dolibarr migrations consistently recommend a three-stage validation: a test load of 10 percent of records with stakeholder spot-checks, the full load with monitoring of row counts and journal totals, and a 30-day post-migration audit cycle. The most reliable signal is having the accountant and the warehouse lead verify their own data — they spot wrong totals faster than any reconciliation script.

Build a reconciliation queries spreadsheet that compares source and destination on the counts below. Anything outside a 0.1 percent variance on financial totals gets investigated before users get login access; a stricter bar than for CRMs because the GL has to balance to the penny.

  • Total third parties imported vs source — split by customer-only, supplier-only and both, since the client / fournisseur flags must match.
  • Total products imported vs source — and a checksum of cost prices and selling prices summed across the catalogue.
  • Stock-on-hand per warehouse per product vs source — query SUM(value) FROM llx_stock_mouvement grouped by warehouse and product, and compare against the source inventory snapshot.
  • Open AR and AP per third party — sum of unpaid invoice residuals from llx_facture and llx_facture_fourn, compared against the source aging report.
  • Trial balance per account — sum of debits and credits per account_number in llx_accounting_bookkeeping, compared against the source trial balance for the cutover date.
  • Document count per type per fiscal year — invoices, supplier invoices, orders, proposals — to catch range gaps caused by the document-number mask.
  • Extra field population rate — count NULLs per extra field per object; an unexpectedly high NULL rate means a column was dropped during wizard mapping.

On top of reconciliation, run a manual spot-check protocol: pick 30 random records across objects and verify each field against the source UI. Pick five high-value invoices and trace the full graph — third party, lines, payments, journal entries. 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 import_key.

Dolibarr does not ship a native bulk-undo. The real rollback strategy is: take a mysqldump of the entire database and a tar of the /documents/ tree before the import starts, stamp every imported row with an import_key column containing the batch identifier, and if catastrophe strikes, bulk-delete by that key (DELETE FROM llx_<table> WHERE import_key = 'batch-2026-05-27') and re-import from the cleaned source.

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

Migration partners and tools

Preferred Partners, ETL vendors, specialist migration shops — what each is good for and how to choose.

Dolibarr does not certify partners the way Salesforce or HubSpot do. Instead, the project maintains a public Preferred Partners list of consultancies and freelancers who have demonstrated production experience — NEXT GESTION, Inovea, Dolicraft, and a long tail of country-specific shops are commonly named on the official site17. DoliCloud, run by the project's founder, offers managed hosting plus migration assistance as a paid service.

Freelancers from the Dolibarr forum are a legitimate alternative for smaller projects — many post their availability under the Asking a freelance section of the Mass imports wiki page3. Expect language to skew French and Spanish on that channel; English-speaking shops cluster around Dolicraft, Atm Consulting and a handful of UK and German consultancies.

On the ETL and iPaaS side, Airbyte ships a dedicated Dolibarr source connector and is the most common choice for warehouse-first migrations3. Fivetran and Stitch do not ship a native Dolibarr connector, so teams using them write a custom HTTP source against the platform. Workato and n8n are common picks where the migration is bundled with workflow automation. LibreOffice Base is a legitimate, documented direct-write tool for small one-off loads against the MySQL backend3.

Managed-migration cost ranges vary widely with scope. A spreadsheet-to-Dolibarr move for an SMB of five to twenty people typically lands in the €5,000–€20,000 range, training included, per NEXT GESTION's published guidance for standard SMB scope. A multi-entity ERP replacement with historical accounting, multi-currency, manufacturing and 50,000+ products commonly runs €25,000–€80,000, with the upper end driven by document depth, custom module count and the number of integrations to rebuild.

For teams that want to outsource the migration end-to-end, FlitStack specialises in Dolibarr migrations and handles the dictionary mapping, Extra fields setup, chart-of-accounts alignment, GL opening balance posting, stock-correction seeding and validation work described in Sections 5 and 7 of this guide. Pricing is fixed-fee, based on record count and source platform, with separate line items for multi-entity scope and historical-document depth so the engagement is transparent before signature.

This is one of several legitimate paths — the right choice for any given team depends on whether they want a Dolibarr Preferred Partner, a freelancer from the forum, an Airbyte warehouse-first approach, or a specialist migration vendor. [Explore FlitStack →](/contact)

Dolibarr ERP migration checklist

An 8-phase task list for migrating an existing ERP or accounting system into a self-hosted or DoliCloud Dolibarr instance using its module architecture and Import tool. Typical timeline: 4–16 weeks.

0. Decide & Plan9 tasks
  • List every object in scope by Dolibarr module. Map source objects to Dolibarr modules you intend to enable: Third Parties, Products/Services, Stocks, Customer Invoices (Facture), Supplier Invoices (FactureFournisseur), Proposals (Propal), Orders, Projects, Accounting, Users, Bank, ECM. Mark each as in-scope or out-of-scope.If skipped: Undocumented scope produces mid-cutover surprises when a source object has no enabled destination module to receive it.
  • Decide the Dolibarr deployment model. Pick one: self-hosted on your own LAMP/LEMP stack (DoliWamp, DoliDeb, DoliRpm, Docker image, or zip), shared web hosting, or DoliCloud. The choice fixes PHP version, MySQL/MariaDB or PostgreSQL backend, and what php.ini limits you can change.If skipped: Shared hosting with locked php.ini caps your upload_max_filesize and memory_limit and silently blocks large CSV imports later.
  • Decide whether to run a single-entity or multi-entity install. Enable the Multi-company module only if you must isolate legal entities in one install. Multi-entity changes table behavior and the upgrade path.If skipped: Switching from single to multi-entity after data is loaded requires manual re-keying of entity columns across llx_ tables.
  • Define the historical-data scope. Decide how many fiscal years of invoices, supplier invoices, payments, stock movements, and journal entries are in scope. Decide whether closed periods come over as posted documents, as opening balances only, or as an external archive.If skipped: Importing 7+ years of closed-period invoices into a fresh install bloats llx_facture and the bound journal, slowing month-end forever after.
  • Identify GDPR and accounting-retention obligations. Document EU GDPR data-subject rights (access, rectification, erasure, portability) and the legal retention window for invoices and accounting records in each operating country. Confirm where the Dolibarr database and document storage will physically sit.If skipped: Hosting a self-hosted instance outside the EU without documented safeguards triggers GDPR cross-border transfer obligations after go-live.
  • Name a single accountable migration owner and a finance approver. The owner runs the punch list. The finance approver signs the opening trial balance and the post-load reconciliation in writing.
  • Write the success criteria. Define what must be true to declare the migration complete: e.g. opening trial balance ties to source by zero, every open AR/AP invoice exists in Dolibarr with matching balance, stock-on-hand per warehouse matches source.If skipped: Without written success criteria, the migration drifts into a multi-month tail of one-off fixes.
  • Set the cutover window and the source-system freeze. Pick a date that aligns with a fiscal period boundary. Communicate the freeze to all source-system users at least two weeks ahead.If skipped: Cutting over mid-period forces a manual delta reconciliation of partial-month transactions.
  • List out-of-scope items explicitly. Examples: legacy custom reports, paper-only attachments, archived users with no future role, departments closing within the year. Publish the list so it cannot be re-litigated later.
1. Pre-Migration Prep21 tasks
  • Export current record counts per source object as a baseline. Capture counts for customers, suppliers, contacts, products, AR invoices, AP invoices, payments, stock movements, journal entries, users. Save as the Phase 6 reconciliation baseline.
  • Run a deduplication pass on customers and suppliers. Match on normalized name + VAT/tax ID + email. Resolve duplicates in the source before export, because Dolibarr's Import tool does not auto-merge third parties.If skipped: Duplicate third parties carry forward to duplicate invoices and split AR aging across two records of the same customer.
  • Standardize email casing, phone-number format, and ISO country codes. Lowercase emails, E.164 phones, and ISO 3166-1 alpha-2 country codes. Dolibarr stores country as a code referencing llx_c_country.If skipped: Free-text country strings fail to match the llx_c_country dictionary and land as NULL country on third parties.
  • Resolve records with missing required fields at source. Third Parties need at minimum a name. Customer invoices need a date, third party, and at least one line. Fix these in source rather than at transform time.
  • Standardize date formats to ISO-8601 in every export. Dolibarr's Import tool is strict about date format and surfaces 'Date format' errors when locale-specific formats arrive.If skipped: DD/MM/YYYY vs MM/DD/YYYY ambiguity silently flips months and creates back-dated invoices.
  • Provision a production and a sandbox Dolibarr instance on identical versions. Pin both to the same minor release. Use a recent stable line and confirm PHP version compatibility before you start.If skipped: A sandbox on an older minor build hides import-tool fixes and produces different errors than production.
  • Raise PHP upload_max_filesize, post_max_size, and memory_limit on both instances. The Dolibarr Import wizard uploads CSV/Excel through PHP and is bounded by php.ini. Set values that cover your largest expected file plus headroom.If skipped: Default PHP caps abort large product or invoice-line imports halfway with a generic upload error.
  • Enable required modules at Home → Setup → Modules/Applications. Toggle Third Parties, Products, Services, Stocks, Warehouses, Proposals, Customer Orders, Customer Invoices, Supplier Invoices, Bank/Cash, Accounting, Multicurrency (if needed), Product Lots, BOM, Manufacturing Orders, Projects, ECM, and Import.If skipped: Importing into a module that is not enabled writes to no table and the rows vanish.
  • Configure the company card at Setup → Company/Organization. Set legal name, address, country, default currency, fiscal year start month, and tax/VAT identifiers. These propagate into invoice numbering, accounting masks, and PDF templates.If skipped: Changing the default currency after invoices are loaded breaks the multicurrency historical-rate columns.
  • Set the company timezone and verify the database server timezone matches. Mismatched PHP timezone and MySQL/MariaDB timezone produce off-by-an-hour timestamps on log_t fields.
  • Enable Extra fields on every object that needs custom columns. Navigate to Home → Setup → Dictionaries → Extra attributes (or the per-object Setup → Extra fields page). Create the field, type, length, list-of-values, and required flag before any import.If skipped: Importing into an extra field that does not yet exist drops the column silently in the Dolibarr Import tool.
  • Recreate picklists in dictionaries (llx_c_* tables). Customer type, prospect status, payment terms, payment modes, shipping methods, units of measure, civility, civility codes — all live in dictionary tables under Setup → Dictionaries. Add any source values that are missing.If skipped: Source picklist values with no match in the dictionary land as NULL or as the default fallback, distorting reports.
  • Create warehouses under Setup → Warehouses. Stock movements reference a warehouse ID. Without warehouses pre-created, stock import has nothing to attach to.
  • Activate the Multicurrency module if more than one currency is in scope. Enable it before importing any third party or invoice. Set the list of allowed currencies under Setup → Currencies.If skipped: Turning Multicurrency on after invoices are loaded leaves historical multicurrency columns NULL and breaks FX reporting.
  • Provision all users with the correct group memberships and permissions. Create users under Users & Groups, assign groups, and grant per-module permissions. Imports executed by an under-permissioned user fail silently on the protected tables.
  • Configure the chart of accounts under Accounting → Setup. Pick a country accounting plan (e.g. PCG for France, PCMN for Belgium, PGC for Spain) or load a custom one. Confirm the fiscal year periods are defined for the migration year and the prior closed year.If skipped: Posting journals without periods defined throws 'no open fiscal year' errors and blocks the opening-balance entry.
  • Pause all third-party integrations and scheduled jobs on the destination. Disable any scheduled job or email-collector module that might fire on imported records. Re-enable only in Phase 5.If skipped: An active email-collector fires on every imported invoice and floods customers with go-live emails.
  • Take a full database + filesystem backup of the empty destination. mysqldump (or pg_dump) plus a tarball of the documents directory and conf.php. This is the clean rollback point.If skipped: Without a known-clean snapshot, a failed test load contaminates the prod instance and forces a reinstall.
  • Communicate the source-system freeze date to every user in writing. Include the exact local time, what 'frozen' means (read-only vs. no writes vs. full lockout), and where to direct urgent requests.If skipped: Last-minute writes to the source after the export window create a delta that never gets reconciled.
  • Schedule end-user training on Dolibarr basics by role. Separate sessions for sales (proposals, orders, third parties), accounting (invoices, payments, ledger), warehouse (stock, lots, movements), and admin (modules, dictionaries, users).
  • Designate first-responders for the 48 hours post-cutover. Name a primary and backup who triage user-reported data issues and have the access to fix them directly in the database or via the UI.
2. Source Export16 tasks
  • Export third parties (customers, suppliers, prospects) to CSV. Include name, supplement name, address lines, ZIP, city, country code, phone, fax, email, VAT number, customer/prospect/supplier flag, legal form code, payment terms, and every custom field. UTF-8 encoding.If skipped: ANSI/Windows-1252 source files corrupt non-ASCII names (é, ñ, ö) on import and require a re-export.
  • Export contacts and their links to third parties. Contacts are a separate object in Dolibarr (Socpeople). Export with a foreign key column pointing back to the third-party external ID.
  • Export products and services with all attributes. Ref, label, description, type (product vs. service), price, VAT rate, weight, dimensions, default warehouse, default unit of measure, supplier ref(s), accounting codes (sell, buy), barcode, and every extra field.
  • Export product lots / serial numbers and their batch metadata. Lot number, product ref, manufacturing date, sell-by date, eat-by date. Skipping this loses traceability for any regulated product.If skipped: Re-creating lots manually after invoices reference them produces orphan rows in llx_product_lot.
  • Export current stock levels per product per warehouse. These become the opening stock movement transactions in Phase 5, not direct UPDATEs to llx_product_stock.If skipped: Directly writing stock totals bypasses the movement audit trail and breaks future reorder reports.
  • Export customer invoices (Facture) with all header and line fields. Invoice ref, date, due date, third-party external ID, currency, multicurrency rate, total HT, total VAT, total TTC, status, paid status. Export lines separately with FK to header ref.
  • Export supplier invoices (FactureFournisseur) with header and lines. Mirror the customer-invoice export structure for AP. Include supplier ref number (their invoice number, not yours).
  • Export proposals and customer orders with lines. Only if in scope. Status mapping in Phase 3 will translate source pipeline states to Dolibarr status codes.
  • Export payments and bank reconciliation history. Payment date, amount, payment mode (check, transfer, card, cash), bank account, and the invoice(s) the payment is allocated against.If skipped: Loading invoices without payments leaves every closed invoice showing 'unpaid' and breaks the AR aging.
  • Export the general ledger trial balance as of the cutover 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.
  • Export historical journal entries if posted history is in scope. Account code, debit, credit, date, journal code, narration, third-party reference. Group rows by journal entry number.
  • Export user list with roles, groups, and reporting structure. Login, email, first name, last name, group memberships, active flag. Strip passwords; Dolibarr will issue new ones at first login.
  • Export agenda events, notes, and per-record comments. Dolibarr stores agenda events (llx_actioncomm) and per-object notes (note_private, note_public). Export with the parent object's external ID so they can be re-linked.If skipped: Notes loaded without a parent FK end up as orphan rows visible only by direct SQL query.
  • Export attachments and document binaries with their parent references. Pull the binary files plus a manifest CSV mapping each file to source object type + source ID. Preserve original filenames and MIME types.
  • Screenshot and document source automations, reports, and dashboards. These are rebuilt manually in Dolibarr's report module and via custom triggers. Capture the specification now so Phase 7 has a target.
  • Record the exact timestamp of every export. Per-file timestamp + per-object source count. The cutover delta will be measured against this.
3. Transform & Map25 tasks
  • Build a master mapping spreadsheet, one tab per object. For each source field record: destination object, destination column (or extra field), data type, length, required flag, transformation rule, default if NULL. Reference llx_ table column names where helpful.If skipped: Without a single mapping source of truth, transforms drift across people and re-runs produce different results.
  • Decide an external ID strategy for every object. Use the Dolibarr 'ref' (or 'ref_ext') column as the upsert key. Pre-stamp every source row with the value you want to land there.If skipped: Without a stable external ID, a re-run inserts duplicates instead of updating the row from the prior attempt.
  • Resolve picklist value mismatches against llx_c_ dictionaries. Map source customer types, prospect statuses, payment terms, payment modes, and units of measure to the dictionary codes Dolibarr stores. Add missing dictionary rows before import, not during.
  • Decide handling for source fields with no Dolibarr equivalent. Three options per field: drop, concatenate into note_private/note_public, or create an Extra field. Document the choice on the mapping sheet.
  • Convert all dates to YYYY-MM-DD. The Dolibarr Import tool flags non-ISO dates as 'Date format' errors. Convert in your scripting tool of choice before upload.If skipped: Mixed date formats in one column produce a partial import where some rows convert and some are rejected.
  • Convert decimal separators to a single canonical form. European-locale source files often use comma as decimal separator. Dolibarr's Import tool expects dot. Stock corrections and currency amounts both silently fail with a comma decimal.If skipped: Comma-decimal stock quantities accept the row but ignore the fractional part, dropping inventory accuracy.
  • Re-encode every CSV/XLSX file as UTF-8. Save with BOM-less UTF-8. Verify by inspecting a file with non-ASCII characters in a hex editor or a UTF-8-aware viewer.If skipped: Windows-1252 or Latin-1 source files corrupt diacritics on import and the corruption is invisible until a customer sees their name wrong.
  • Truncate or split fields that exceed Dolibarr column lengths. Check the destination column type (VARCHAR(255), TEXT, etc.) per the Dolibarr database documentation. Truncate or chunk into notes.
  • Escape commas, double quotes, and newlines in CSV cells. Wrap fields containing the delimiter in double quotes and escape embedded quotes by doubling. Better yet, switch to XLSX where supported.If skipped: An unescaped comma in a company name shifts every downstream column by one and corrupts the row silently.
  • Strip HTML tags from text fields that will not render as rich text. Description fields that came from a WYSIWYG source may contain markup Dolibarr will display verbatim.
  • Normalize VAT/tax-ID format per country. Strip spaces and dashes, capitalize country prefix where the source omitted it.
  • Stamp every parent record's external ID onto its children before export. Contact rows must carry the parent third-party ref. Invoice line rows must carry the parent invoice ref. Lots must carry the parent product ref.If skipped: Children loaded without a resolvable parent ref end up orphaned and invisible to the parent's tabs.
  • Decide and implement the timestamp strategy. Dolibarr stamps datec (creation date) on insert. To preserve the source creation date, write it to an Extra field named source_created_at and accept that datec will read as the import date.If skipped: Reports filtered by datec will look like the entire business was founded on import day.
  • Decide and implement the ownership strategy. Two patterns: best-match source owner email to a Dolibarr user (fk_user_author / fk_user_resp), or assign everything to a single 'data-migration' user and reassign post go-live.
  • Decide the file-attachment strategy. Either upload binaries into the Dolibarr documents directory under the canonical path (documents/<module>/<ref>/) and let ECM index them, or store as external links in an Extra field. ECM is the native fit.If skipped: External links break when the source storage is decommissioned; binaries imported into the wrong path are invisible in the document tabs.
  • Map your source chart of accounts to the Dolibarr accounting plan. Pick the country plan (PCG for France, PCMN for Belgium, PGC for Spain, or load a custom plan). Build a source-account → destination-account spreadsheet and resolve every unmapped account before journal-load.If skipped: Unmapped accounts default to a suspense or NULL account and silently distort the trial balance.
  • Prepare the opening-balance journal entry from the source trial balance. One journal entry, dated the day before cutover, with one line per account. Debits must equal credits. Exclude any current-year P&L lines that the destination will derive automatically from posted documents.If skipped: Including a YTD net-income line double-counts current-year profit once posted invoices arrive.
  • Build the open AR file: one row per unpaid customer invoice. Use the source invoice ref as the Dolibarr ref (or ref_ext) so it ties back. Include date, due date, currency, multicurrency rate at issuance, third-party ref, total HT, total VAT, total TTC, paid amount, remaining amount.If skipped: Loading only the trial-balance AR total leaves you with no per-invoice aging and no way to apply incoming payments cleanly.
  • Build the open AP file: one row per unpaid supplier invoice. Mirror the AR structure for FactureFournisseur. Supplier invoice number (theirs) goes in ref_supplier; your internal ref goes in ref.
  • Build the products + units + lots + opening-stock-movement files. Four files: products, units of measure (verify against llx_c_units), product lots, and stock movement transactions to seed opening stock per warehouse. Each movement has a source warehouse, target warehouse, product, quantity, and movement date.If skipped: Seeding stock by direct UPDATE to llx_product_stock bypasses the movement audit trail and breaks future stock corrections.
  • Compute multicurrency historical FX rates per invoice line. Dolibarr stores multicurrency_rate, multicurrency_total_ht, multicurrency_total_tva, multicurrency_total_ttc per line. Snapshot the rate that applied on the invoice date, not today's rate.If skipped: Using today's FX rate on historical invoices distorts every realized/unrealized FX gain or loss for the year.
  • Confirm fiscal year and accounting periods are open for every date range you will post into. Under Accounting → Fiscal years, create the closed prior year (for the opening journal) and the current open year. Periods must exist before journal entries can be saved.If skipped: Posting into a period that is not defined throws an error and stops the load mid-file.
  • Map VAT rates and tax accounts to the destination's tax dictionary. Verify llx_c_tva and the VAT accounting codes on each VAT rate. Add missing rates before invoice import.
  • Translate source payment terms and modes to llx_c_payment_term and llx_c_paiement codes. Net-30, net-60, end-of-month, COD, etc. Dolibarr stores numeric codes; the import file must carry those codes, not the source label.
  • Build the customer-payment allocation file. One row per payment with the list of invoice refs it pays against. Dolibarr stores allocations in llx_paiement_facture; without this file, every imported invoice shows as unpaid.If skipped: Mass-marking invoices paid without allocation files breaks the audit chain between payment and invoice.
4. Sandbox Test Migration13 tasks
  • Load a 5% representative sample of each object into the sandbox. Use Tools → New Import for CSV/Excel uploads. Step 1 pick the predefined dataset, Step 2 upload the file, Step 3 map columns, Step 4 simulate, Step 5 run real import.
  • Run the import simulator before every real load. Dolibarr's import wizard exposes a simulation step that flags row-by-row errors without writing. Treat any simulation error as a hard stop.If skipped: Skipping the simulator means errors only surface after partial writes, leaving the table in a mixed state.
  • Validate field-by-field on 5–10 random sandbox records per object. Pick records at random per object, open the card in Dolibarr, and compare every visible field plus the extra-fields tab against the source export.
  • Test special-character handling on a non-ASCII third party. Verify names with é, ö, ñ, Arabic, or CJK characters survive round-trip from CSV through import to UI render.If skipped: Encoding bugs surface as garbled names on customer-visible PDFs after go-live.
  • Test long-string handling at the column-length boundary. Confirm descriptions and notes at or slightly over the destination column length truncate or reject as the mapping spreadsheet predicted.
  • Test parent-child link integrity. Load a sample third party, then its contacts, then an invoice with lines. Confirm each child appears in the parent's tab in the Dolibarr UI.
  • Test the opening-balance journal entry in sandbox. Post the full opening journal, 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 subsequent posted invoices from reconciling cleanly.
  • Test stock-movement seeding against current-stock targets. Run the opening stock movements, then check the stock-by-warehouse report against the source. Confirm fractional quantities (e.g. 1.36 kg) survive the dot-decimal transform.If skipped: Comma-decimal sneaks back in and Dolibarr stores 1 instead of 1.36, dropping inventory accuracy.
  • Test the attachment binary upload path. Upload a small set of files to the documents directory under documents/<module>/<ref>/ and confirm they appear in the object's Documents tab.If skipped: Wrong subdirectory paths leave binaries on disk but invisible in the UI.
  • Run a full-volume rehearsal where the sandbox allows it. Time each load step. Extrapolate against production volume to confirm the cutover window is realistic and the PHP memory_limit is sized correctly.If skipped: An untimed cutover is a guess; a 90-minute estimated load that runs 6 hours blows the freeze window.
  • Hand the sandbox to a finance user for spot-checks. Have them open ten random invoices, run a small AR aging, and pull one customer's full transaction history. Their gut says more than the row counts.
  • Take a second filesystem + DB backup of the sandbox after a clean test load. Keep this as the gold reference for diffing against production after Phase 5.
  • Get written sign-off from the migration owner and finance approver before proceeding. No production cutover starts without both signatures.If skipped: Skipping sign-off lets unresolved sandbox issues recur in production where they cost more to fix.
5. Production Cutover13 tasks
  • Confirm the source system is in read-only or fully frozen state. Verify no writes have happened in the last hour. Take a screenshot of the freeze banner shown to source users.If skipped: A late source write creates an invoice that exists in the source but not in the destination after cutover.
  • Take the final source export — the delta from the Phase 2 baseline. Re-export every object using the same scripts as Phase 2 to capture changes between baseline and freeze.
  • Take a fresh mysqldump (or pg_dump) of the empty production Dolibarr. This is the absolute rollback point if the cutover has to abort.
  • Confirm scheduled jobs and integrations remain paused. Re-check after the dump. Background jobs firing during import cause cascading side-effects.If skipped: An active job that triggers on invoice creation fires on every imported row and sends thousands of emails.
  • Load in dependency order — users first. Users, then dictionaries (any custom rows), then warehouses, then third parties, then contacts, then products, then product lots, then opening stock movements.If skipped: Loading invoices before third parties produces orphan invoices that cannot be edited until the third party arrives.
  • Post the opening-balance journal entry, then load posted prior-year journals if in scope. Verify the post-journal trial balance equals the source trial balance to the cent before any documents are loaded.
  • Load open AR invoices and AP invoices. Use the Import tool's update-if-exists mode keyed on ref/ref_ext so a re-run does not duplicate.If skipped: Insert-only mode on a re-run creates duplicate invoices that double the AR balance.
  • Load customer payments and their allocations against invoices. Payments first into llx_paiement, then the allocation rows. Confirm each invoice's remaining-amount updates as expected.
  • Load proposals, customer orders, and supplier orders if in scope. Status codes per the dictionary mapping from Phase 3.
  • Upload attachment binaries into documents/<module>/<ref>/ paths. Script the binary copy. The Dolibarr ECM module will index them and they will appear in each object's Documents tab.
  • Load agenda events, notes, and per-object comments last. These reference every other object and must come after their parents exist.
  • Capture row counts and import job IDs at every step. Diff against the source delta counts immediately. If a step shows a count mismatch, stop and diagnose before loading the next dependency level.If skipped: Pushing through a count mismatch buries the bug under three more loads.
  • Re-enable integrations and scheduled jobs only after all loads complete. Re-enable in the reverse order of disabling. Smoke-test each as it comes back on.
6. Validate15 tasks
  • Compare per-object row counts: source delta vs. Dolibarr llx_ tables. Run SQL counts directly on llx_societe, llx_socpeople, llx_product, llx_facture, llx_facturedet, llx_facture_fourn, llx_paiement, llx_stock_mouvement, llx_bookkeeping. Investigate any non-zero delta.If skipped: A silent five-row drop in invoice lines distorts revenue for the period until someone notices in the close.
  • Run the Dolibarr trial balance report and tie to source. Accounting → Reports → Trial balance, dated as of the cutover day. The delta against the source's closing trial balance should be zero.If skipped: A non-zero delta in the trial balance is a hard blocker for the first close on Dolibarr.
  • Reconcile open AR total against source. Customer → Invoices → list filtered to unpaid. Sum total remaining-amount and compare to the source AR aging total.
  • Reconcile open AP total against source. Same exercise for FactureFournisseur — unpaid filter, sum, compare.
  • Reconcile stock-on-hand per product per warehouse. Stock → Reports → Stock per warehouse. Compare against the source stock report. Any product with a delta gets a stock-correction movement, not a direct UPDATE.If skipped: Direct UPDATE to llx_product_stock to mask a delta hides the underlying transform bug and corrupts the audit trail.
  • Spot-check 25–50 random records across customers, invoices, products, payments. Compare every visible field on the Dolibarr card against the source export. Document each pass/fail.
  • Verify multicurrency invoices show the historical FX rate, not today's. Open three foreign-currency invoices from different prior periods and confirm multicurrency_rate and multicurrency_total_ttc match the source.
  • Verify product lots are linked to the right products. Open a lot, check it shows under its parent product's Lots tab. Repeat for a sample of ten.
  • Verify a sample of attachments opens correctly from the Documents tab. Click through to download. Confirm the binary is intact and the filename is preserved.
  • Verify the audit-trail strategy from Phase 3 actually held. If you used the source_created_at extra field, confirm it is populated on a sample. If you used best-match owner, confirm fk_user_author matches the expected user.
  • Run a GDPR export on a single contact to confirm portability still works. Pull a contact's complete record from the database. Confirm all linked data (orders, invoices, comments) is reachable.
  • Confirm document storage location matches the data-residency commitment. Verify the documents directory lives on the storage volume in the region required by the Phase 0 compliance decision.
  • Have 3–5 power users validate their core workflows end-to-end. Sales: create a proposal from a migrated customer. Accounting: receive a payment against a migrated invoice. Warehouse: log a stock movement on a migrated product.If skipped: Workflow-level bugs only surface during real use; finding them after go-live is 10x more expensive.
  • Document every UAT-surfaced data issue and assign an owner. Anything material gets fixed before users come in; anything cosmetic goes to a Phase 7 follow-up list.
  • Get written sign-off from the migration sponsor before opening to users. No general access until the sponsor approves in writing.
7. Post-Migration Cleanup12 tasks
  • Send the go-live announcement with login URL and support contact. Include first-login password-reset instructions and where to report data issues. Tag the first-responder rotation.
  • Run role-segmented training sessions in the first week. Sales, accounting, warehouse, admin. Record and post the sessions to the internal knowledge base.
  • Set the source system to read-only and announce the read-only date. Read-only first, not immediate decommission. Users need a reference window for the first close on Dolibarr.If skipped: Decommissioning the source the same day as cutover removes the ability to diff against it when a reconciliation question arises.
  • Rebuild reports and dashboards inside Dolibarr. Standard reports live under each module's Reports menu. Custom needs go through the Export module or custom SQL through a reporting layer.
  • Rebuild automations using Dolibarr triggers and scheduled jobs. Triggers under Home → Setup → Modules trigger configurations. Scheduled jobs under Home → Admin tools → Scheduled jobs. These do not migrate from the source.
  • Schedule daily database + documents backups. Use the Backup module under Home → System tools → Backup, plus filesystem-level snapshots of the documents directory and conf.php. Test a restore once.If skipped: An untested backup is a hope, not a backup; the first restore attempt always finds the missing file.
  • Configure data-retention purge jobs to honor the Phase 0 retention policy. Use scheduled jobs or the Purge module to delete or anonymize records past the retention window.
  • Reassign ownership from the data-migration user to real users. If you used a single placeholder owner in Phase 3, bulk-update fk_user_author / fk_user_resp to the real owners now.
  • Schedule the 30-day retrospective. Capture what went well, what didn't, and what the next major upgrade should do differently.
  • Decide and document the source-system decommission date. Typically 90 days after cutover. Confirm the source retention obligation is independently satisfied by the archived exports.
  • Archive the full set of source exports, mapping spreadsheets, and transform scripts. Long-term cold storage. Label by cutover date. These are the forensic record if a discrepancy surfaces months later.If skipped: Without archived exports, a year-end audit question about a migrated transaction has no source of truth to reference.
  • Close out the migration project formally with a final status report. Final task counts, residual issues with owners, lessons learned, and the link to the 30-day retrospective.

Questions, answered

Migrating to Dolibarr ERP: questions

How long does migration to Dolibarr take?

An SMB migration with under 5,000 third parties, a single entity and no manufacturing runs one to two weeks of focused work end-to-end. A multi-entity ERP project with historical accounting, multi-currency, BOMs and 50,000-plus products runs four to eight weeks of elapsed time including audit, dry-run, validation and training.

Can I migrate from QuickBooks to Dolibarr?

Yes — QuickBooks to Dolibarr is a common SMB shape. Customers, vendors, products and the open AR/AP aging map cleanly to Societe, Product and Facture. The chart of accounts needs manual mapping from QuickBooks account numbers to your chosen Dolibarr CoA template, and the trial balance has to be reposted as an opening journal entry.

Can I migrate from Odoo to Dolibarr?

Yes, and Odoo Community to Dolibarr is becoming common as Odoo Enterprise pricing rises. Object models align well — res.partner to Societe, product.template to Product, account.move to Facture — but Odoo automations, Studio customisations and OWL views do not transfer and must be rebuilt as Dolibarr modules or hooks.

Does Dolibarr preserve original timestamps on import?

Yes, unlike most SaaS ERPs. `datec` and `tms` columns on the `llx_*` tables are writable from both the import wizard and programmatic loads, so original creation and modification dates round-trip cleanly. Pre-provision the matching users so `fk_user_author` resolves and historical ownership lands correctly on each row.

What's the difference between the import wizard and programmatic loads for Dolibarr?

The Module Imports wizard handles roughly 20,000–50,000 rows per object on tuned PHP and is best for one-shot loads with a visual mapping step and a simulator. Programmatic loads through the PHP CRUD classes handle larger volumes, multi-entity loads and repeatable migrations but require code and respect the same business-rule validation as the UI.

Can I migrate custom fields to Dolibarr?

Yes, via the Extra fields system. Every object — third parties, products, invoices, projects — supports per-object extras defined under Setup, Dictionaries, Extra fields. Define each field with the right type before importing, otherwise mapped columns are silently dropped during the wizard's column-mapping step and the data is lost.

What happens to open invoices and GL opening balances during migration?

Open customer and supplier invoices import as Facture and FactureFournisseur records with original dates and residuals matched via payment postings. GL opening balances post as a single balanced journal entry on the fiscal year's opening date — never as fake invoices, which would inflate AR/AP aging and double-count revenue in subsequent reports.

Is there an undo or rollback for Dolibarr imports?

No native bulk-undo exists. The standard fallback is: take a `mysqldump` plus a tar of the `/documents/` tree before import, stamp every row with an `import_key` batch identifier, and if catastrophe strikes, `DELETE FROM llx_<table> WHERE import_key = 'batch-id'` and re-import from the cleaned source against a restored database.

Get a quote

Moving to Dolibarr ERP?

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

Get a quote