Skip to main content
Hide Cost Price — A build-to-order Odoo module that restricts product cost price visibility to the exact user roles you nomin — 1/1Illustrative preview

A build-to-order Odoo module that restricts product cost price visibility to the exact user roles you nominate,

hardened across form views, list views, reports, and the RPC API.

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

What is Hide Cost Price?

A build-to-order Odoo module that restricts product cost price visibility to the exact user roles you nominate, hardened across form views, list views, reports, and the RPC API. 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

Dedicated `group_view_cost_price` security group declared in `__manifest__.py`, assignable per user so cost visibility becomes a role, not a view hack
`standard_price` gated via the `groups="..."` attribute across `product.template` and `product.product` form, tree, kanban, and search views
ORM-level read guard so unauthorized users receive a masked/zeroed cost even through direct `read()` and `read_group()` calls, not just hidden inputs
XML-RPC/JSON-RPC hardening: cost fields return the masked value to external API callers outside the authorized group, closing the integration back-door
List-view export protection so unauthorized users cannot dump real cost via CSV/XLSX export
QWeb report masking on inventory valuation, margin, and sale/purchase analysis templates — cost columns render blank or "restricted" for unauthorized roles
Related cost surfaces covered: `product.supplierinfo` vendor price, `stock.valuation.layer` unit cost, and purchase price on stock moves
Configurable mask behavior chosen at scoping: blank, zero, or a literal "restricted" placeholder
`has_group()` context checks rather than hard-coded user IDs, so the rule follows your access-group assignments
Record rules and `ir.model.access.csv` entries authored to complement, not conflict with, existing product access
Upgrade-safe, idempotent inheritance that survives Odoo minor/patch updates and Studio-added views
Community and Enterprise compatible; built and tested against Odoo 17.0, 18.0, and 19.0
POS and website surfaces reviewed so cost does not leak through secondary front-ends when in scope
Automated test coverage targeting the escape hatches — export, RPC, `read_group`, and expected superuser behavior

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

Cost price is one of the most sensitive numbers in your Odoo database, yet by default it is visible to anyone who can open a product form. Salespeople, POS cashiers, warehouse operators, and external consultants all land on the product.template / product.product standard_price field with nothing standing between them and your margins. Odoo's native controls only get you part of the way there: you can gate the field behind the groups="..." attribute in a view or hide it with the Product Costs access group, but that leaves the value fully readable through list exports, invoice and inventory valuation reports, the Developer Tools inspector, and any read() call over XML-RPC/JSON-RPC. The moment a user has export rights or a bit of technical curiosity, "hidden in the view" stops being hidden.

We build a Hide Cost Price module that treats cost visibility as a first-class access-control concern rather than a UI convenience. At the presentation layer we apply groups and computed-visibility on standard_price (and related cost fields such as product.supplierinfo price, purchase price on stock moves/layers, and margin columns) across every form, tree, kanban, and search view where it surfaces. But the enforcement does not stop at the view: we add an ORM guard so that users outside the authorized security group receive a masked or zeroed cost when they read the field — including through list-view exports, read_group aggregations, and direct RPC calls — while authorized users see the real figure. This is driven by a dedicated security group defined in the manifest, wired through ir.model.access.csv and record rules, so "who can see cost" becomes an assignable role, not a scattered set of view tweaks.

Technically, the module is a clean, versioned addon: a __manifest__.py declaring the new group_view_cost_price security group and its data files, a small models/ layer that overrides the relevant read/compute paths using @api.depends and environment-context checks (self.env.user.has_group(...)), XML view inheritance to bind the groups attribute onto every cost-bearing field, and adjustments to QWeb report templates so cost columns render blank or "—" for unauthorized users on valuation, margin, and sale/purchase reports. We keep the logic idempotent and upgrade-safe so it survives future Odoo updates, and we test the escape hatches specifically — export, RPC, studio-added views, and superuser bypass expectations are all covered. It works on Community and Enterprise, and we target Odoo 17.0, 18.0, and 19.0 with a build matched to your exact edition and version.

Delivery is build-to-order. After a short scoping call we confirm precisely which cost fields, reports, and RPC surfaces must be locked, which security group(s) map to your org's roles, and how masking should behave (blank, zero, or "restricted"). We build against a copy of your configuration, validate on a staging database with a rollback plan, and hand over installable source plus a git repository. Typical delivery is one working week from confirmed scope. Pricing starts from $999 (indicative, single-company base scope); multi-company cost isolation, custom report templates, additional cost-bearing models, and stricter RPC/export hardening increase the quoted scope. You receive a fixed quote after the scoping call — never a surprise on the invoice.

What you get

  • Installable, versioned module source code built for your exact Odoo edition and version (17.0 / 18.0 / 19.0)
  • Installation and configuration on your target database, including security-group assignment for the roles you nominate
  • Technical documentation: models, security group, record rules, view inheritances, and the mask/RPC behavior
  • End-user and admin guide plus a live training session on assigning and auditing cost-visibility roles
  • UAT on a staging database with a documented rollback plan before any production change
  • Post-go-live support window for fixes and questions after deployment
  • Git repository handover with full commit history and tagged release
  • Compatibility notes covering upgrade behavior and known interactions with other cost-related addons

Who this is for

Finance / Margin Owner

CFOs and finance leads who need standard cost and margin locked to accounting and management, invisible to sales, POS, and warehouse staff, with the certainty that exports and reports don't leak the number.

Odoo Administrator

The internal admin who owns roles and security groups and wants cost visibility managed as an assignable group with clean `ir.model.access.csv` and record rules, not a fragile pile of per-view `groups` edits.

Operations Manager with External Users

Teams that grant portal, consultant, or contractor access and must ensure those users — and any RPC integration they touch — can transact on products without ever reading purchase cost.

Multi-Company / Franchise Controller

Controllers running several companies in one database who need cost isolated per company and role, so shared catalogs don't expose one entity's buying prices to another.

How Hide Cost Price Compares

CriterionECOSIRECustom BuildCompetitorOdoo Native
Cost hidden in product viewsAll form, tree, kanban, search views gated by security groupPossible, but only the views you remember to editUsually gates the main product form fieldField hideable via `groups` attribute or Product Costs group
Export / list-dump protectionMasked in CSV/XLSX export for unauthorized rolesRarely covered unless explicitly builtOften leaks via exportCost still exportable even when hidden in view
RPC / API enforcementORM read guard masks cost over XML-RPC/JSON-RPCDepends entirely on developer diligenceTypically view-only, RPC exposes real cost`read()` returns real cost to any allowed user
Report maskingQWeb valuation/margin/analysis columns masked by roleExtra bespoke work per reportSeldom touches reportsCost shown in valuation and margin reports
Role modelDedicated assignable security group + record rulesHowever the developer wires itUsually a single fixed groupProduct Costs group, coarse-grained
Upgrade safety (17/18/19)Idempotent inheritance, tested per versionMaintenance is on youVaries; may lag Odoo releasesNative, but no extra enforcement to maintain
Delivery modelBuild-to-order, installed + supported, one working weekIn-house build and maintenanceInstant download, self-installIncluded, but insufficient alone
Support & handoverTraining, docs, git repo, post-go-live windowInternal onlyVendor ticket queue, no source guaranteeCommunity/Enterprise support channels

Frequently Asked Questions about Hide Cost Price

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

No. This is a build-to-order module. ECOSIRE builds it against your exact Odoo edition and version, matched to your roles and reports, then installs and supports it. There is no instant download — you request a quotation and we build.

How long does delivery take?

Typical delivery is one working week from confirmed scope. After the scoping call we agree on the exact cost fields, reports, and RPC surfaces to lock; the timeline depends on how many models and custom reports are in scope, multi-company requirements, and staging/UAT.

How does pricing and scoping work?

Pricing starts from $999 as an indicative single-company base scope. We hold a short scoping call, then issue a fixed quote — no surprises on the invoice. Drivers like multi-company cost isolation, extra cost-bearing models, custom report masking, and stricter export/RPC hardening increase the quoted scope.

Doesn't Odoo already let me hide the cost field?

Odoo can hide `standard_price` in a view via the `groups` attribute or the Product Costs access group, but the value stays readable through list exports, valuation and margin reports, the developer inspector, and RPC `read()` calls. We enforce the restriction at the ORM and report layers as well, so hiding the field actually hides the number.

Will it work over the XML-RPC / JSON-RPC API and for exports?

Yes — that is a core reason to build it. Users and integrations outside the authorized security group receive the masked value through `read`, `read_group`, and CSV/XLSX export, not just in the on-screen form. We test these escape hatches explicitly.

What about support and future Odoo updates?

You get a post-go-live support window for fixes and questions, plus a git handover. The module is written to be upgrade-safe and idempotent. When you move to a new Odoo major version, we can quote a compatibility pass for 17.0, 18.0, or 19.0 as needed.

Does it run on Odoo Community or only Enterprise?

Both. The security group, ORM guard, and view/report masking rely on core ORM and security mechanisms present in Community and Enterprise alike. We build and test against your specific edition and version.

Request a quote

Hide Cost Price

A build-to-order Odoo module that restricts product cost price visibility to the exact user roles you nominate, hardened across form views, list views, reports, and the RPC API. ECOSIRE scopes, builds, installs, and supports it for your database.

  • Dedicated `group_view_cost_price` security group declared in `__manifest__.py`, assignable per user so cost visibility becomes a role, not a view hack
  • `standard_price` gated via the `groups="..."` attribute across `product.template` and `product.product` form, tree, kanban, and search views
  • ORM-level read guard so unauthorized users receive a masked/zeroed cost even through direct `read()` and `read_group()` calls, not just hidden inputs
  • XML-RPC/JSON-RPC hardening: cost fields return the masked value to external API callers outside the authorized group, closing the integration back-door

Request a Quotation

Tell us about your Hide Cost Price 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.