Skip to main content
ERPNext Subscription & Recurring Billing Pro — A build-to-order ERPNext app that extends native Subscription with usage meter — 1/1Illustrative preview

A build-to-order ERPNext app that extends native Subscription with usage metering,

proration, automated dunning, and revenue recognition.

ECOSIRE scopes, builds, installs, and supports it on your bench — this is not an instant Marketplace download.

What is ERPNext Subscription & Recurring Billing Pro?

A build-to-order ERPNext app that extends native Subscription with usage metering, proration, automated dunning, and revenue recognition. ECOSIRE scopes, builds, installs, and supports it on your bench — this is not an instant Marketplace download. Built to order by ECOSIRE for ERPNext v15, v16 — indicative price from $999.00 USD; request a quote for a scoped proposal.

Key Features

Dedicated Frappe app with its own module, `hooks.py`, and fixtures — installed on your bench, not a pile of loose server scripts
`Billing Plan` DocType supporting flat, tiered, volume, and per-unit usage pricing with effective-dated price rules
`Usage Record` metering ingested through a whitelisted REST method (`/api/method/...`) with idempotency keys for safe retries
Scheduler job (`scheduler_events`) that aggregates usage per subscription each period and drafts/submits the `Sales Invoice`
Mid-cycle proration and plan upgrade/downgrade logic on `on_update`/`on_submit`, generating correct credit and charge lines automatically
`Dunning Policy` DocType with a configurable retry cadence and escalation to suspend/cancel when the policy is exhausted
Automated dunning scheduler that walks overdue invoices and fires templated reminders via Frappe `Notification` and `Email Queue`
Deferred revenue recognition via native ERPNext deferred-accounting fields plus a `Revenue Schedule` DocType reconciled to the Chart of Accounts
Payment-gateway webhook handler (Stripe/Razorpay/local) as a whitelisted method that updates payment status and short-circuits dunning on success
Client scripts for in-form UX: live proration preview, one-click 'run dunning now', and plan-change confirmation dialogs
Role profiles and permission-level (perm-level) field masking so billing clerks, AR managers, and auditors see only what they should
Server-side rating engine callable from both the scheduler and the REST API so batch and real-time invoicing use identical logic
Report DocTypes / query reports for MRR, churn, deferred-revenue waterfall, and dunning-recovery, filterable by plan and customer group
Built against Frappe/ERPNext v15 and v16, pinned to your bench version, with upgrade-safe patches under `patches.txt`

Built to order, done for you

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

  1. 1

    You order

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

  2. 2

    We build & install

    ECOSIRE builds, configures and installs it on your ERPNext.

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

ERPNext Compatibility
—
License
Licence confirmation required
Python Requirement
Python 3.10+
Database
MariaDB 10.6+

About this Product

If you run a subscription or usage-based business on ERPNext, you have probably hit the ceiling of the native Subscription DocType. Core ERPNext can generate a recurring Sales Invoice on a fixed plan cycle, but it cannot meter consumption, prorate a mid-cycle plan change, chase failed payments on a schedule, or recognize revenue over the service period. Finance teams end up exporting to spreadsheets, hand-adjusting deferred revenue via manual Journal Entry, and manually emailing customers whose cards declined — exactly the error-prone, un-auditable work an ERP is supposed to eliminate. ERPNext Subscription & Recurring Billing Pro closes that gap as a proper Frappe app installed on your own bench.

We build a dedicated Frappe app (its own module, DocTypes, and hooks.py) rather than bolting scripts onto core. Typical DocTypes include Billing Plan (with tiered and volume price rules), Usage Record (metered events posted via a whitelisted REST endpoint), Dunning Policy, and Revenue Schedule. A nightly scheduler_events job aggregates Usage Record rows per subscription, applies your rating rules, and drafts or submits the period Sales Invoice. Proration and plan upgrades are handled with server-side logic on document events (on_submit, on_update) so a mid-cycle switch generates the correct credit and charge lines automatically, with full ledger backing rather than a manual adjustment.

Dunning runs as a scheduled job that walks overdue invoices, follows your configured retry cadence (for example day 1 / 3 / 7 / 14), fires templated email or SMS reminders through Frappe's Notification and Email Queue, and escalates to suspend/cancel actions when the policy exhausts. Deferred revenue is posted through ERPNext's native deferred-accounting fields plus a Revenue Schedule DocType, so month-by-month recognition ties back to your Chart of Accounts and reconciles against invoiced amounts — auditors see a clean trail, not a black box. Where you need a payment gateway (Stripe, Razorpay, a local processor), we wire the webhook to a whitelisted method that updates payment status and short-circuits dunning on success.

Everything respects Frappe's permission model: role profiles, permission levels, and user-permission scoping so a billing clerk, an AR manager, and an auditor each see only what they should. Client scripts add the in-form UX (live proration preview, one-click "run dunning now"), and every automated behavior is covered by hooks.py doc events and scheduler entries so it survives upgrades. The app targets Frappe/ERPNext v15 and v16, and we pin to your exact bench version at scoping time.

Because this is build-to-order, nothing ships until we agree on scope. We start with a short scoping call, produce a written specification and fixed quotation, then build against your real plans, tax rules, and gateway. Typical delivery is one working week from confirmed scope. You get UAT on a staging site, a rollback plan, the full git repository, and a post-go-live support window — not a mystery zip from a marketplace.

What you get

  • Installable source code for your version of the app (a proper Frappe app, pip/bench-installable)
  • Installation and configuration on your bench, including scheduler and gateway wiring
  • Technical documentation: DocType reference, `hooks.py` events, whitelisted API endpoints, and scheduler map
  • End-user guide plus a live training session for your billing and finance team
  • UAT on a staging site with sign-off, plus a documented rollback plan before production cutover
  • Post-go-live support window for defect fixes and configuration adjustments
  • Full git repository handover with commit history and README
  • Data migration/backfill scripts for existing subscriptions and open invoices where required

Who this is for

SaaS / usage-based finance lead

Runs a metered or seat-based product on ERPNext and needs consumption rated, invoiced, and recognized correctly each period instead of reconciling usage in spreadsheets and posting manual journal entries.

AR / collections manager

Owns cash collection and wants failed-payment retries, reminder cadences, and suspend/cancel escalation to run automatically on a schedule, with a recovery report that shows what dunning actually recovered.

Financial controller / auditor

Needs deferred revenue recognized month-by-month against the Chart of Accounts with a clean, reconcilable audit trail, and role-scoped access so recognition schedules can't be silently overwritten.

ERPNext implementation partner / internal admin

Manages the bench and wants an upgrade-safe Frappe app with proper DocTypes, `hooks.py` events, and `patches.txt` — not brittle server scripts that break on the next v15/v16 update.

How ERPNext Subscription & Recurring Billing Pro Compares

CriterionECOSIRECustom BuildCompetitorERPNext Native
Usage-based billingMetered via `Usage Record` + rating enginePossible but built from scratchRarely metered; mostly flat plansNot supported — fixed plans only
Mid-cycle proration & upgradesAutomatic credit/charge lines on plan changeDepends on developer effortUsually manual or absentManual invoice edits
Dunning automationScheduled retry cadence + escalationMust build scheduler + policy yourselfBasic reminders at bestNo scheduled dunning
Deferred revenue recognition`Revenue Schedule` reconciled to CoACustom accounting logic, high riskSeldom includedNative fields, no schedule automation
Fit to your processBuilt to your plans, tax, and gatewayFully bespoke if you have the timeTake it as shippedGeneric defaults only
Upgrade safety (v15/v16)Proper app + `patches.txt`, version-pinnedOnly if disciplinedVaries; can break on updatesMaintained by Frappe
Support & ownershipSupport window + full git handoverYou own and maintain everythingVendor-dependent, limited scopeCommunity/self-support
Time to liveone working week from confirmed scopeMonths of in-house buildInstant but genericImmediate but insufficient

Frequently Asked Questions about ERPNext Subscription & Recurring Billing Pro

How long does delivery take?

This is build-to-order, so there is no instant download. After a scoping call we send a written specification and fixed quotation; once you confirm scope, typical delivery is one working week depending on the number of pricing models, your payment gateway, and any data migration. UAT on staging happens before production cutover.

Which Frappe/ERPNext versions do you support?

We build for Frappe/ERPNext v15 and v16 and pin to your exact bench version at scoping time. The app is packaged as a standard Frappe app with upgrade-safe patches (`patches.txt`) so it survives bench updates rather than breaking on them.

What do support and updates look like after go-live?

Every build includes a post-go-live support window for defect fixes and configuration adjustments. Because you receive the full git repository, your team can extend it, and we offer ongoing support or version-migration engagements (for example v15 to v16) as a separate agreement.

Why not just use ERPNext's native Subscription feature?

Native `Subscription` generates fixed-plan recurring invoices but has no usage metering, no mid-cycle proration, no scheduled dunning cadence, and no automated deferred-revenue schedule. This app adds those as first-class DocTypes and scheduler jobs while still posting through native ERPNext accounting.

Can it meter usage from our product and integrate a payment gateway?

Yes. Usage events are posted to a whitelisted REST method with idempotency keys, so your product or an external service can push consumption safely. Gateway webhooks (Stripe, Razorpay, or a local processor) are handled by whitelisted methods that update payment status and stop dunning on a successful charge. Exact integrations are confirmed during scoping.

Do we own the code?

Yes. You receive the full source as an installable Frappe app plus the git repository with history. There is no per-seat license lock-in on the app itself; it runs on your bench and your team can read, audit, and extend it.

How does it keep our revenue recognition auditable?

Deferred revenue is posted through ERPNext's native deferred-accounting fields backed by a `Revenue Schedule` DocType, so recognition ties to your Chart of Accounts and reconciles against invoiced amounts. Perm-level permissions and audit logging prevent silent edits, giving auditors a clean trail.

Request a quote

ERPNext Subscription & Recurring Billing Pro

A build-to-order ERPNext app that extends native Subscription with usage metering, proration, automated dunning, and revenue recognition. ECOSIRE scopes, builds, installs, and supports it on your bench — this is not an instant Marketplace download.

  • Dedicated Frappe app with its own module, `hooks.py`, and fixtures — installed on your bench, not a pile of loose server scripts
  • `Billing Plan` DocType supporting flat, tiered, volume, and per-unit usage pricing with effective-dated price rules
  • `Usage Record` metering ingested through a whitelisted REST method (`/api/method/...`) with idempotency keys for safe retries
  • Scheduler job (`scheduler_events`) that aggregates usage per subscription each period and drafts/submits the `Sales Invoice`

Request a Quotation

Tell us about your ERPNext Subscription & Recurring Billing Pro requirements and we'll send pricing, licensing options and a tailored proposal — usually within one business day.

No payment now. This sends a quote request to our team — we'll follow up by email with pricing and next steps.