- Home
- Apps
- SaaS Tools
- Save Payment Token In Back-end
Illustrative previewA build-to-order Odoo module that lets your team securely capture card details submitted through website contact
and intake forms and store them as gateway payment tokens in the back-end for later charging.
ECOSIRE scopes, builds, installs, and supports it — nothing is charged or stored until you confirm the design.
What is Save Payment Token In Back-end?
A build-to-order Odoo module that lets your team securely capture card details submitted through website contact and intake forms and store them as gateway payment tokens in the back-end for later charging. ECOSIRE scopes, builds, installs, and supports it — nothing is charged or stored until you confirm the design. 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
Built to order, done for you
No DIY setup — a working app, built, installed and supported by ECOSIRE.
- 1
You order
Start with a one-time build price. We scope it with you at kickoff.
- 2
We build & install
ECOSIRE builds, configures and installs it on your Odoo.
- 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
Sales, service, and rental teams that run Odoo frequently need to take a customer's card at the point of enquiry — a website contact form, a quote request, or a booking intake — and hold it on file so an agent can charge it later from the back-end once the order is confirmed. Odoo's native payment stack is built for the checkout flow: a logged-in portal customer completes a payment.transaction and, with Enterprise, a payment.token may be saved. It has no supported path for capturing raw card data on a marketing contact form and turning it into a reusable, PCI-safe token attached to a res.partner without a full e-commerce cart. Teams that try to bridge that gap end up emailing card numbers or pasting them into notes — a serious compliance liability.
We build a made-to-order module that closes this gap correctly. On the website side we render a hardened intake form whose card fields are handled by your acquirer's client-side tokenization (hosted fields / JS SDK), so the raw PAN never touches your Odoo server or database — only the gateway-issued token and the last four digits, brand, and expiry are transmitted back. A controller receives the tokenization result, resolves or creates the res.partner, and persists a payment.token record linked to the acquirer, exactly the object Odoo's own _send_payment_request already knows how to charge. Back-end users see the saved cards on the partner and on the sale order, gated by ir.model.access.csv and record rules so only the sales/finance groups you nominate can view or use them; QWeb-free, the UI is standard OWL list/form views with an audited "Charge saved card" action that creates the payment.transaction server-side.
Technically the build ships as a proper Odoo addon with its own __manifest__.py, models/ extending payment.token/res.partner with @api.depends computed display fields (masked number, expiry status), server actions and optional base_automation rules to flag expiring cards, and a controller layer for the website endpoint. Everything routes through the acquirer provider your instance already uses, so tokens created here are chargeable through Odoo's standard payment flows and via the external XML-RPC/JSON-RPC API for any headless integration. We support Odoo 17.0, 18.0, and 19.0; where a capability depends on Enterprise (e.g. the built-in saved-payment-method framework) versus Community we tell you up front and adapt the design so the module behaves consistently on your edition.
Because this is build-to-order, work starts with a short scoping call, not a download. We confirm your acquirer(s), the forms that will capture cards, the security groups, and your compliance posture, then deliver a fixed quote and a signed scope. Typical delivery is one working week from confirmed scope, including UAT on a staging database before anything touches production. Pricing starts from $999 (indicative, single-company base scope for one acquirer and one intake form); additional acquirers, multi-company token isolation, deeper localization or gateway-specific compliance work, and migrating existing stored cards increase the quoted scope. You receive a firm, fixed quote after the scoping call — never a surprise on the invoice.
What you get
- Installable, version-pinned source code for your Odoo edition (17.0 / 18.0 / 19.0) as a self-contained addon
- Installation and configuration on your environment, including acquirer/provider wiring and security-group setup
- Technical documentation: model/field reference, controller endpoints, access rules, and API usage notes
- End-user guide plus a live training session for your sales and finance teams
- UAT on a staging database with a documented test plan and a rollback plan before production cutover
- A post-go-live support window for defect fixes and configuration adjustments
- Git repository handover with full commit history and tagged release
- Compliance handoff notes covering the tokenization boundary and your PCI-scope responsibilities
Who this is for
Sales operations lead
Runs the quote-to-cash flow in Odoo and needs agents to capture a customer's card at enquiry time and charge it from the back-end once the deal is confirmed, without handling raw card numbers.
Finance / compliance manager
Owns PCI posture and wants card capture pushed to gateway tokenization so raw PANs never land in Odoo, with strict record rules and a full audit trail over who can view or charge saved cards.
Odoo administrator / IT lead
Maintains the instance across 17/18/19 and Community vs Enterprise, and needs a clean addon with proper `ir.model.access.csv`, upgrade-safe models, and no untracked customizations bolted onto core.
Service or rental business owner
Takes deposits and recurring charges against cards on file and needs a reliable, supported way to store tokens on the partner and trigger charges as bookings and orders progress.
How Save Payment Token In Back-end Compares
| Criterion | ECOSIRE | Custom Build | Competitor | Odoo Native |
|---|---|---|---|---|
| Card capture on a contact/intake form | Purpose-built hardened website form wired to gateway tokenization | Possible but you design and secure the whole flow | Often assumes checkout/portal context, not a marketing form | No supported non-checkout capture path |
| Where raw PAN lives | Never touches Odoo — tokenized client-side at the acquirer | Depends entirely on your implementation discipline | Varies; some persist unsafe data if misconfigured | N/A — no such capture flow exists |
| Access control over saved cards | Scoped `ir.model.access.csv` + record rules per your groups | You must author and test every rule | Generic defaults, rarely tailored to your groups | Standard token access only within checkout context |
| Charging from the back-end | Audited server action creating `payment.transaction` on the token | Build the action and audit trail yourself | Charge UX inconsistent; audit trail often absent | Charging tied to portal-driven transactions |
| Odoo 17/18/19 + Community vs Enterprise | Version-pinned build, edition differences reconciled at design | Your team owns cross-version compatibility | Version support varies; edition gaps often unstated | Enterprise-only saved-method framework |
| External API charging | XML-RPC / JSON-RPC ready against standard `payment.token` | Achievable with additional development | Usually not exposed for headless use | No dedicated non-checkout API surface |
| Delivery model | Build-to-order: scoped, built, installed, supported (2-4 wks) | Depends on in-house capacity and backlog | Instant download, but you integrate and maintain it | Included, but only for the checkout use case |
| Support & handover | Docs, training, support window, full git repo handover | Internal knowledge only unless documented | Vendor forum / ticket support, no code ownership | Community/Enterprise support channels |
Frequently Asked Questions about Save Payment Token In Back-end
Do you store the actual credit card number in Odoo?
No. Card fields are tokenized client-side by your acquirer's hosted fields or JS SDK, so the raw PAN never reaches your Odoo server or database. We only persist the gateway-issued token plus masked metadata (last four, brand, expiry), which keeps the sensitive data inside your acquirer's PCI scope rather than yours.
How long does delivery take?
Because this is build-to-order, work begins after a scoping call — not an instant download. Typical delivery is one working week from confirmed scope, including UAT on a staging database before anything reaches production. Larger scopes (multiple acquirers, multi-company isolation, data migration) can extend that, which we state in the quote.
How does pricing and scoping work?
Pricing starts from $999 as an indicative single-company base scope for one acquirer and one intake form. After a short scoping call we confirm your acquirers, forms, security groups, and compliance needs and issue a firm, fixed quote and signed scope. Drivers like extra acquirers, localization depth, or migrating existing stored cards adjust the final figure.
What support and updates do I get after go-live?
Every build includes a post-go-live support window for defect fixes and configuration adjustments, plus the full git repository so you own the code. Version upgrades (for example moving from 18.0 to 19.0) or new acquirers are handled as a scoped follow-on engagement rather than a silent auto-update.
Does it work on Odoo Community as well as Enterprise?
Yes, we support 17.0, 18.0, and 19.0 on both editions. Some capabilities rely on Enterprise's built-in saved-payment-method framework; where that applies we tell you at design time and adapt the module so behavior is consistent on your edition rather than assuming a feature that isn't there.
Can external systems charge the saved cards?
Yes. Tokens are stored as standard `payment.token` records tied to your acquirer's provider, so they are chargeable through Odoo's native payment flows and via the XML-RPC / JSON-RPC API — letting a headless storefront, subscription engine, or middleware create partners and trigger charges against a card on file.
Which acquirers / payment gateways are supported?
Any acquirer that offers client-side tokenization and is (or can be) configured as a payment provider in your Odoo instance. During scoping we confirm your specific gateway and wire the intake form to its hosted fields; supporting an additional acquirer later is a defined add-on to scope.
Related Modules

SAML 2.0 Single Sign-On
A build-to-order SAML 2.0 Service Provider for Odoo that brings your instance under corporate SSO with Azure AD, Okta, Google Workspace, or OneLogin — including SP- and IdP-initiated login, just-in-time provisioning, and IdP-group-to-Odoo-group mapping. ECOSIRE scopes, builds, installs, and supports it for Odoo 17.0, 18.0, and 19.0.

Saudi Arabia Payroll (GOSI, WPS/Mudad)
KSA-localized Odoo payroll: GOSI contributions, Mudad/WPS export, end-of-service, and expat vs. Saudi national salary structures.

Sell and Invoice from Chat
A build-to-order Odoo module that lets your team draft, confirm, and invoice sales orders directly inside a Discuss chat thread — no context switch to the Sales screen. ECOSIRE builds, installs, and supports it for your Odoo 17, 18, or 19.

Send WhatsApp Message
A build-to-order Odoo integration that lets your team send WhatsApp messages to customers directly from Odoo records — quotations, invoices, deliveries, and support tickets — with approved templates, delivery tracking, and full chatter logging. ECOSIRE scopes, builds, installs, and supports it for you.
Save Payment Token In Back-end
A build-to-order Odoo module that lets your team securely capture card details submitted through website contact and intake forms and store them as gateway payment tokens in the back-end for later charging. ECOSIRE scopes, builds, installs, and supports it — nothing is charged or stored until you confirm the design.
- Client-side tokenization via the acquirer's hosted fields / JS SDK so raw PAN never reaches the Odoo server, DB, or logs
- Website controller endpoint that receives only the gateway token plus masked card metadata (last four, brand, expiry) and persists a standard `payment.token`
- Saved cards linked to `res.partner` and surfaced on the sale order, reusing Odoo's native `payment.token` object for downstream charging
- Back-end "Charge saved card" server action that creates a `payment.transaction` through the acquirer's existing provider flow