Fiscalise Odoo customer invoices against Tanzania Revenue Authority EFD/VFD requirements without leaving the ERP. Built to order by ECOSIRE for your Odoo 17.0, 18.0 or 19.0 database, chart of accounts and tax configuration. Built to order by ECOSIRE for Odoo 17, 18, 19 — indicative price from $499.00 USD; request a quote for a scoped proposal.
Illustrative previewFiscalise Odoo customer invoices against Tanzania Revenue Authority EFD/VFD requirements without leaving the
ERP. Built to order by ECOSIRE for your Odoo 17.0, 18.0 or 19.0 database, chart of accounts and tax configuration.
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 Tanzania face a split reality: the accounting entry lives in Odoo, but the fiscal receipt lives in an EFD device or a virtual fiscal device service registered with the Tanzania Revenue Authority. In practice that means an accountant posts account.move, then re-keys the same customer, TIN, line items and VAT into a separate terminal or portal, then staples the returned fiscal number back onto the Odoo record by hand — or worse, into a spreadsheet. The two ledgers drift. A credit note issued in Odoo has no fiscal counterpart. A rejected submission is discovered a week later during a VAT return. Odoo core has no concept of fiscalisation at all: account.move gives you a posted invoice, a sequence and a QWeb PDF, and nothing that speaks to a fiscal device or carries a verification code, device serial, receipt number or signature.
ECOSIRE builds a module that closes that gap inside the ERP. We add a fiscalisation layer on account.move — new fields for the fiscal document number, verification/QR payload, device or VFD identifier, submission timestamp and a fiscal_state selection (to_submit, submitted, accepted, rejected, cancelled) — plus a dedicated tra.efd.submission model that stores every request and response payload so the exchange is reconstructable months later. Submission is triggered from the posting flow or from an explicit button, then handed to a queued job so a slow or unreachable endpoint never blocks a user's post. Tax mapping is driven off your existing ERP master data rather than hardcoded: account.tax records carry the TRA tax code, product.template carries the item classification and unit of measure mapping, and res.partner supplies the TIN and VRN, all validated with @api.constrains so a bad master-data record is caught at source instead of at the tax authority.
One posting produces both outputs. The human-readable document is a QWeb report that renders the fiscal identifiers, verification code and QR image alongside your normal invoice layout, so the customer copy and the fiscal copy can never disagree. The machine format is generated from the same recordset by a dedicated builder method, signed or wrapped per the integration's requirements, and transmitted over the vendor's HTTP interface. Rejections are first-class: the response code and message are stored on the submission record, the invoice moves to rejected and is flagged in a filtered list view, and a correction workflow lets a user fix the underlying data and resubmit under a controlled sequence rather than silently re-posting. Every state change writes to the chatter via message_post, so mail.thread becomes your audit trail. Access is governed by ir.model.access.csv plus record rules — accountants submit, a billing supervisor can retry or cancel a fiscalised document, and nobody can edit stored payloads once written.
Because the exchange happens inside Odoo, the rest of your automation keeps working. Scheduled actions (ir.cron) retry queued submissions and reconcile documents stuck in submitted, automated actions can notify a channel on rejection, and everything is reachable over XML-RPC/JSON-RPC if a POS front end, e-commerce store or third-party system needs to trigger or read fiscal status. The module targets Odoo Community and runs unchanged on Enterprise; where Enterprise is present we hook the accounting dashboard and use its reporting engine, and where it is not, the same data is exposed through standard list, pivot and QWeb views so no feature sits behind a licence.
This is a build-to-order product, not an off-the-shelf download. After a short scoping call we confirm your Odoo version (17.0, 18.0 or 19.0), your VFD or device vendor and credentials, your chart of accounts and tax structure, and the exact document types in scope — invoices, credit notes, POS receipts, multi-company or multi-branch. We then write the module against your database, package it with a proper __manifest__.py and version pin, and deliver it for UAT on a staging copy of your production data before anything touches live. Typical delivery is 2-4 weeks from confirmed scope, and you receive the full source in a git repository you own.
Owns the VAT return and the relationship with TRA. Needs every posted invoice to have a matching fiscal document, wants rejections visible the same day rather than at month end, and needs an audit trail that survives an inspection without hunting through a device's memory.
Runs day-to-day invoicing. Wants one posting to produce both the customer document and the fiscal record, no re-keying into a separate terminal, and a clear queue of rejected documents with an obvious correction path.
Responsible for the database, upgrades and integrations. Needs a properly packaged module with clean models, real access rules and no core overwrites, so the next Odoo upgrade and any parallel customisations are not put at risk.
Deciding between building in-house and commissioning. Wants the source in a git repo they own, a documented integration contract with the VFD vendor, and RPC access so POS or e-commerce channels can drive fiscalisation from outside Odoo.
| Criterion | ECOSIRE | Custom Build | Competitor | Odoo Native |
|---|---|---|---|---|
| Fit to your tax and master-data setup | Built against your live chart of accounts, `account.tax` records and partner master data after a scoping call | Exact fit achievable, but you fund the discovery, the integration research and the mistakes | Generic mapping assumptions; you bend your configuration to match the module | No fiscalisation concept exists in Odoo core at all |
| Rejection and correction handling | Stored response codes, a `rejected` state, a filtered work queue and controlled resubmission | Usually deferred to phase two and discovered as a gap after the first rejection | Often just a log line or a raised exception, with no correction workflow | Not applicable — nothing is submitted |
| Audit trail and archiving | Request/response records kept per submission, plus chatter on every state change | Depends entirely on the developer's discipline; frequently only the final status is kept | Varies widely; payloads are often not retained past the response | Standard Odoo logging only — no fiscal payloads to archive |
| Resilience when the fiscal service is down | Queued submission plus an `ir.cron` retry loop; posting is never blocked or rolled back | Commonly written synchronous on post, so an outage stops invoicing | Frequently synchronous, with retry left as a manual button | Not applicable |
| Source code and ownership | Full source in a git repository you own, with commit history and a tagged release | You own it, and you also own every future fix and version migration | Usually licence-locked to a database, sometimes obfuscated | Odoo core source, but nothing to own for this use case |
| Version support and upgrades | Pinned to your 17.0, 18.0 or 19.0 build; upgrades handled as a scoped engagement | Your team carries every major-version migration | Version support depends on the publisher's roadmap and may lag a release | Odoo upgrades itself, but the compliance gap remains in every version |
| Integration reach | Actions and fiscal status exposed over XML-RPC/JSON-RPC for POS, e-commerce and middleware | Whatever you scope and build yourself | Typically UI-only, with no documented external interface | Generic Odoo RPC exists, but there are no fiscal models to call |
| Time to a working solution | 2-4 weeks from confirmed scope, including staging UAT and a rollback plan | Months, including vendor integration research and testing cycles | Fast to install, then weeks of adaptation if the assumptions do not match | Immediate, and permanently non-compliant |
This is a build-to-order module, not an instant download. Typical delivery is 2-4 weeks from confirmed scope. The sequence is: a short scoping call to confirm your Odoo version, VFD or device vendor, tax structure and document types in scope; a written scope and fixed quotation; development against your configuration; UAT on a staging copy of your production data with a documented test script; then production install with a rollback plan. Complex multi-company, multi-branch or POS scope can extend that window, and we say so in the quotation rather than after the fact.
Delivery includes a post-go-live support window for defect fixes and configuration adjustments within the delivered scope. Beyond that we offer a support and maintenance agreement covering fixes and version upgrades when you move between Odoo major versions. Because the fiscal interface is set by the authority and your VFD vendor, changes on their side are handled as a scoped change request — we do not monitor them on your behalf unless a support agreement says we do.
The module targets Community and runs unchanged on Enterprise. All fiscal data is exposed through standard list, pivot and QWeb views, so no capability sits behind an Enterprise licence. Where you do have Enterprise, we hook the accounting dashboard and use its reporting engine so fiscal status appears where your accountants already look.
Odoo 17.0, 18.0 and 19.0. We build against one target version — the one your production database runs — and pin it in the `__manifest__.py`. If you are mid-upgrade, tell us at the scoping call and we will scope the build against the version you will be on at go-live, or quote both.
The authority's response code and message are stored on the `tra.efd.submission` record, the invoice moves to `rejected` and appears in a filtered list view with a search filter, and the chatter records the event. A correction workflow lets a user fix the underlying master data or line detail and resubmit under a controlled sequence. The failed attempt is retained, never overwritten, so the full history stays reconstructable.
We extend rather than overwrite: new models, inherited views and computed fields, with no monkey-patching of core accounting methods where an inheritance hook exists. Access is governed by `ir.model.access.csv` and record rules rather than by loosening core security. During scoping we review your installed custom modules and flag any overlap on `account.move` before quoting.
Yes. Submission actions and fiscal status are exposed over XML-RPC/JSON-RPC, so an external POS front end, webshop or middleware can trigger a submission and read back the fiscal document number and verification code. If POS receipts are in scope as fiscal documents in their own right, say so at scoping — that changes the document-type coverage and the quotation.

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.
Fiscalise Odoo customer invoices against Tanzania Revenue Authority EFD/VFD requirements without leaving the ERP. Built to order by ECOSIRE for your Odoo 17.0, 18.0 or 19.0 database, chart of accounts and tax configuration.