Odoo 19 Analytic Accounting:
Track Profitability by Project, Department & Cost Center

Your General Ledger Tells You What Happened. Analytic Accounting Tells You Why.

Your chart of accounts answers one question: how much did we spend on salaries, rent, or software licenses? It cannot answer the question that actually drives decisions: which project is profitable, which department is over budget, and which cost center is bleeding cash?

That is the gap analytic accounting fills. It lets you tag every financial transaction—invoices, expenses, timesheets, purchase orders—with one or more analytical dimensions (project, department, cost center, product line, region) so you can slice your P&L by the dimensions that matter to management.

Odoo 19 overhauled analytic accounting with a multi-plan distribution system that replaces the old single-analytic-account model. This means a single invoice line can now be split across multiple projects and multiple departments simultaneously—something that previously required ugly workarounds or third-party modules. This guide walks you through the full setup: how analytic plans work in Odoo 19, how to create and apply distributions, how to build management dashboards, and the automation patterns that eliminate manual tagging.

Understanding Analytic Plans and Distributions in Odoo 19

In Odoo 17 and earlier, analytic accounting was built around a single concept: the analytic account. Each journal item could reference one analytic account. If your business needed to track both the project and the department for the same expense, you either created compound accounts (Project A / Marketing) or installed workaround modules. The model broke down at scale.

Odoo 19 introduces analytic plans—independent dimensional axes that can each contain their own tree of analytic accounts. A single transaction can carry distributions across multiple plans simultaneously, each with its own percentage allocation.

The Data Model

How Multi-Plan Distribution Works

The key innovation is the analytic_distribution JSON field on account.move.line. Instead of a Many2one to a single analytic account, Odoo 19 stores a dictionary where keys are analytic account IDs and values are percentage allocations:

# The analytic_distribution field on account.move.line
# is a JSON dict: { analytic_account_id: percentage }

# Example: 60% to Project Alpha, 40% to Project Beta,
#          100% to Marketing department
{
    "7": 60.0,    # account.analytic.account ID=7 (Project Alpha)
    "8": 40.0,    # account.analytic.account ID=8 (Project Beta)
    "15": 100.0,  # account.analytic.account ID=15 (Marketing)
}
# Percentages are per-plan, not global.
# Projects: 60% + 40% = 100%  ✓
# Departments: 100%            ✓

Applying Analytic Distributions to Invoices, Expenses, Timesheets, and Purchase Orders

Creating plans is the foundation. The value comes from tagging transactions consistently. Odoo 19 surfaces the analytic distribution widget on every document that generates journal entries. Here is where and how each source document feeds analytic data.

Customer Invoices and Vendor Bills

The analytic_distribution widget appears on each invoice line in the form view. Users can split a single line across multiple analytic accounts from multiple plans:

# Set analytic distribution on an invoice line via code
invoice = self.env['account.move'].browse(invoice_id)
for line in invoice.invoice_line_ids:
    line.analytic_distribution = {
        str(project_alpha.id): 60.0,
        str(project_beta.id): 40.0,
        str(dept_engineering.id): 100.0,
    }

# When the invoice is posted, Odoo creates
# account.analytic.line entries:
# - 60% of line amount → Project Alpha
# - 40% of line amount → Project Beta
# - 100% of line amount → Engineering department

Timesheets

Timesheets in Odoo 19 are account.analytic.line records directly. When an employee logs time against a project task, the analytic account is set automatically from the project's analytic account configuration. The key connection:

# project.project has an analytic_account_id field
# When a timesheet is created for this project,
# the analytic line automatically inherits this account.

project = self.env['project.project'].create({
    'name': 'Project Alpha',
    'analytic_account_id': project_alpha_account.id,
    # In Odoo 19, you can also set multi-plan distributions:
    'analytic_distribution': {
        str(project_alpha_account.id): 100.0,
        str(dept_engineering.id): 100.0,
    },
})

# Every timesheet logged against this project
# will carry both the project AND department tags.

Expenses

Employee expenses (hr.expense) carry the same analytic_distribution JSON field. When the expense report is approved and the journal entry is created, the distribution flows through to the accounting entries. Configure default distributions per expense category to reduce manual input:

<record id="product_travel_expense"
        model="product.product">
  <field name="name">Business Travel</field>
  <field name="can_be_expensed">True</field>
  <field name="analytic_distribution"
         eval="{'7': 100.0, '15': 100.0}"/>
  <!-- 7 = Project Alpha, 15 = Marketing dept -->
</record>

Purchase Orders

Purchase order lines in Odoo 19 carry analytic_distribution. When the vendor bill is created from the PO (either manually or via 3-way matching), the analytic distribution propagates from the PO line to the bill line. This is critical for cost tracking—you tag once at procurement time, and the cost allocation carries through to the general ledger without re-entry.

Automating Analytic Distributions with Default Rules and Python Compute Methods

Manual analytic tagging is the #1 reason analytic data quality degrades over time. Users forget, users rush, users don't understand which project code to use. The solution: automate distribution assignment so the system fills in the right tags before users even see the field.

Distribution Models (No-Code Defaults)

Odoo 19 provides account.analytic.distribution.model—a rules engine that auto-fills the analytic distribution widget based on conditions. Navigate to Accounting → Configuration → Analytic Distribution Models:

<odoo>
  <!-- Rule: All invoices for Partner "Acme Corp"
       default to Project Alpha (60%) + Project Beta (40%) -->
  <record id="dist_model_acme"
          model="account.analytic.distribution.model">
    <field name="partner_id" ref="base.res_partner_acme"/>
    <field name="analytic_distribution"
           eval="{'7': 60.0, '8': 40.0}"/>
  </record>

  <!-- Rule: All lines using account 600000 (Purchases)
       default to Operations department -->
  <record id="dist_model_purchases"
          model="account.analytic.distribution.model">
    <field name="account_prefix">6000</field>
    <field name="analytic_distribution"
           eval="{'20': 100.0}"/>
    <!-- 20 = OPS-001 Operations -->
  </record>

  <!-- Rule: Product category "IT Services"
       defaults to Engineering department -->
  <record id="dist_model_it_services"
          model="account.analytic.distribution.model">
    <field name="product_categ_id"
           ref="product.product_category_services"/>
    <field name="analytic_distribution"
           eval="{'10': 100.0}"/>
    <!-- 10 = ENG-001 Engineering -->
  </record>
</odoo>

Distribution models match on partner, product, product category, account prefix, and company. When a user creates an invoice line that matches a rule, the analytic distribution widget pre-fills automatically. The user can still override—but the default is correct 90% of the time.

Python Compute Methods for Complex Logic

When the no-code rules engine isn't enough—for example, you need to split costs based on headcount ratios that change monthly—extend the model with a computed field:

import json
from odoo import api, fields, models


class AccountMoveLine(models.Model):
    _inherit = "account.move.line"

    @api.onchange('product_id', 'partner_id', 'account_id')
    def _onchange_analytic_distribution_custom(self):
        """Auto-assign analytic distribution based on
        custom business rules that go beyond the standard
        distribution model capabilities.
        """
        if not self.product_id or not self.move_id.partner_id:
            return

        # Example: If the partner has a default project
        # on their contact record (custom field)
        partner = self.move_id.partner_id
        if partner.x_default_project_id:
            project_account = partner.x_default_project_id \
                .analytic_account_id
            if project_account:
                dist = dict(self.analytic_distribution or {})
                dist[str(project_account.id)] = 100.0
                self.analytic_distribution = dist

    @api.model
    def _get_headcount_split(self, department_ids):
        """Compute cost split ratios based on current
        headcount per department. Used for shared cost
        allocation (rent, utilities, IT infrastructure).
        """
        Employee = self.env['hr.employee']
        total = 0
        counts = {}
        for dept_id in department_ids:
            dept = self.env['hr.department'].browse(dept_id)
            count = Employee.search_count([
                ('department_id', '=', dept_id),
                ('active', '=', True),
            ])
            counts[dept_id] = count
            total += count

        if not total:
            return {}

        # Map department → analytic account → percentage
        distribution = {}
        for dept_id, count in counts.items():
            dept = self.env['hr.department'].browse(dept_id)
            if dept.x_analytic_account_id:
                pct = round(count / total * 100, 2)
                distribution[str(dept.x_analytic_account_id.id)] = pct

        return distribution

3 Analytic Accounting Mistakes That Corrupt Your Profitability Data

Optimization Metadata