Quick facts
- Price
- $199.00 USD
- ERPNext versions
- —
- Setup time
- 30 min
- License
- One-time perpetual
- Languages
- 11 languages
One-time Purchase
Cash on Delivery & COD Manager for ERPNext
A build-to-order ERPNext app that turns Cash on Delivery into a first-class, controlled payment method — OTP/phone order verification, configurable COD fees and limits, courier collection and remittance tracking, and automatic reconciliation to Payment Entries. ECOSIRE scopes, builds, installs and supports it for your v15/v16 site.
$199.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
COD as a first-class payment method mapped to a dedicated `Mode of Payment` and receivable/clearing account, not just an 'unpaid' invoice flag
OTP / phone verification via a whitelisted server method that issues and validates a one-time code through your SMS or WhatsApp gateway before order confirmation
Configurable COD surcharge (fixed, percentage, or slab-based) applied server-side as a real charge/line item via `validate` and `before_save` doc events in `hooks.py`
Per-customer, per-region and per-order-value COD limits enforced in server logic so oversized or high-risk COD orders are blocked or held for approval
`Courier Remittance` DocType that batches collected cash and reconciles it against the originating Sales Invoices
Automatic `Payment Entry` creation on remittance settlement, posting against the correct receivable and COD clearing accounts
RTO (return-to-origin), short-payment and partial-collection handling so undelivered or under-collected COD is tracked, not lost
Courier assignment and delivery-status tracking with optional polling of courier APIs through scheduler events
OTP expiry, stale-order cleanup and overdue-remittance flags driven by `scheduler_events` background jobs
Client Scripts that render COD status, OTP resend/verify actions and remittance state directly on Sales Order and Sales Invoice forms
Whitelisted REST endpoints for headless / storefront checkout consumable via the Frappe REST API and `frappe.call`
Role-based permissions and dedicated role profiles (e.g. COD Verifier, Remittance Officer) so verification and reconciliation are properly segregated
COD dashboard / report views for pending verification, cash-in-transit, delivered-not-remitted, and RTO ageing
Full audit trail via Frappe's document versioning and a per-order COD event log for compliance and dispute resolution
About this Product
In South Asian and MENA retail, Cash on Delivery is not a fringe option — it is often the majority of order volume. But out of the box, ERPNext treats COD as an afterthought: you can flag a Sales Order or Sales Invoice as "unpaid" and hope the courier collects, yet there is no native OTP verification to filter fake orders, no configurable COD surcharge, no per-customer or per-region collection limits, and no structured way to track which orders a courier has picked up, delivered, collected cash on, and remitted back to you. Finance teams end up reconciling courier remittance sheets against invoices by hand in spreadsheets, RTO (return-to-origin) losses go untracked, and the gap between "delivered" and "cash actually received" stays invisible in the general ledger.
Why Choose Cash on Delivery & COD Manager for ERPNext
COD as a first-class payment method mapped to a dedicated `Mode of Payment` and receivable/clearing account, not just an 'unpaid' invoice flag
OTP / phone verification via a whitelisted server method that issues and validates a one-time code through your SMS or WhatsApp gateway before order confirmation
Configurable COD surcharge (fixed, percentage, or slab-based) applied server-side as a real charge/line item via `validate` and `before_save` doc events in `hooks.py`
Per-customer, per-region and per-order-value COD limits enforced in server logic so oversized or high-risk COD orders are blocked or held for approval
`Courier Remittance` DocType that batches collected cash and reconciles it against the originating Sales Invoices
Automatic `Payment Entry` creation on remittance settlement, posting against the correct receivable and COD clearing accounts
ECOSIRE builds a proper Frappe app — a versioned module installed on your bench, not a pile of customizations — that makes COD a controlled, auditable payment method inside ERPNext. We add a COD checkout/order path with new DocTypes such as COD Order, COD Settings, and Courier Remittance, wired into the standard Sales Order and Sales Invoice lifecycle. Phone/OTP verification runs through a whitelisted server method (@frappe.whitelist()) that issues and validates a one-time code via your SMS/WhatsApp gateway before an order is confirmed, cutting fake and duplicate COD orders. COD surcharge and collection limits live in COD Settings and are applied via hooks.py doc events (before_save / validate / on_submit) so the fee lands as a real line item or charge and limits are enforced server-side — never bypassable from the client.
On the fulfilment and finance side, the app tracks the full cash journey: courier assignment, pickup, delivery status, cash collected, and remittance batches. A Courier Remittance DocType reconciles collected amounts against the originating invoices and generates the matching Payment Entry records against the correct receivable accounts, so your GL reflects cash received the moment a courier settles — with COD fees, RTO, and short-payments accounted for rather than silently lost. Scheduler events (scheduler_events in hooks.py) can auto-expire stale OTPs, flag overdue remittances, and poll courier status where an API is available. Client Scripts surface COD status and OTP actions directly on the ERPNext form, everything respects role-based permissions and role profiles, and the whitelisted endpoints are consumable from your storefront or the Frappe REST API for a headless checkout.
Because this is build-to-order, nothing ships as a blind download. We start with a short scoping call to confirm your couriers, remittance workflow, fee rules, SMS/WhatsApp provider, and whether you are on Frappe/ERPNext v15 or v16. We then build and unit-test the app against your requirements, deploy it to a staging site for UAT, and only cut over to production once you have signed off — with a documented rollback path. Typical delivery is 2–4 weeks from confirmed scope, and you receive the full git repository so the code is yours to keep, audit, and extend.
What you get
- Installable source code of your version of the COD Manager app, packaged as a proper Frappe app for your bench
- Installation and configuration on your site — DocTypes, `COD Settings`, Mode of Payment, accounts, role profiles and SMS/WhatsApp gateway wiring
- Technical documentation: DocType schema, hooks.py doc events, whitelisted methods, scheduler events and REST endpoints
- End-user guide plus a live training session for your sales, verification and finance teams
- UAT on a staging site with sample orders, plus a documented rollback plan before production cutover
- Post-go-live support window for bug fixes and configuration adjustments after launch
- Handover of the complete git repository so the code is yours to keep, audit and extend
- Compatibility validation against your Frappe/ERPNext v15 or v16 version, recorded in the release notes
Who this is for
COD-heavy online retailer (Pakistan, India, Bangladesh)
Runs an ERPNext-backed store where 60–90% of orders are Cash on Delivery. Needs OTP verification to kill fake orders, a COD fee to offset RTO cost, and a clear view of cash sitting with couriers versus cash actually banked.
GCC / MENA multi-courier merchant
Ships via several courier partners across the UAE, KSA and Egypt, each with its own remittance cycle. Needs per-courier remittance batches reconciled to invoices and automatic Payment Entries so finance stops matching PDFs by hand.
Finance / accounts controller
Owns the ledger and the receivables. Needs COD collections posted to the right clearing and receivable accounts on settlement, RTO and short-payments accounted for, and an audit trail that survives a review — not a spreadsheet reconciliation.
Operations / fulfilment manager
Coordinates verification, dispatch and courier follow-up. Needs role-segregated workflows, delivered-not-remitted and RTO-ageing reports, and status visible on the order form so nothing stalls between confirmed and collected.
Installation overview
Download from ECOSIRE
Buy the license on ecosire.com and download the Cash on Delivery & COD Manager for ERPNext app ZIP from your account dashboard.
Add the app to your bench
Extract the ZIP into your bench's apps folder, or run `bench get-app` with the path to the extracted app.
Install on your site
Run `bench --site SITE_NAME install-app APP_NAME` followed by `bench migrate` to install Cash on Delivery & COD Manager for ERPNext and apply its schema.
Activate your license
Open the ECOSIRE License settings on your site and activate your license key. Requires the free ecosire_connect and ecosire_license_client apps.
How Cash on Delivery & COD Manager for ERPNext Compares
| Criterion | ECOSIRE | Custom Build | Competitor | Odoo Native |
|---|---|---|---|---|
| COD as a payment method | First-class Mode of Payment with clearing account and controlled lifecycle | Whatever you build; usually starts from scratch | Often just a checkout label, shallow accounting | |
| OTP / phone verification | Whitelisted server-side OTP via your SMS/WhatsApp gateway, scheduler-expired | Possible but you design and maintain it | Rarely included; if so, generic | |
| COD fees & limits | Configurable surcharge and per-customer/region limits enforced server-side | Hand-coded rules you own end to end | Basic flat fee at best | |
| Courier remittance tracking | Dedicated Courier Remittance DocType with batches and ageing reports | Bespoke build effort | Usually absent or single-courier | |
| Reconciliation to accounting | Auto Payment Entries on settlement with RTO/short-pay handling | You wire the GL posting yourself | Manual or partial | |
| ERPNext v15/v16 fit & upgrades | Proper Frappe app on its own repo, upgrade-safe | Depends on your discipline | Varies; may lag versions | |
| Ownership & extensibility | Full git repo handover, yours to extend | You own it but also all the effort | Licensed, limited source access | |
| Support & delivery | Scoped build, staging UAT, rollback plan, post-go-live window | Your team's time and risk | Vendor support of variable depth |
Frequently Asked Questions about Cash on Delivery & COD Manager for ERPNext
+Is this an existing app I can download and install today?
No. It is build-to-order. ECOSIRE designs, builds, installs and supports a version tailored to your couriers, remittance workflow, fee rules and SMS/WhatsApp provider. There is no instant download — we scope it, build it, test it on staging, and cut over once you approve.
+How long does delivery take?
Typically 2–4 weeks from confirmed scope. The timeline depends on how many courier integrations, fee rules and edge cases (RTO, partial collection, multi-currency) you need, and on how quickly UAT sign-off happens. We agree the scope and timeline in writing before any build starts.
+Which ERPNext versions do you support, and how are updates handled?
We build and test against Frappe/ERPNext v15 and v16, targeting your specific version. Because it is a proper Frappe app on its own git repo, it survives ERPNext upgrades cleanly. During the post-go-live support window we fix bugs and adjust config; ongoing maintenance or version-migration retainers are available separately.
+How does the OTP / phone verification actually work?
When a COD order is placed, a whitelisted server method generates a one-time code and sends it via your SMS or WhatsApp gateway. The order stays in an unverified state until the customer's code is validated server-side. Codes expire on a scheduler event, and you can require verification before the Sales Order is submitted — filtering out fake and duplicate COD orders.
+How is COD cash reconciled into ERPNext accounting?
Collected cash is grouped into a `Courier Remittance` batch and matched against the originating Sales Invoices. On settlement the app creates the corresponding `Payment Entry` records against the correct receivable and COD clearing accounts, with COD fees, RTO and short-payments handled explicitly — so your GL reflects cash received, not just invoices raised.
+Can it work with our headless storefront or custom checkout?
Yes. COD placement, OTP issue/verify and status lookups are exposed as whitelisted methods callable through the Frappe REST API, so a Next.js, mobile or third-party storefront can drive the flow. We confirm the exact endpoints and payloads with your team during scoping.
+Do we own the code?
Yes. You receive the full git repository for your version at handover — it is yours to keep, audit, self-host and extend. There is no per-seat lock-in and no obligation to keep us on retainer after the support window.
Related Modules
Request a quote
Cash on Delivery & COD Manager for ERPNext
A build-to-order ERPNext app that turns Cash on Delivery into a first-class, controlled payment method — OTP/phone order verification, configurable COD fees and limits, courier collection and remittance tracking, and automatic reconciliation to Payment Entries. ECOSIRE scopes, builds, installs and supports it for your v15/v16 site.
- COD as a first-class payment method mapped to a dedicated `Mode of Payment` and receivable/clearing account, not just an 'unpaid' invoice flag
- OTP / phone verification via a whitelisted server method that issues and validates a one-time code through your SMS or WhatsApp gateway before order confirmation
- Configurable COD surcharge (fixed, percentage, or slab-based) applied server-side as a real charge/line item via `validate` and `before_save` doc events in `hooks.py`
- Per-customer, per-region and per-order-value COD limits enforced in server logic so oversized or high-risk COD orders are blocked or held for approval