Quick facts
- Price
- $249.00 USD
- Odoo versions
- 17, 18, 19
- Setup time
- 30 min
- License
- One-time perpetual
- Languages
- 11 languages
One-time Purchase
Google Tag Manager Integration for Odoo
A build-to-order Odoo integration that pushes clean, structured analytics events from your storefront, portal, and checkout into a container-based tag management layer. ECOSIRE scopes, builds, installs, and supports it for your exact site and consent requirements.
$249.00USD
No payment now. This sends a quote request to our team — we'll follow up by email with pricing and next steps.
Key Features
Dedicated module with its own `__manifest__.py`, models, views, and `ir.model.access.csv` — no core patching, upgrade-safe against theme and other apps
Single global container-snippet injection via an inherited QWeb `<head>` template, eliminating duplicated or theme-embedded scripts
Structured `dataLayer` push contract with a documented event schema (product view, add-to-cart, remove-from-cart, begin-checkout, purchase)
Server-confirmed `purchase` event fired on `sale.order` / `website.sale` completion, not a client thank-you-page script, so refunds and refreshes don't inflate counts
Idempotency guard using a computed flag (`@api.depends`) on the order so a conversion is emitted exactly once even on retry or reload
ORM-enriched event payloads: accurate totals, currency, tax, coupon codes, and line items with `product.template` / `product.product` and category identifiers
Consent gating that maps Odoo's cookie bar (or a custom consent widget) to consent-mode signals so tags fire only after the matching category is accepted
Central configuration through `res.config.settings`: container IDs, preview/environment parameters, and per-event enable toggles managed in the Odoo UI
Environment separation (staging vs production container/preview) so test traffic never pollutes production analytics
Optional server-side controller endpoint and XML-RPC / JSON-RPC hooks for externally-triggered or back-office conversion pushes
Customer-portal and backend-triggered event support (e.g. invoice paid, subscription renewed) beyond just the public storefront
Automated-action hooks to annotate records and trigger enrichment without hand-written cron glue
Record rules and access controls so configuration is editable only by authorized users, respecting multi-website and multi-company boundaries
Built and tested against Odoo 17.0/18.0/19.0 on Community and Enterprise, with edition differences documented for your build
About this Product
Marketing and revenue teams running Odoo eCommerce and the customer portal usually hit the same wall: they need trustworthy analytics and conversion tracking, but the container-tag snippet ends up hardcoded into a theme, duplicated across pages, or firing on brittle client-side selectors that break every time the storefront markup changes. Odoo core lets you paste a <head> script through website settings, but it has no structured dataLayer, no server-confirmed purchase events, no consent gating tied to the visitor's cookie choice, and no way to enrich events with real order, product, or partner data from the ORM. The result is under-counted conversions, double-fired events, and ad spend optimized against numbers nobody trusts.
Why Choose Google Tag Manager Integration for Odoo
Dedicated module with its own `__manifest__.py`, models, views, and `ir.model.access.csv` — no core patching, upgrade-safe against theme and other apps
Single global container-snippet injection via an inherited QWeb `<head>` template, eliminating duplicated or theme-embedded scripts
Structured `dataLayer` push contract with a documented event schema (product view, add-to-cart, remove-from-cart, begin-checkout, purchase)
Server-confirmed `purchase` event fired on `sale.order` / `website.sale` completion, not a client thank-you-page script, so refunds and refreshes don't inflate counts
Idempotency guard using a computed flag (`@api.depends`) on the order so a conversion is emitted exactly once even on retry or reload
ORM-enriched event payloads: accurate totals, currency, tax, coupon codes, and line items with `product.template` / `product.product` and category identifiers
This is a build-to-order integration that ECOSIRE designs, develops, installs, and supports for your specific Odoo deployment — it is not an existing app you download and self-install. We build a dedicated module (its own __manifest__.py, models, views, and ir.model.access.csv security rules) that injects your container snippet once, globally, via an inherited QWeb <head> template, and then emits a well-typed dataLayer event stream for the moments that matter: product views, add-to-cart, begin-checkout, and — critically — a purchase event pushed on confirmed sale.order / website.sale completion rather than a fragile thank-you-page script. Because the events originate from the server, they carry accurate order totals, currency, line items with product.template and product.product identifiers, tax, and coupon data straight from the ORM.
Technically, the module centralizes configuration in a settings model (extending res.config.settings) so container IDs, environment/preview parameters, and per-event toggles are managed from the Odoo UI instead of edited in code. We wire consent handling so tags only fire once the visitor accepts the relevant cookie category, mapping Odoo's cookie bar (or your custom consent widget) to consent-mode signals. Server-side event enrichment can be exposed through a controller endpoint or, where you need externally-triggered pushes, the XML-RPC / JSON-RPC API. Automated actions and @api.depends computes can annotate records (for example, flagging which orders have already emitted a conversion) so events are idempotent and never double-count on page refresh or retry.
Delivery is a scoped engagement. We start with a short scoping call to map your exact events, consent requirements, storefront theme, and Odoo edition, then produce a fixed quote and build against a signed scope. You review the module on a staging database during UAT, we validate the event stream in the container's preview/debug mode, and only then do we deploy to production with a rollback plan. Typical delivery is 2–4 weeks from confirmed scope, depending on the number of custom events and integrations. Pricing starts from $249 (indicative, single-company base scope); additional custom events, multi-company or multi-website setups, deeper consent/localization requirements, and third-party integrations (CRM, CDP, offline-conversion feeds) increase the quoted scope.
Because we deliver the full source and a git repo handover, the integration is yours to own and extend. It is built cleanly against Odoo's inheritance mechanisms — no core patching — so it upgrades predictably and coexists with your theme and other apps. We support Odoo 17.0, 18.0, and 19.0 across both Community and Enterprise, and we tell you up front which capabilities differ between editions for your specific build.
What you get
- Installable source code for your Odoo major version (17.0, 18.0, or 19.0), Community or Enterprise
- Installation and configuration on your environment, including container-ID wiring and consent mapping
- Technical documentation covering the module architecture, `dataLayer` event schema, and configuration options
- End-user / marketer guide plus a live training session on managing settings and validating events
- UAT on a staging database with event verification in the container's preview/debug mode, and a documented rollback plan
- Post-go-live support window for defect fixes and configuration adjustments
- Full git repository handover so you own and can extend the source
- Event-mapping specification and QA checklist documenting every tracked event and its trigger conditions
Who this is for
eCommerce marketing manager
Runs paid and organic campaigns on an Odoo storefront and needs conversion and funnel events they can trust — server-confirmed purchases, correct order values, and no double-counting — so ad platforms optimize against real revenue rather than inflated client-side numbers.
Odoo administrator / IT lead
Owns the Odoo instance and wants tracking delivered as a clean, upgrade-safe module with proper security rules and central configuration, rather than snippets pasted into a theme that break on the next update or migration.
Analytics / data lead
Defines the measurement plan and needs a documented, stable `dataLayer` schema with consistent event names and enriched payloads so downstream tags, dashboards, and attribution models stay reliable as the site evolves.
Growth-stage retailer or B2B seller
Sells through Odoo eCommerce and the portal, needs consent-compliant tracking for their region, and wants one accountable partner to scope, build, install, and support it rather than stitching together generic snippets.
Installation overview
Download from ECOSIRE
Buy the license on ecosire.com and download the Google Tag Manager Integration for Odoo module ZIP from your account dashboard.
Upload to Odoo
Extract the ZIP into your Odoo custom addons folder on the server (or upload via Apps > Install from file on Odoo.sh / runbot).
Install the module
Activate Developer Mode, open Apps, click Update Apps List, search for Google Tag Manager Integration for Odoo, and press Install.
Configure settings
Open the new menu, paste your ECOSIRE license key, connect any external credentials (Shopify, Amazon, Stripe, etc.), and save.
Verify & go live
Run the built-in connection test, sync your first 10 records, and schedule the recurring cron. Contact support if anything fails.
How Google Tag Manager Integration for Odoo Compares
| Criterion | ECOSIRE | Custom Build | Competitor | Odoo Native |
|---|---|---|---|---|
| Event accuracy | Server-confirmed events from the ORM with idempotency guard | Depends on in-house skill; often client-side only | Mostly client-side snippet events, easily missed | |
| dataLayer schema | Documented, typed event contract enriched with order/product data | Built from scratch; quality varies by developer | Generic schema, limited enrichment | |
| Consent gating | Mapped to Odoo cookie bar / custom widget as consent signals | Must be implemented and tested manually | Basic or absent; rarely region-specific | |
| Fit to your site | Scoped and built for your theme, events, and edition | Fully bespoke but you own the full build effort | One-size-fits-all, adapt yourself | |
| Upgrade safety | Clean inheritance, no core patching, tested on 17/18/19 | Risk of core patches and brittle overrides | Varies; may lag Odoo releases | |
| Ownership | Full source + git repo handover, yours to extend | You own it, but carry all build and QA cost | Licensed binary/module, limited to vendor roadmap | |
| Support | Post-go-live support window + optional maintenance | Self-supported or contractor-dependent | Generic vendor tickets, no context on your build | |
| Delivery model | Scoped quote, UAT on staging, rollback plan, 2–4 weeks | Timeline and cost depend on your team's capacity | Instant install but generic and unsupported for edge cases |
Frequently Asked Questions about Google Tag Manager Integration for Odoo
Is this a ready-made app I can download and install today?
No. This is a build-to-order engagement. ECOSIRE scopes, builds, installs, and supports a module tailored to your exact events, consent requirements, storefront, and Odoo edition. There is no instant download — you receive source code and a deployed, tested integration built for your deployment.
How long does delivery take?
Typical delivery is 2–4 weeks from confirmed scope. The timeline depends on the number of custom events, consent/localization depth, and any third-party integrations. We agree the scope and timeline on the scoping call before any build work begins.
How does pricing and scoping work?
Pricing starts from $249 (indicative, single-company base scope). It is not a fixed price — after a short scoping call we send a fixed written quote based on your event list, multi-company/multi-website needs, consent requirements, and integrations. You only commit once the scope and quote are agreed.
What about support and Odoo version updates?
Every build includes a post-go-live support window for defect fixes and configuration tweaks. Because we deliver full source and a git repo, your team can extend it, and we can quote ongoing maintenance or upgrades to future Odoo versions separately. The module is built against Odoo's inheritance mechanisms so it upgrades predictably.
Which Odoo versions and editions do you support?
We support Odoo 17.0, 18.0, and 19.0 on both Community and Enterprise. We build for your specific version and tell you up front which capabilities, if any, differ between editions for your requirements.
Will tracking respect visitor cookie consent?
Yes. We gate tag firing on the visitor's consent choice, mapping Odoo's cookie bar or your custom consent widget to consent-mode signals so tags only load after the relevant cookie category is accepted. Consent behavior is part of the scoping conversation to match your regional requirements.
Why is a server-confirmed purchase event better than a page script?
A thank-you-page script can be blocked, missed on redirect, or double-fired on refresh, under- or over-counting revenue. We emit the purchase event on confirmed order completion in the ORM with an idempotency guard, so each conversion is recorded exactly once with accurate totals, currency, and line items.
Related Modules
Request a quote
Google Tag Manager Integration for Odoo
A build-to-order Odoo integration that pushes clean, structured analytics events from your storefront, portal, and checkout into a container-based tag management layer. ECOSIRE scopes, builds, installs, and supports it for your exact site and consent requirements.
- Dedicated module with its own `__manifest__.py`, models, views, and `ir.model.access.csv` — no core patching, upgrade-safe against theme and other apps
- Single global container-snippet injection via an inherited QWeb `<head>` template, eliminating duplicated or theme-embedded scripts
- Structured `dataLayer` push contract with a documented event schema (product view, add-to-cart, remove-from-cart, begin-checkout, purchase)
- Server-confirmed `purchase` event fired on `sale.order` / `website.sale` completion, not a client thank-you-page script, so refunds and refreshes don't inflate counts