A build-to-order Odoo module that registers your invoices and receipts with URA's EFRIS from inside Odoo, returning the FDN, verification code and QR onto the customer-facing document. ECOSIRE scopes, builds, installs and supports it for your exact Odoo version and chart of accounts. Built to order by ECOSIRE for Odoo 17, 18, 19 — indicative price from $499.00 USD; request a quote for a scoped proposal.
Illustrative previewA build-to-order Odoo module that registers your invoices and receipts with URA's EFRIS from inside Odoo,
returning the FDN, verification code and QR onto the customer-facing document.
ECOSIRE scopes, builds, installs and supports it for your exact Odoo version and chart of accounts.
No DIY setup — a working app, built, installed and supported by ECOSIRE.
Start with a one-time build price. We scope it with you at kickoff.
ECOSIRE builds, configures and installs it on your Odoo.
You go live in about 2–4 weeks, with a post-launch support window.
Finance teams invoicing in Uganda live with a split process. The sale is recorded in Odoo, but the fiscal document is produced somewhere else — a URA EFRIS portal session, an offline client, or a spreadsheet someone re-keys at the end of the day. The result is predictable: FDNs that do not tie back to account.move records, credit notes issued in Odoo with no matching EFRIS credit application, VAT summaries that disagree between the ERP and the URA portal, and a month-end where the accountant reconciles two systems by hand. Odoo core does not know EFRIS exists. There is no Ugandan fiscal-device layer in Community or Enterprise, no FDN field on the invoice, no place to store a verification code, and the standard QWeb invoice report has no slot for a compliance QR. You can bolt on a tax group and call it VAT, but nothing in the stock product registers a document with a revenue authority or handles what comes back.
What we build is an EFRIS integration layer that lives inside your Odoo database and treats registration as part of posting, not as an afterthought. A dedicated model (typically efris.transaction) is linked one-to-one to each account.move and carries the full lifecycle: the payload we assembled, the signed request, URA's response, the FDN, verification code, QR payload, and the timestamp of each attempt. Confirming an invoice enqueues registration through a queued job or an automated action rather than blocking the user's click, so a slow or unreachable URA endpoint never freezes the accounting screen. Product and partner master data drive the payload: product.template gains the EFRIS goods/services classification code, unit-of-measure mapping and commodity category; res.partner carries TIN and buyer type; account.tax maps to the correct EFRIS tax category so exempt, zero-rated and standard-rated lines are declared exactly as they are posted. Computed fields with @api.depends keep mapped values in sync when master data changes, and a constraint blocks confirmation when a line's mapping is missing — the error surfaces at the desk, not at the revenue authority.
The response side is where most integrations fall down, so we build it explicitly. A successful registration writes the FDN, verification code and QR back onto the move and stamps a chatter message with the raw response for audit. The QWeb invoice and receipt reports are extended to render the human-readable fiscal block plus the QR image, so one posting produces both the document a customer can read and the machine record URA holds. Rejections are not swallowed: the transaction moves to a rejected state with URA's error code and message, an activity is raised on the responsible user, and a correction workflow lets finance fix the underlying data — a wrong classification code, a missing TIN, a tax mapping — and re-submit against the same move without creating a duplicate accounting entry. Credit notes route through the EFRIS credit-note flow with the reference to the original FDN carried automatically. Everything is reachable over Odoo's XML-RPC/JSON-RPC API so a POS front end, a webshop, or a third-party billing system can trigger the same code path, and access is controlled with ir.model.access.csv plus record rules so only the finance group can view credentials or re-submit a transaction.
This is a build-to-order product, not a download. EFRIS behaviour depends on your taxpayer configuration, the credentials URA issued you, the shape of your product catalogue, and whether you invoice from Sales, POS, Subscriptions or a custom flow. We start with a scoping call, confirm your Odoo version (17.0, 18.0 or 19.0), edition (Community or Enterprise — Enterprise-only dependencies are declared or avoided based on what you actually run), and your URA integration credentials and test environment. We then build against your data, deploy to a staging database for UAT with your own invoices, and only after your sign-off do we install on production with a rollback plan in hand.
Typical delivery is two to four weeks from confirmed scope. You receive the full source of the module — __manifest__.py, models, views, security rules, QWeb reports and data files — in a git repository you own, so nothing about your compliance path is locked to us. Where URA changes a schema or a field, the fix is a change in code you already hold, applied by us during your support window or by your own team afterwards.
Owns the VAT return and the month-end close. Needs every posted invoice to carry an FDN that reconciles to the URA portal, and needs rejections visible and fixable the same day rather than discovered at filing time.
Runs the Odoo instance and answers for uptime. Wants the integration to fail gracefully when URA is unreachable, to be auditable, to keep credentials out of user-visible fields, and to ship as source code in a repository the company owns.
Issues invoices and credit notes daily. Needs the compliance block and QR on the document the customer actually receives, and a correction path that fixes bad data and re-submits without voiding a legitimate accounting entry.
Reviews the compliance position. Needs a searchable, immutable record of every submission, response and correction, tied line-by-line to the accounting entries it represents.
| Criterion | ECOSIRE | Custom Build | Competitor | Odoo Native |
|---|---|---|---|---|
| Fit to your URA setup and catalogue | Built against your actual TIN configuration, product classification codes and tax mapping | Fits perfectly if your team knows both EFRIS and Odoo internals well | Generic mapping assumptions; classification and tax setup left to you | No EFRIS concept exists in Odoo core at all |
| Rejection and correction workflow | Rejected state with URA error code, activity to the owner, correct-and-resubmit on the same move | Usually deferred past v1 and built after the first bad filing | Often logs the error only; correction becomes a manual portal task | Nothing to reject — no submission takes place |
| Fiscal data on the customer document | QWeb reports extended with FDN, verification code and QR from the same posting | Achievable, but QWeb report inheritance is where DIY builds commonly stall | QR often present; layout rarely matches your existing report template | Standard invoice report has no fiscal block or QR slot |
| Behaviour when URA is slow or down | Asynchronous queued submission with idempotent retry; posting is never blocked | Frequently synchronous in v1, which freezes the invoice screen | Varies by vendor and is rarely documented before purchase | Not applicable — nothing is submitted |
| Audit trail | Every request and response persisted, mirrored to chatter, searchable and filterable | Depends entirely on how much logging the developer chose to build | Typically a status field plus a last-error string | Standard chatter only, with no fiscal record to trace |
| Source code ownership | Full source handed over in a git repository you own | You own it outright — the main advantage of DIY | Often obfuscated, licence-keyed or tied to the vendor's update channel | Odoo core source, with no EFRIS functionality in it |
| Version and edition coverage | Built and tested for your target 17.0, 18.0 or 19.0 on Community or Enterprise | One version at a time, and upgrades are your team's problem | Version support depends on the vendor's backport appetite | All versions, none of them EFRIS-aware |
| Time to a working, proven integration | Two to four weeks from confirmed scope, including UAT on staging | Months once EFRIS specification study and testing are counted honestly | Fast to install, then slow to configure and reconcile | Never — the capability does not exist |
This is a build-to-order module, so nothing ships until scope is confirmed. Typical delivery is two to four weeks from a confirmed scope — that covers development against your Odoo version and data, deployment to staging, UAT with your own invoices on URA's test environment, and the production install. Complex cases (multiple TINs, POS issuance, a custom billing flow, or migration of historical documents) can extend that, and we tell you before you commit, not after.
Every engagement includes a post go-live support window covering defects, configuration adjustments and changes URA makes to the EFRIS schema during that period. You also receive the full source in a git repository you own, so your own developers can maintain or extend the module without us. After the support window you can either handle changes in-house or continue on an ECOSIRE support agreement — the choice stays yours because the code is already in your hands.
We build for Odoo 17.0, 18.0 and 19.0, in either Community or Enterprise. The module is built for one target version per engagement so the manifest, dependencies and view inheritance are correct rather than defensively version-branched. If you run Enterprise we can use Enterprise-only features where they genuinely help; if you run Community we avoid them entirely so the module installs cleanly.
Yes. EFRIS credentials and taxpayer registration are issued to you by URA and cannot be supplied by a software vendor. We work with the credentials and test-environment access you hold and help you configure them correctly inside Odoo. Part of the scoping call is confirming what you already have, so the build is not blocked waiting on registration.
Registration runs asynchronously, so an unavailable URA endpoint does not block invoice confirmation — the transaction stays queued and retries. A rejection is stored with URA's error code and message, moves the transaction to a `rejected` state, and raises an activity on the responsible user. Finance corrects the underlying data — a missing classification code, TIN or tax mapping — and re-submits against the same accounting entry. Submission is idempotent, so retries cannot double-register a document.
Yes. The registration methods are exposed over Odoo's XML-RPC/JSON-RPC API, so anything that can create or confirm a move in Odoo can drive the same code path. If issuance from POS or a specific external system is in scope, tell us on the scoping call — it changes the payload assembly and the receipt report, and we build for it rather than retrofitting later.
No. This is built to order for your environment. EFRIS behaviour depends on your taxpayer configuration, credentials, product catalogue and invoicing flows, and a generic download cannot know any of those. We scope first, build against your actual data, prove it on staging with your invoices, and install on production only after your sign-off.

A build-to-order Odoo localization that loads Algeria's full wilaya and commune hierarchy with bilingual French and Arabic names, wired into partner addresses and reporting. ECOSIRE builds, installs, and supports it after your quotation.



A build-to-order Odoo module that lets you render any accounting report — P&L, Balance Sheet, aged reports, journals, trial balance — in a currency of your choice, with automatic conversion at the rate you define. ECOSIRE scopes, builds, installs and supports it for your Odoo 17/18/19 environment.
A build-to-order Odoo module that registers your invoices and receipts with URA's EFRIS from inside Odoo, returning the FDN, verification code and QR onto the customer-facing document. ECOSIRE scopes, builds, installs and supports it for your exact Odoo version and chart of accounts.