Skip to main content
Forms • Contacts — A build-to-order Odoo integration that maps submissions from an external drag-and-drop form builder direct — 1/1Illustrative preview

A build-to-order Odoo integration that maps submissions from an external drag-and-drop form builder directly

onto your Odoo contact and partner records — deduplicated, validated, and audit-logged.

ECOSIRE scopes, builds, installs, and supports it; it is not an instant download.

What is Forms • Contacts?

A build-to-order Odoo integration that maps submissions from an external drag-and-drop form builder directly onto your Odoo contact and partner records — deduplicated, validated, and audit-logged. ECOSIRE scopes, builds, installs, and supports it; it is not an instant download. 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

Authenticated inbound `http.Controller` webhook route (per-source token or HMAC-signed payload) that ingests form-builder submissions in real time
UI-editable field-mapping engine (a `models.Model` mapping table) binding any form field to any `res.partner` field without code changes
Relational-field mapping for `country_id`, `state_id`, `title`, `category_id` tags, and child/contact records, resolved by name or external ID
Raw-submission staging model — every payload is persisted before mapping so failed transforms are never lost
Configurable dedupe pass matching on email, `vat`, or phone against existing partners to update rather than duplicate contacts
Pre-write field validators (email format, required-field, allowed-value lists) with quarantine + human-readable failure reasons
Atomic `create`/`write` transactions with full rollback on validation error, keeping the partner table clean
`@api.depends` compute helpers for derived values: full-name assembly, phone E.164 normalization, email lowercasing
Optional automated actions on successful import — assign salesperson, add followers, tag, or spawn a linked `crm.lead`
Submission audit log with list/kanban views and a QWeb report for compliance and reconciliation
`ir.model.access.csv` access rights plus record rules so multi-company and scoped-user deployments stay isolated
Backfill/polling mode for form builders without outbound webhooks, using their JSON API on an `ir.cron` schedule
Idempotency keys on inbound requests to safely absorb webhook retries without double-creating contacts
Full `XML-RPC`/`JSON-RPC` exposure of mapping and submission models for external orchestration
Built and regression-tested across Odoo 17.0, 18.0, and 19.0 on Community and Enterprise

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

Most teams that run Odoo end up with two disconnected worlds: a flexible external form builder that marketing and operations rely on for complex, multi-step, conditional forms, and Odoo's res.partner contact/partner model where every downstream process — quotations, invoices, projects, helpdesk — actually needs that data to live. Odoo's own Website Forms builder can push a handful of fields to a model, but it runs out of road quickly: no rich conditional logic, no repeatable sub-forms, no clean mapping of a nested submission payload onto related records, and no dedupe or validation before a partner is created. The result is manual re-keying, duplicate contacts, and submissions that sit in an inbox instead of your database.

This build-to-order integration closes that gap. We build a dedicated bridge module — with its own __manifest__.py, models, and ir.model.access.csv security — that receives submissions from your external form builder either via its outbound webhook or by polling its JSON API, then maps each payload onto Odoo through a configurable field-mapping engine. A mapping table defined as a models.Model and edited entirely from the Odoo UI lets you bind any form field to any res.partner field, including relational fields such as country_id, state_id, category_id tags, and child contacts, with @api.depends compute helpers for derived values (full-name assembly, phone normalization, email lowercasing). Inbound requests hit an authenticated http.Controller route (token or HMAC-signed), and every raw submission is persisted in a staging model so nothing is ever lost, even if mapping fails.

Technically, the flow is deterministic and auditable. On receipt we run a configurable dedupe pass (email, VAT/vat, or phone match against existing res.partner records) so submissions update the right contact instead of spawning duplicates; unmatched records create a new partner in a search + create/write transaction that is fully rolled back on validation error. Field-level validators (email format, required fields, allowed-value lists) run before any write, and failures are quarantined with a human-readable reason rather than silently dropped. Optional automated actions can then fire — assign a salesperson, tag the contact, subscribe followers, or create a linked crm.lead — and a QWeb report or list view gives you a submission audit log. Everything is exposed over Odoo's XML-RPC/JSON-RPC API too, and the module respects record rules so multi-company and access-scoped deployments behave correctly. It is built and tested against Odoo 17.0, 18.0, and 19.0 on both Community and Enterprise (Enterprise-only touchpoints, such as Studio-created fields, are handled gracefully where present).

Because this is build-to-order, nothing ships until we have agreed scope. After a short scoping call we confirm your exact form fields, the target Odoo version and edition, your dedupe rules, and any downstream automation, then produce a fixed quotation. Typical delivery is one working week from confirmed scope: we build on a branch, deliver to a staging database for your UAT, and only then install on production with a rollback plan. You receive the full source. Pricing starts from $999 (indicative, single-company base scope); the number of forms and field mappings, multi-company record-rule complexity, historical submission data migration, and any bespoke downstream automation increase the quoted scope.

What you get

  • Installable source code for your version of the module (`__manifest__.py`, models, views, controllers, security), licensed for your organization
  • Installation and configuration on your target environment, including form-builder webhook/API wiring and initial field mappings
  • Technical documentation: model/field reference, mapping-engine guide, security model, and webhook payload contract
  • End-user guide plus a live training session for the admins who will own mappings and the submission audit log
  • Post-go-live support window for defect fixes and configuration questions
  • UAT on a staging database with a signed-off test plan, plus a documented rollback plan for the production install
  • Git repository handover with full commit history and branch/tag structure
  • Optional historical-submission data migration script (scoped separately based on volume)

Who this is for

Marketing / demand-gen lead

Runs complex campaign and event forms in an external builder and needs every submission to land as a clean, deduplicated `res.partner` (or `crm.lead`) in Odoo, tagged and routed, without the team re-keying data or chasing duplicates.

Odoo administrator / operations manager

Owns the Odoo database and wants a maintainable, UI-configurable bridge — mappings they can edit themselves, an audit log they can trust, and record-rule-safe behavior across companies — rather than a brittle one-off script.

IT / systems integrator

Responsible for the wider stack and needs an authenticated, idempotent webhook contract, staging-model safety, and `XML-RPC`/`JSON-RPC` access so the integration fits existing monitoring, retries, and orchestration.

Sales operations manager

Depends on accurate, complete contact data for pipeline and territory assignment, and needs inbound form contacts auto-assigned to the right salesperson with followers and tags set on arrival.

How Forms • Contacts Compares

CriterionECOSIRECustom BuildCompetitorOdoo Native
Delivery modelBuilt, installed & supported by ECOSIRE for your forms and Odoo versionYou hire/allocate developers to build and maintain itGeneric download, install yourself, one-size mappingIncluded, but limited to Odoo's basic website form builder
Field mapping to res.partnerUI-editable engine mapping any form field to any partner field incl. relationsWhatever your team codes; changes need a developerFixed or shallow mapping; nested payloads unsupportedA few fields only; no relational/child-record mapping
Dedupe & validationConfigurable email/VAT/phone dedupe + pre-write validators + quarantineOnly if you build it; often skipped under deadlineRarely included; tends to create duplicatesNone — each submission risks a new duplicate contact
External form-builder supportWebhook or JSON-API polling for any builder, authenticatedBespoke per builder, you own the integration codeUsually tied to one specific builderNot applicable — Odoo's own builder only
Auditability & error handlingRaw-submission staging, audit log, QWeb report, idempotent retriesDepends on effort invested; often minimal loggingLimited logging; failures may be silentSubmissions go to email/lead with no structured audit trail
Odoo version coverageTested on 17.0/18.0/19.0, Community & EnterpriseWhatever you target; upgrades are your burdenOften lags new Odoo releasesShips with each version but feature-frozen
Ongoing supportPost-go-live support window + source + git handoverYour team owns all maintenanceVendor forum/ticket, variable responsivenessOdoo standard support scope only
Cost profileFrom $999 indicative; fixed quote after scopingHigher build cost + ongoing maintenance salaryLow upfront license, hidden customization costNo extra cost but capability gap remains

Frequently Asked Questions about Forms • Contacts

Is this a ready-made app I can download and install today?

No. This is a build-to-order productized service. ECOSIRE scopes, builds, installs, and supports the module specifically for your forms, your Odoo version, and your data rules. There is no instant download — after a scoping call we confirm requirements and deliver a tailored module.

How long does delivery take?

Typical delivery is one working week from confirmed scope. The timeline starts once we've agreed your exact form fields, target Odoo version/edition, dedupe rules, and any downstream automation on the scoping call. Larger multi-form or data-migration engagements may run longer, and we confirm the schedule in the fixed quotation.

How does pricing and scoping work?

Pricing starts from $999 as an indicative single-company base scope. It is not a firm fixed price until we've held a short scoping call — after that we issue a fixed quotation. The number of forms and field mappings, multi-company complexity, historical data migration, and bespoke automation are the main drivers that increase the quote.

Which Odoo versions and editions are supported?

We build and test against Odoo 17.0, 18.0, and 19.0 on both Community and Enterprise. The controller, models, and security are written to each target version's ORM conventions. Enterprise-only touchpoints (such as Studio-created fields) are handled where present, and we confirm your exact version during scoping.

What about support and updates after go-live?

Every engagement includes a post-go-live support window for defect fixes and configuration questions, and you receive the full source plus git repository so your own team can maintain it. Ongoing enhancements, version upgrades (e.g. an 18.0→19.0 migration), or extended support can be arranged as a separate scoped agreement.

Will it create duplicate contacts?

No — dedupe is core to the design. A configurable pass matches each submission on email, `vat`, or phone against existing `res.partner` records and updates the matched contact instead of creating a new one. Unmatched submissions create a new partner in an atomic transaction, and every raw payload is staged so nothing is lost.

Which form builders does it work with?

Any form builder that can send an outbound webhook or expose a JSON API for submissions. We build an authenticated inbound route (token or HMAC-signed) for real-time delivery, or an `ir.cron` polling mode for builders without webhooks. We confirm your specific builder and payload shape during scoping.

Request a quote

Forms • Contacts

A build-to-order Odoo integration that maps submissions from an external drag-and-drop form builder directly onto your Odoo contact and partner records — deduplicated, validated, and audit-logged. ECOSIRE scopes, builds, installs, and supports it; it is not an instant download.

  • Authenticated inbound `http.Controller` webhook route (per-source token or HMAC-signed payload) that ingests form-builder submissions in real time
  • UI-editable field-mapping engine (a `models.Model` mapping table) binding any form field to any `res.partner` field without code changes
  • Relational-field mapping for `country_id`, `state_id`, `title`, `category_id` tags, and child/contact records, resolved by name or external ID
  • Raw-submission staging model — every payload is persisted before mapping so failed transforms are never lost

Request a Quotation

Tell us about your Forms • Contacts 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.