Subscription & Recurring Billing for ERPNext

Key Features

Dedicated `Subscription Plan` and `Subscription Plan Tier` DocTypes supporting flat, tiered, volume, and per-unit pricing models

Auto-recurring `Sales Invoice` generation driven by `scheduler_events` daily/cron hooks — no manual billing run required

Day-accurate proration engine for mid-cycle upgrades, downgrades, and plan swaps, posting the delta as a prorated invoice line or credit note

Usage-based and metered billing via a `Usage Record` DocType, aggregated and rated at period close

Whitelisted `@frappe.whitelist()` REST endpoints to ingest usage events and trigger billing securely from your app or telemetry pipeline

Configurable dunning sequence (`Dunning Attempt` DocType) with retry intervals, escalation emails, grace period, and auto-suspend on exhaustion

Payment-gateway retry handling for failed charges via `Payment Entry` reconciliation and webhook-driven state updates

Business logic in `hooks.py` doc events (`validate`/`on_submit`/`on_cancel`) and typed controller methods — not fragile client-only code

Client Scripts for the plan-change and quantity-adjustment UX inside the ERPNext Desk

Custom Role Profiles and permission rules separating billing operators from GL/accounting access

Automatic renewal, cancellation, pause/resume, and trial-period handling with lifecycle state on the subscription

MRR / churn / active-subscription reporting via Query Reports and Number Cards on a dedicated workspace

Email notification templates for renewal reminders, receipts, dunning notices, and cancellation confirmations

Full timeline/comment audit trail on every automated invoice, retry, and state change; targets Frappe/ERPNext v15 with v16 readiness

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

Go live + support

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

About this Product

Subscription businesses on ERPNext hit a wall fast. The stock Subscription and Subscription Plan DocTypes handle a flat monthly or annual invoice against a fixed price, but they were never designed for real recurring-revenue operations: mid-cycle plan changes with correct proration, metered usage rated at period close, tiered or volume pricing, grace periods, or a dunning sequence that retries a failed charge and escalates before it suspends the customer. Teams end up patching the gap with spreadsheets, manual credit notes, and a monthly scramble to reconcile who owes what — which quietly leaks revenue and burns finance hours every billing run.

ECOSIRE builds a proper Frappe app (its own module, installed on your bench alongside ERPNext) that closes that gap without forking core. We introduce dedicated DocTypes — Subscription Plan Tier, Usage Record, Billing Run, and Dunning Attempt — linked to native Customer, Sales Invoice, and Payment Entry so your ledger, GL, and reporting stay ERPNext-native. Recurring invoice generation and dunning retries run on scheduler_events (cron and daily hooks) so nothing depends on someone remembering to click a button. Proration on upgrades and downgrades is computed against the exact day count of the current billing period; usage-based and metered lines are aggregated from Usage Record rows (ingested via whitelisted REST endpoints or your product's telemetry) and rated at period close.

Technically, the app is wired the way a maintainable Frappe app should be. Business rules live in hooks.py doc events (validate, on_submit, on_cancel) and typed server-side controller methods rather than scattered client logic; whitelisted @frappe.whitelist() methods expose a clean surface for the Frappe REST API so your app, website, or payment webhook can push usage and trigger billing securely. Client Scripts drive the plan-change and quantity UX in the Desk, custom Role Profiles and permission rules keep billing operators out of the GL, and every automated action writes to a comment/timeline trail for audit. It targets Frappe/ERPNext v15 and is v16-ready, and we validate against your actual instance and payment gateway, not a generic demo.

Because this is build-to-order, nothing is a black-box download. We start with a scoping call to map your plans, proration policy, metering source, dunning cadence, and gateway. We build against your requirements, run UAT on a staging bench, and only then install on production with a rollback plan. Typical delivery is 2–4 weeks from confirmed scope depending on complexity (metered billing and multi-gateway retries add time). You receive the full source in a git repository you own, so you are never locked to us.

What you get

Installable source code for your version of the app, as a proper Frappe app (`bench get-app` / `bench install-app` ready)

Installation and configuration on your bench, including scheduler enablement and gateway/webhook wiring

Technical documentation: DocType reference, hooks and scheduler map, REST endpoint spec, and permission model

End-user guide plus a live training session for your billing and finance operators

Post-go-live support window for defect fixes and configuration questions

UAT on a staging bench with a documented rollback plan before production install

Git repository handover with full commit history — you own the code, no vendor lock-in

Configuration sheet capturing your plans, proration policy, dunning cadence, and metering source for future changes

Who this is for

SaaS Finance / RevOps Lead

Runs recurring revenue on ERPNext and needs correct proration, metered billing, and MRR/churn visibility without exporting to spreadsheets. Wants failed-payment dunning to run automatically instead of chasing invoices by hand.

Membership or Subscription-Club Operator

Bills members on monthly/annual cycles with tiers, trials, pauses, and renewals. Needs reliable auto-invoicing and grace-period handling so members aren't wrongly suspended, all inside their existing ERPNext ledger.

Recurring-Service Provider (Maintenance/Retainer)

Invoices retainers and service plans on repeating schedules with occasional usage overages. Needs day-accurate proration on plan changes and a clean audit trail tying each invoice to the contract.

ERPNext Implementer / Fractional CTO

Owns the client's bench and wants a maintainable Frappe app that respects core — doc-event hooks, whitelisted APIs, permission-scoped roles — with source handed over in git rather than an opaque marketplace binary.

How Subscription & Recurring Billing for ERPNext Compares

Criterion	ECOSIRE	Custom Build	Competitor
Proration on plan changes	Day-accurate proration engine posting the delta automatically	Possible, but you design and test the date math yourself	Often flat-swap only; proration limited or absent
Usage / metered billing	`Usage Record` ingestion via REST, rated at period close	Buildable from scratch at significant effort	Rarely supported; fixed-price focus
Dunning & failed-payment retries	Configurable retry sequence, escalation, grace, auto-suspend	Manual to build and easy to get wrong	Basic reminder emails at best
Fits your exact billing policy	Scoped and built to your plans, cadence, and gateway	Fully bespoke but you own the whole build	You bend your process to its assumptions
Delivery time	2–4 weeks from confirmed scope	Months of in-house dev and QA	Instant install, then heavy configuration/gaps
Source ownership	Full source in a git repo you own — no lock-in	You own it entirely	Often a closed binary or license-gated
Architecture quality	Doc-event hooks, whitelisted APIs, scoped roles, no core fork	Depends entirely on your team's discipline	Variable; may override core or leak client logic
Support & training	Install, docs, training session, post-go-live window	Whatever you staff internally	Community forum or paid tickets, no training

Frequently Asked Questions about Subscription & Recurring Billing for ERPNext

How is this different from ERPNext's built-in Subscription DocType?

Core ERPNext handles a flat recurring invoice against a fixed plan price. It does not do day-accurate proration on mid-cycle plan changes, usage-based or tiered metered billing, or a real dunning sequence with retries and escalation. This app adds those as dedicated DocTypes and scheduler-driven automation while keeping your invoices, GL, and reporting fully ERPNext-native.

How long does delivery take?

This is a build-to-order app, not an instant download. Typical delivery is 2–4 weeks from confirmed scope. Straightforward plan-and-dunning setups land near the short end; metered billing, multiple payment gateways, or complex proration rules push toward the longer end. You get a firm timeline after the scoping call.

Which Frappe/ERPNext versions are supported?

The app targets Frappe/ERPNext v15 and is built to be v16-ready. We validate against your actual instance and version during UAT on a staging bench before installing on production, rather than assuming a generic environment.

How do updates and support work after go-live?

You get a post-go-live support window for defect fixes and configuration questions. Because you receive the full source in a git repository you own, your team or any Frappe developer can maintain and extend it — you are not locked to ECOSIRE. We can also quote an ongoing support/enhancement retainer separately.

Can it connect to our payment gateway for automatic retries?

Yes. Failed-charge retries are driven by webhook-updated state and reconciled against `Payment Entry`. We wire your specific gateway during the build and configure the dunning retry intervals, escalation emails, and grace period to your policy. Supported gateways depend on their API availability and are confirmed during scoping.

Will this modify or fork ERPNext core?

No. It ships as a separate Frappe app with its own module and DocTypes, using `hooks.py` doc events, whitelisted methods, Client Scripts, and scheduler events. Core stays untouched, which keeps your bench upgradeable to future ERPNext versions.

How do we feed usage data for metered billing?

Usage is captured in a `Usage Record` DocType. Your application or telemetry pipeline pushes events through whitelisted `@frappe.whitelist()` REST endpoints (or you enter them manually), and the app aggregates and rates them at period close into the recurring invoice. We define the ingestion contract with you during scoping.