Skip to main content
Wompi Payment Gateway for Odoo (Colombia) — A build-to-order Odoo payment provider that lets Colombian merchants accept PSE b — 1/1Illustrative preview

A build-to-order Odoo payment provider that lets Colombian merchants accept PSE bank transfers,

cards, and Nequi through Wompi — with signature-verified webhooks, COP localization, and refund support across website and customer portal.

What is Wompi Payment Gateway for Odoo (Colombia)?

A build-to-order Odoo payment provider that lets Colombian merchants accept PSE bank transfers, cards, and Nequi through Wompi — with signature-verified webhooks, COP localization, and refund support across website and customer portal. One-time license from $249.00 USD for Odoo 17, 18, 19 — includes 12 months of updates and support.

Key Features

New `payment.provider` record with `code = 'wompi'`, sandbox/production toggle, and per-method enablement — integrates with Odoo's native checkout, no core patches
PSE (débito bancario / online bank transfer) support with the bank-selection step surfaced in Odoo's website checkout flow
Credit and debit card acquiring through Wompi, plus Nequi and (optionally) Bancolombia Transfer as selectable methods
Server-side integrity signature generated for every checkout (reference + amount-in-cents + currency + secret, SHA-256) so totals can't be altered in the browser
Webhook endpoint with constant-time `checksum` verification against your events secret before any `payment.transaction` state change — forged events are rejected
Idempotent event handling: duplicate or replayed Wompi webhooks are de-duplicated by transaction reference so an order is confirmed exactly once
Status mapping from Wompi (`APPROVED` / `DECLINED` / `VOIDED` / `ERROR`) onto `_set_done` / `_set_canceled` / `_set_error`, driving SO confirmation and invoice registration
COP handled in cents with `res.currency` rounding reconciliation, so captured amounts match the sales order to the peso
Refund action on `payment.transaction` (and optional invoice-linked action) that calls Wompi's private API and records the refund id and outcome
Security via `ir.model.access.csv` plus a record rule restricting refund/void actions to accounting or payment-manager groups
Customer portal + website integration: buyers see transaction status; `mail.thread` chatter on the transaction gives your team a full audit trail
Configurable capture mode and clear sandbox test-card / test-PSE flow documented for UAT before go-live
Structured logging of every Wompi request/response (secrets redacted) for reconciliation and support
Built and tested for Odoo 17.0, 18.0, and 19.0 on both Community and Enterprise, respecting each version's `payment` framework API differences

Installation overview

  1. 1

    Download from ECOSIRE

    Buy the license on ecosire.com and download the Wompi Payment Gateway for Odoo (Colombia) module ZIP from your account dashboard.

  2. 2

    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).

  3. 3

    Install the module

    Activate Developer Mode, open Apps, click Update Apps List, search for Wompi Payment Gateway for Odoo (Colombia), and press Install.

  4. 4

    Configure settings

    Open the new menu, paste your ECOSIRE license key, connect any external credentials (Shopify, Amazon, Stripe, etc.), and save.

  5. 5

    Verify & go live

    Run the built-in connection test, sync your first 10 records, and schedule the recurring cron. Contact support if anything fails.

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

Colombian merchants running Odoo hit a wall the moment they try to collect money the way their customers actually pay. Odoo core ships the payment provider framework for Stripe, PayPal, Adyen, and a handful of others, but there is no native Wompi acquirer — which means no PSE (débito bancario), no Nequi, and no local card acquiring priced in COP. Teams end up bolting on manual bank-transfer confirmation, reconciling by hand, and losing carts at checkout because the buyer's preferred rail simply isn't offered. That is where Odoo's out-of-the-box payment module runs out of road for Colombia.

ECOSIRE builds a first-class Wompi acquirer that plugs into Odoo's native payment.provider and payment.transaction framework. We add a new provider record (code = 'wompi') via models.Model subclasses with fields for your public/private keys and the events (integrity) secret, plus @api.depends-driven compute fields for environment (sandbox vs production) and enabled payment methods. The checkout controller redirects the buyer to Wompi's hosted Checkout — or renders the inline Widget — with a server-side reference and an integrity signature, so the amount, currency, and reference cannot be tampered with client-side.

On the return leg we handle both the redirect and the asynchronous webhook. Every event's checksum is recomputed from the documented concatenated property list plus your events secret (SHA-256) and compared in constant time before the payment.transaction state is moved — no forged APPROVED event can confirm an order. The transaction feedback path maps Wompi statuses (APPROVED, DECLINED, VOIDED, ERROR) onto Odoo's _set_done, _set_canceled, _set_error helpers, so sales orders, invoices, and the website checkout confirmation all react exactly as they do for a native provider. COP amounts are handled in cents as Wompi expects, and res.currency rounding is reconciled so the captured amount matches the SO to the peso.

Refunds are wired through the private API: an admin action on payment.transaction (and, where you want it, the linked invoice) posts a refund to Wompi, records the returned refund id, and reflects the outcome back on the Odoo record with proper ir.model.access.csv rights and a record rule so only accounting/payment managers can trigger it. The buyer sees their transaction and status in the website customer portal; your team sees a clean audit trail via mail.thread chatter on the transaction.

Because this is build-to-order, nothing ships as a blind download. We start from a short scoping call, confirm your Wompi account setup, target Odoo version (17.0, 18.0, or 19.0) and Community-vs-Enterprise edition, and which methods you need enabled (PSE, cards, Nequi, Bancolombia Transfer). We then build against your requirements, deliver on a staging instance for UAT, and only promote to production once you have signed off — typically one working week from confirmed scope. You receive the full installable source, documentation, and a post-go-live support window.

Compatible with Odoo 17Compatible with Odoo 18Compatible with Odoo 19

What you get

  • Installable Odoo module source code targeted to your exact version (17.0 / 18.0 / 19.0) and edition, with a clean `__manifest__.py` and dependency declaration
  • Installation and configuration on your environment, including provider keys, events secret, and enabled payment methods
  • Technical documentation: models, controllers, webhook contract, signature/checksum scheme, and configuration reference
  • End-user guide plus a live training session for your team covering checkout, reconciliation, and refunds
  • UAT on a staging instance with Wompi sandbox test cases, sign-off checklist, and a documented rollback plan
  • Post-go-live support window for defect fixes and configuration adjustments
  • Git repository handover with full commit history and tagged release
  • COP reconciliation notes and a go-live runbook for switching from sandbox to production keys

Who this is for

Colombian e-commerce merchant on Wompi

Runs an Odoo website storefront and already collects through Wompi elsewhere. Needs PSE, cards, and Nequi natively at Odoo checkout so buyers pay their preferred way and orders confirm automatically instead of via manual bank-transfer approval.

Finance / accounting manager

Owns reconciliation and refunds. Needs captured amounts to match sales orders to the peso in COP, a reliable audit trail on each transaction, and refund controls locked to accounting roles via record rules — not open to every user.

Odoo administrator / IT lead

Responsible for the instance and upgrades. Wants a clean provider module that follows Odoo's native `payment` framework, no core forks, verified webhook security, and a supported build that survives 17→18→19 migrations.

Agency or systems integrator

Delivering an Odoo project for a Colombian client and needs the Wompi rail done properly. Wants the git repo, technical docs, and a staging UAT so it slots into their own delivery and handover.

How Wompi Payment Gateway for Odoo (Colombia) Compares

CriterionECOSIRECustom BuildCompetitorOdoo Native
Wompi support (PSE, cards, Nequi)Built-in as a native Odoo payment providerPossible, but you specify and build it allRarely covers Wompi; usually global gatewaysNot available — no Wompi acquirer in core
Webhook signature verificationConstant-time SHA-256 checksum on every eventDepends on your developer's diligenceVaries; often undocumentedN/A — no Wompi endpoint exists
COP handling & reconciliationCents-accurate, reconciled to the sales orderYou handle rounding and reconciliationGeneric; may mishandle COP centsNo COP acquiring path
Refunds from OdooRole-restricted refund action via Wompi APIExtra scope you must buildSometimes missing or manualNot applicable
Odoo version coverageBuilt for 17.0 / 18.0 / 19.0, CE & EEWhatever you commission and maintainOften lags new Odoo releasesShips with each version, but no Wompi
Testing & UATSandbox UAT on staging + rollback planYou define and run the test planBuyer self-tests after downloadNothing to test — feature absent
Support & handoverPost-go-live window + git repo handoverTied to your internal team's availabilityForum/ticket support, quality variesCommunity support only
Cost & time to valueFixed build-to-order scope, one working weekHigher effort, longer, spec-dependentCheap upfront, integration risk on youFree, but does not solve the problem

Frequently Asked Questions about Wompi Payment Gateway

How long does delivery take?

This is a build-to-order module, not an instant download. After a short scoping call to confirm your Odoo version, edition, and which Wompi methods you need, typical delivery is one working week from confirmed scope. You approve the build on a staging instance before it goes to production.

Which Wompi payment methods are supported?

PSE (online bank débito), credit/debit cards, and Nequi are the core set, with Bancolombia Transfer available as an option. We enable exactly the methods you request during scoping; each appears as a selectable option in Odoo's website checkout.

Which Odoo versions and editions does it work with?

We build for Odoo 17.0, 18.0, and 19.0, on both Community and Enterprise. Because it uses Odoo's native `payment.provider` / `payment.transaction` framework rather than patching core, it upgrades cleanly with your instance.

How is checkout kept secure against tampering?

Each checkout carries a server-side integrity signature over the reference, amount, and currency, so the totals can't be altered in the browser. Incoming Wompi webhooks are verified with a constant-time SHA-256 checksum against your events secret before any transaction is marked paid, and duplicate events are de-duplicated so an order confirms exactly once.

Can we issue refunds from inside Odoo?

Yes. A refund action on the payment transaction (and optionally the linked invoice) calls Wompi's private API, records the returned refund id, and reflects the result on the Odoo record. Access is restricted to accounting/payment-manager roles via `ir.model.access.csv` and a record rule.

What about support and updates after go-live?

Every engagement includes a post-go-live support window for defect fixes and configuration adjustments. Beyond that, we offer ongoing maintenance and version-migration support (e.g. when you move from Odoo 18 to 19) as a separate arrangement. You also receive the git repo so your own team can maintain it.

Do we need our own Wompi account?

Yes — you provide your Wompi merchant account and its keys (public, private, and events secret). We configure the module against your sandbox first for UAT, then switch to your production credentials at go-live using the documented runbook.

Talk to an ECOSIRE expert about Wompi Payment Gateway

Get a custom quote, a live demo, or help evaluating fit.

Start the conversation