Trust Payments (3DS) Gateway for Odoo

Key Features

Dedicated `payment.provider` with `code = 'trustpayments'` — appears natively in Odoo checkout, invoice and sales-order 'Pay Now' flows alongside Stripe/Adyen

Full 3DS2 / SCA via the Trust Payments hosted payment page — PSD2-compliant authentication and liability shift handled by the PSP, never by your server

JWT-signed transaction requests: site reference, amount, currency and order reference assembled server-side and signed with your secret so the browser payload can't be tampered with

SAQ-A PCI scope — card PAN, CVV and the 3DS challenge live entirely on the Trust Payments hosted page; Odoo stores only tokens/references

Webhook / return-URL reconciliation controller that verifies the response hash, matches the `payment.transaction` by order reference, and is idempotent against duplicate notifications

Transaction state machine wired to Odoo's `_set_done` / `_set_pending` / `_set_error` / `_set_canceled`, auto-confirming the sale order and reconciling the linked invoice

Native refund support (`support_refund`) — a credit note or refund action calls Trust Payments to reverse a settled payment, with the refund transaction linked back

Multi-currency correct by construction: passes ISO 4217 currency and minor-unit amounts (e.g. pence) per Trust Payments' expected format

Encrypted credential fields (site reference, JWT username, secret/API key) on the provider record, with separate test and live sets toggled by provider `state`

Optional card tokenisation / `payment.token` support for saved cards and recurring/subscription charges where MIT rules allow

Auth-only vs auth-and-settle capture modes configurable per provider to match your Trust Payments account setup

Full gateway request/response logging for audit trails, chargeback evidence and dispute handling

Locked-down security via `ir.model.access.csv` plus record rules so gateway config and transaction logs are admin-only

Clean, upgrade-safe addon (`__manifest__.py` depending on `payment`/`website_sale`/`account`) targeting Odoo 17.0, 18.0 and 19.0, Community or Enterprise

Built to order, done for you

No DIY setup — a working app, built, installed and supported by ECOSIRE.

You order

Start with a one-time build price. We scope it with you at kickoff.

We build & install

ECOSIRE builds, configures and installs it on your Odoo.

Go live + support

You go live in about 2–4 weeks, with a post-launch support window.

About this Product

UK and EU merchants on Trust Payments face a specific gap: Odoo ships payment providers for Stripe, Adyen, Mollie, PayPal and a handful of others, but there is no first-party Trust Payments (formerly Secure Trading) provider in payment core. Teams end up either routing customers off-Odoo to a hosted checkout — losing order attribution and forcing manual reconciliation — or paying twice for a PSP they already have a contract and negotiated MID rates with. Under PSD2, a card flow that does not implement 3DS2 and Strong Customer Authentication (SCA) correctly gets soft-declined or exposes the merchant to liability shift, so a half-built integration is worse than none.

We build a dedicated Odoo payment provider (payment.provider with code = 'trustpayments') that plugs Trust Payments directly into the standard Odoo checkout, so the flow behaves exactly like a native provider: it appears on the eCommerce checkout and the "Pay Now" links on customer invoices and sales orders, writes proper payment.transaction records, and confirms the order through Odoo's own post-processing. The module implements the Trust Payments hosted payment page using their JWT request model — the transaction request (site reference, amount, currency, order reference, customer fields) is assembled server-side, signed as a JWT with your secret so nothing sensitive is tamperable in the browser, and the shopper is redirected to the PCI-scoped hosted page where card data and the 3DS2 challenge are handled entirely by Trust Payments. Card details never touch your Odoo server, keeping you in SAQ-A scope.

Technically it is a clean, upgrade-safe addon: a __manifest__.py depending on payment (and website_sale/account where those flows are in scope), a provider model extending payment.provider with the trustpayments-specific credential fields (site reference, JWT username, secret/API key) stored encrypted, and a controller exposing the return and webhook routes. Inbound status notifications are verified (signature/response-hash check against your secret), matched to the originating payment.transaction by order reference, and drive the transaction state machine — _set_done, _set_pending, _set_error — so a settled auth reconciles the linked invoice automatically instead of by hand. Refunds are wired through Odoo's native refund support (support_refund) so a credit note or a refund action calls back to Trust Payments; multi-currency is honoured by passing the order currency and minor-unit amount correctly per ISO 4217. Access is locked down with ir.model.access.csv plus record rules, and every gateway request/response is logged for audit and dispute evidence.

Because this is BUILD-TO-ORDER, it is not an instant apps.odoo.com download — ECOSIRE builds it against your exact Odoo edition and version. After a short scoping call we confirm your Trust Payments configuration (site reference, MID/currencies, 3DS2 profile, capture mode), agree the flows in scope (eCommerce, invoice pay-links, subscriptions/tokenisation if needed), then develop, install on your staging, run UAT against Trust Payments test credentials, and go live. Typical delivery is 2-4 weeks from confirmed scope. You receive the full source for your version and a post-go-live support window; nothing here is a stock listing or a pre-recorded demo.

What you get

Installable Odoo module source code built for your exact edition and version (17.0 / 18.0 / 19.0, Community or Enterprise)

Installation and configuration on your staging, then production — provider credentials, 3DS2 profile, capture mode and currencies set up

Technical documentation: architecture, provider fields, webhook/return routes, and the JWT request/response contract

End-user / admin guide plus a live training session covering checkout, reconciliation and refund handling

UAT on staging against Trust Payments test credentials, with a documented test matrix and a rollback plan

Post-go-live support window for defect fixes and gateway-behaviour questions

Git repository handover with full commit history and tagged release

Configuration checklist mapping your Trust Payments account (site reference, MID, currencies) to the Odoo provider settings

Who this is for

UK/EU merchant on Trust Payments

Already holds a Trust Payments MID with negotiated rates and wants card acceptance inside Odoo eCommerce and invoicing, without routing shoppers to a disconnected external checkout.

Finance / AR manager

Needs settled payments to reconcile automatically against Odoo invoices, refunds to flow through credit notes, and a clean audit trail for chargebacks and disputes.

Compliance-conscious operations lead

Must satisfy PSD2 SCA with proper 3DS2 and keep the business in SAQ-A PCI scope — card data never touching the Odoo server is a hard requirement.

Odoo functional consultant / integrator

Managing a client's Odoo estate and wants a maintainable, upgrade-safe Trust Payments provider that extends `payment.provider` correctly rather than a fragile bolt-on.

How Trust Payments (3DS) Gateway for Odoo Compares

Criterion	ECOSIRE	Custom Build	Competitor
Trust Payments support in Odoo	Purpose-built provider extending payment.provider	Depends entirely on your dev's knowledge	Rarely available; most cover Stripe/Adyen only
3DS2 / SCA compliance	Hosted page handles 3DS2, SAQ-A scope	Correct only if built carefully	Varies; often partial or outdated
Webhook reconciliation	Verified, idempotent, auto-reconciles invoices	Build and test it yourself	Basic or manual matching
Refund handling	Native refund support via credit notes	Extra work to wire up	Often not supported
Multi-currency	ISO 4217 minor-units passed correctly	Easy to get amounts wrong	Inconsistent handling
Odoo version/edition fit	Built for your exact 17/18/19, CE or EE	One version, your risk	Fixed versions; may lag releases
Source & maintainability	Full source + git repo handover	You own it but must maintain alone	Often encrypted/obfuscated code
Support & warranty	Post-go-live support window + UAT	Whatever you arrange internally	Ticket queue, variable quality

Frequently Asked Questions about Trust Payments (3DS) Gateway for Odoo

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

No. This is a build-to-order engagement. ECOSIRE builds the Trust Payments provider against your specific Odoo edition and version, configures it to your account, and installs it. There is no instant apps.odoo.com download — you receive the source for your version after we build it.

How long does delivery take?

Typical delivery is 2-4 weeks from confirmed scope. The clock starts once we've agreed the flows in scope (eCommerce, invoice pay-links, tokenisation, capture mode) and you've provided Trust Payments test credentials. Larger scopes with subscriptions or custom reconciliation may run longer, which we confirm in writing before starting.

Does it handle 3DS2 and PSD2 Strong Customer Authentication?

Yes. The card flow uses the Trust Payments hosted payment page, where 3DS2 authentication and the SCA challenge are performed by Trust Payments. This gives you PSD2 compliance and liability shift, and keeps you in SAQ-A PCI scope because card data and the challenge never touch your Odoo server.

Which Odoo versions and editions are supported?

We build for Odoo 17.0, 18.0 and 19.0, in both Community and Enterprise. The provider extends the standard `payment` framework so it works with `website_sale` eCommerce checkout and the accounting 'Pay Now' invoice flow. Tell us your version and edition at the scoping call and we target it exactly.

What about support and future updates after go-live?

Every build includes a post-go-live support window for defect fixes and gateway-behaviour questions. Because you receive the full source and git repo, your team can maintain it too. Migrating the module to a newer Odoo major version, or adding flows later, is available as a follow-on engagement.

Do refunds and reconciliation work automatically?

Yes. Settled payments reconcile against the linked Odoo invoice via the transaction's state machine, so AR doesn't match manually. Refunds use Odoo's native refund support — issuing a credit note or refund action calls Trust Payments to reverse the payment, with the refund transaction linked back for a clean audit trail.

Can it save cards for subscriptions or recurring billing?

Optionally, yes. Where your Trust Payments account and merchant-initiated-transaction rules allow, we implement `payment.token` support so cards can be saved and reused for recurring or subscription charges. This is confirmed as part of scope since it depends on your account configuration and 3DS exemptions.