Open-source billing software compared: which fits your business model
If you must self-host subscription or usage billing, the shortlist is narrower than it looks. Lago fits teams whose pricing is driven by metered usage and who want metering, pricing, invoicing and collection in one open-source engine, with a separate payment gateway. Kill Bill fits teams that want a Java-hosted subscription engine they can extend with plugins and run in Tomcat. OpenMeter fits teams that already have a billing system and need metering, entitlements and usage limits beside it, but it is still beta and should be treated as an evaluation until you confirm otherwise for your workload. Pick Lago if your invoices are the product of usage, Kill Bill if your engineers want to own a server-side billing core, and OpenMeter only if the gap you need to fill is metering and access control.
Lago is the closest to a complete billing back end. It is licensed under AGPLv3, and its FAQ describes a forever-free open-source edition with fundamental billing features and Enterprise plans that add premium features. The condition that matters is the payment side: Lago calculates what to charge and when, then hands that to a gateway such as Stripe, Adyen or GoCardless, so you must plan that integration and its compliance scope yourself. Its Docker Compose stack runs PostgreSQL, Redis and Gotenberg for PDF generation, and ClickHouse stays off unless you enable it for high-volume events. Lago's own docs point larger deployments to Helm charts and dedicated workers, and they advise pinning the last tagged version rather than the latest image tag.
Which billing platform fits which business model
This table maps common business models to the billing platform most likely to fit, with the reason and the condition that would change the pick. Read each row against your own product, data volumes and existing systems, then confirm the conditions with the vendor or your implementation partner before committing.
| Scenario | Best fit | Why | Condition that would change the pick |
|---|---|---|---|
| Recurring SaaS subscriptions with standard plans and invoices | Lago | Built around metering, pricing and invoicing with an open-source edition covering fundamental billing features and a separate payment processor for collection | Need for premium features in Lago Enterprise plans, or a required feature the open-source edition does not include; confirm with Lago |
| Usage or API metering as the core revenue model | Lago or OpenMeter | Both meter usage and produce invoices; OpenMeter focuses on event ingestion and real-time aggregation, while Lago covers the full billing cycle | If you need only metering and entitlements, OpenMeter fits; if you need invoices and collection in one system, Lago fits better |
| AI or API products that must enforce entitlements and usage limits | OpenMeter | Ingests usage as CloudEvents, attributes it to customers and supports entitlements and usage-limit balances | OpenMeter releases are still beta and can include breaking changes; if you need production stability guarantees, confirm the roadmap before choosing it |
| Java shop with an existing Tomcat estate | Kill Bill | Standalone Java server packaged as a WAR file, run in Tomcat, called through REST APIs with plugins deployed as JARs | Team lacks JDK 11 or Tomcat operations skills, or prefers a Go or Node-based stack; confirm support for your JDK version |
| Team that already runs an invoicing system | Kill Bill or Lago, used for metering and subscriptions only | Both can run subscription and usage logic while your existing system issues invoices, reducing the scope of change | If your invoicing system cannot accept external invoice data or lifecycle events, plan the integration work before choosing; OpenMeter also connects to external invoicing providers |
| Organization needing commercial support or an SLA | Confirm with each vendor before shortlisting | Kill Bill ships without support or SLA, and Lago's paid support depends on its Enterprise plans | A contractual support requirement may rule out the open-source-only option; ask each vendor for written terms |
What a billing platform actually does, and what a payment gateway still does
A billing platform decides what to charge and when, but it does not move the money. Billing work breaks into four stages: metering (recording usage events), pricing (applying plans, tiers and credits), invoicing (producing the bill and its line items), and payment collection (charging a card or bank account and handling retries and failures). Lago's FAQ describes its role as calculating how much to charge and when, then handing that instruction to a payment gateway. The README names Stripe, Adyen and GoCardless as supported providers. Kill Bill covers the same ground with a different shape: it handles subscriptions, invoices and credits, and connects to gateways such as Stripe, Braintree and PayPal through plugins deployed alongside the server. Before you shortlist either tool, map each of the four stages to a system owner in your organization.
The split matters for three reasons. First, scope: the systems that store or transmit cardholder data sit in your PCI DSS scope, and a billing platform that only passes a payment token to a hosted gateway will usually keep that scope smaller than one that handles raw card numbers. Confirm with your assessor which architecture you are proposing, and check whether the gateway's hosted fields or tokenization path is the one you intend to use. Second, contract ownership: the merchant agreement, chargeback liability and settlement reporting belong to whoever holds the gateway account, not to the billing software. Decide that owner before implementation, because switching gateways later means re-pointing plugins or integrations and re-validating retry and webhook behavior. Third, the failure path: when a charge fails, someone must own dunning, retries and reconciliation between invoice status and settlement. Ask each vendor and your own engineers to write down the webhook flow, the stored payment identifiers, and where reconciliation runs. A short illustrative test, such as a declined card in a staging gateway account, will show quickly whether the invoice state, the gateway record and your finance ledger agree.
Capabilities, license and infrastructure across Lago, Kill Bill and OpenMeter
This table compares the three platforms on license, runtime, metering, invoicing, payment and ERP integrations, back-office tooling, core components and release maturity. Where the researched sources do not state a capability, the cell tells you what to confirm with the vendor or in a test deployment. Use it to shortlist, then check the gaps against your own billing model.
| Capability | Lago | Kill Bill | OpenMeter |
|---|---|---|---|
| License | AGPLv3 for the platform; agent SDKs and MCP server are MIT in separate repositories | Apache License 2.0; no support or SLA included | Apache License 2.0 |
| Language or runtime | Not stated in the sources reviewed; confirm the runtime and build process in the repository | Standalone Java server packaged as a WAR, typically run in Tomcat; JDK 11 required by the Tomcat guide | Not stated in the sources reviewed; confirm the runtime for API and worker processes |
| Usage metering | Meters usage and applies pricing as part of its monetization function | Supports usage-based subscriptions | Ingests usage as CloudEvents, attributes it to customers and aggregates in real time |
| Subscriptions and pricing | Calculates what to charge and when, with pricing applied to metered usage | Recurring and usage-based subscriptions, upgrades, downgrades, invoices and credits | Versioned plans with flat, recurring, per-unit, tiered, package or dynamic prices, plus entitlements and subscription changes |
| Invoicing | Produces invoices; PDF generation runs through Gotenberg | Invoices and credits are handled by the core; confirm PDF and template options | Invoice lifecycle that can connect to external invoicing providers |
| Payment gateway integrations | Needs a separate processor; README names Stripe, Adyen and GoCardless | Connects to gateways such as Stripe, Braintree and PayPal through plugins | Billing covers invoices and credits; confirm which payment gateways are supported before you commit |
| ERP and accounting integrations | README lists NetSuite, Xero, Salesforce and HubSpot | Not stated in the sources reviewed; confirm connectors or build your own through the REST APIs | Not stated in the sources reviewed; confirm ERP connectors, and note that Kong plans to bring metering and invoicing into Kong Konnect |
| Back-office UI | Front end included in the Docker Compose deployment | Kaui, a back-office UI with role-based access for support, product configuration, finance reporting and testing | Not stated in the sources reviewed; the quickstart is a local evaluation stack |
| Core runtime components | Front end, API, API worker, clock worker, PostgreSQL, Redis and Gotenberg; ClickHouse optional and off by default | Core server in Tomcat with plugins as JARs; the core team runs MySQL and tests MariaDB 10 and PostgreSQL 12 | API and worker processes with Kafka, ClickHouse and PostgreSQL; Redis optional; Svix used when webhooks are enabled |
| Latest release | v1.55.0, released October 7, 2026 | 0.24.22, published September 29, 2026 | v1.0.0-beta.236, published October 9, 2026 |
| Maturity status | Actively released; the self-hosting docs recommend pinning the last tagged version | In production since 2010; the Billing Project, LLC owns the codebase and trademarks | Beta with possible breaking changes; Kong acquired the project in September 2025 and says it stays open source |
Lago, Kill Bill and OpenMeter in brief
All three options can be self-hosted, but they differ in license terms, operating model and project maturity. The cards separate the license questions, the runtime each one needs and the signals that show how stable each project is. Read them with your legal and platform teams before you shortlist.
Lago platform under AGPLv3
The Lago platform is licensed under AGPLv3, a strong copyleft license that is not permissive in the same way Apache 2.0 is. Its network-use terms can matter if you modify the code and offer it to customers as a service, so review the obligations with counsel before you build on it. Lago fits teams that want one engine for metering, pricing, invoicing and payment collection and can accept those terms.
Lago agent SDKs and MCP server
Lago's agent SDKs and MCP server are MIT licensed and kept in separate repositories from the AGPLv3 platform. A team can send usage events from its own services or AI agents under a permissive license without changing how the core platform is licensed. Check each repository's license file and version before you pin it, because the platform and the connectors are released on their own schedules.
Kill Bill, Apache 2.0 since 2010
Kill Bill is an Apache 2.0 subscription billing platform in production since 2010, with its codebase and trademarks owned by The Billing Project, LLC. It runs as a standalone Java server packaged as a WAR file, usually in Tomcat, and plugins for gateways, tax and fraud are deployed as JARs beside it. The project includes no support or SLA, so confirm whether you will pay a vendor or rely on in-house skills.
OpenMeter, still in beta
OpenMeter is an Apache 2.0 project for metering AI, API and usage-based products, and it can cover only the parts your stack lacks. Its releases are still beta and can include breaking changes, so pin versions and plan upgrades with a test environment. Kong announced on September 3, 2025 that it had acquired OpenMeter, said the project would remain open source under Apache 2.0 and planned to bring its capabilities into Kong Konnect. Ask Kong how that roadmap affects your self-hosted deployment.
OpenMeter runtime requirements
OpenMeter's core runtime combines API and worker processes with Kafka, ClickHouse and PostgreSQL, with Redis optional for distributed deduplication and Svix used when webhook delivery is enabled. The Docker Compose quickstart is a local evaluation stack, and the official Helm chart is intended for development deployments, so the production topology is your own design work. Confirm whether your platform team already runs Kafka and ClickHouse before choosing this option over a lighter deployment.
What each platform runs in your infrastructure
Lago's Docker Compose deployment is the most self-contained of the three, and it is the closest to a standard web application stack. The compose setup runs a front end, an API, an API worker and a clock worker, with PostgreSQL holding application data and Redis serving as the job queue. Gotenberg generates PDF invoices, so your team also operates a document rendering service.
- Core services: A front end, an API, an API worker and a clock worker, all started from the same compose file.
- Data and queue: PostgreSQL for application data and Redis as the job queue.
- Document rendering: Gotenberg generates PDFs, so invoice rendering depends on that service being healthy.
- Optional event store: ClickHouse is available for high-volume events but is disabled by default, so you enable it only when your event volume requires it.
- Scaling path: Lago's self-hosting docs recommend pinning the last tagged version instead of the latest image tag and point larger deployments to Helm charts and dedicated workers.
Confirm with your platform team whether the compose footprint matches your standard for containers, backups and PostgreSQL operations, and whether you will run Helm and dedicated workers from the start.
Kill Bill is a standalone Java server packaged as a WAR file and typically run in Tomcat. Your applications call it through REST APIs, and payment, tax and fraud integrations are deployed as plugin JARs into the same environment. The footprint is a Java application server plus a relational database, which suits teams already operating Tomcat and JVM workloads.
- Runtime: A WAR deployed in Tomcat, with the Tomcat installation guide requiring JDK 11.
- Database choice: The core team uses MySQL and runs regression tests against MariaDB 10 and PostgreSQL 12. The getting started guide also notes deployments on Oracle, Percona and Aurora.
- Back office: Kaui is the internal UI with role-based access for support, product configuration, finance reporting and testing, and it runs as its own component.
- Plugins: Payment gateway, tax and fraud plugins are JARs loaded alongside the server, so each plugin adds a release and upgrade path.
- Docker option: The getting started guide describes Docker images for the server, Kaui and MariaDB.
Confirm the JDK and database versions your security team will approve and whether the core team's MySQL path matches your existing database standard.
OpenMeter has the heaviest data plane of the three because it is built for high-volume usage events. Its core runtime is API and worker processes backed by Kafka, ClickHouse and PostgreSQL. Redis is optional for distributed deduplication, and Svix handles webhook delivery when that feature is enabled. Operating it means operating streaming and analytical infrastructure, not just a web application.
- Event pipeline: Kafka carries ingested usage events to the workers.
- Analytics store: ClickHouse holds aggregated usage for real-time queries.
- Relational store: PostgreSQL holds application data.
- Optional components: Redis for distributed deduplication and Svix for webhooks, enabled only when you need them.
- Deployment tiers: The Docker Compose quickstart is a local evaluation stack, and the official Helm chart is intended for development deployments, so a production topology is a separate design task.
Confirm with OpenMeter's maintainers and your platform team what a production topology looks like, since the README does not describe one, and check the beta release notes before you commit to upgrades.
How to choose and pilot a billing platform in four steps
This sequence turns a shortlist of Lago, Kill Bill and OpenMeter into a documented decision backed by a non-production pilot, so the team knows which platform fits its pricing, integrations and operating load before any contract or production migration begins.
Map every pricing model to each platform's price types
Product and finance leads list every pricing model the business sells today and plans to sell within the next product cycle, including flat, tiered, per-unit, package, usage-based and entitlement-based limits. Engineering then checks each item against the price types and entitlement features each vendor documents: OpenMeter lists flat, recurring, per-unit, tiered, package and dynamic prices with entitlements and usage-limit balances, while Lago and Kill Bill need to be checked against your own cases. Mark each model as native, configurable, or requiring custom code. The step is done when the team has a signed-off matrix with one row per pricing model and one column per platform, and every custom-code entry has an owner.
Confirm payment gateway and accounting integrations
Finance operations and the integration lead write down every payment gateway, tax provider, ERP and CRM the billing data must reach, then test each against the candidate platforms. Lago's README names Stripe, Adyen and GoCardless for payment collection and lists NetSuite, Xero, Salesforce and HubSpot integrations, while Kill Bill connects through plugins to gateways such as Stripe, Braintree and PayPal. Any integration not on a vendor's documented list is a gap to confirm directly with the vendor or the community, and the cost of building it is estimated during the pilot. The step is complete when each required integration is marked as supported, supported by plugin, or gap, with the evidence for each.
Pilot on a pinned release in a non-production environment
The platform or DevOps team deploys each shortlisted platform in a non-production environment using a pinned, tagged release rather than the latest image tag. Lago's self-hosting guidance recommends pinning the last tagged version, and the pilot should record the exact version, configuration and container images used. Team members then run representative invoicing cycles, plan changes, credits and a sample of usage events through the pinned build, and compare results with the pricing matrix from the first step. The step is done when the pilot produces invoices that finance has reviewed against expected amounts, and the pinned versions are documented so the same build can be promoted or rebuilt later.
Measure the operating load before committing
The platform team measures the infrastructure each candidate needs under realistic event volume, not only under the pilot's sample load. For Lago, this covers PostgreSQL, Redis as the job queue, Gotenberg for PDF generation and the optional ClickHouse store for high-volume events, which is disabled by default. For OpenMeter, the team assesses Kafka, ClickHouse, PostgreSQL and any Redis or Svix components. For Kill Bill, it assesses the Tomcat, database and plugin footprint, and the JDK version the chosen release requires. Engineers document who will patch, back up and monitor each component. The step is done when the team has a written operating load estimate, a named owner for each service, and a clear view of which components require specialist skills.
Put the vendor questions in writing before the decision
Procurement and the technical lead send each shortlisted vendor or community maintainer the same written question set and record the answers. Key questions include: which price types and entitlement features are supported natively, which payment and accounting integrations are maintained, what the release cadence and breaking-change policy are, whether the project is in beta or production use, what support and SLA options are offered and at what cost, and how the vendor treats the open-source edition relative to any paid tier. For OpenMeter, ask how the Kong acquisition affects the roadmap and whether the beta status will change before general availability. For Kill Bill, ask what support is available given the project ships without a support or SLA commitment. The step is complete when every answer is filed with the pilot results and the decision record names the platform, the pinned version and the open risks.
How licenses and paid editions change the total cost
The open-source core of Lago and Kill Bill carries no license fee, so the money you spend goes to everything around the software. Lago's FAQ describes a forever-free open-source edition with fundamental billing features, and Enterprise plans add premium features on top. Kill Bill is Apache License 2.0 software with no support or SLA included. Before you budget, confirm with Lago which premium features your use case needs and whether they are needed at all. For Kill Bill, assume every production support expectation is a separate purchase, either from a vendor-side support contract or from your own engineers. OpenMeter is also Apache 2.0, but its releases are still beta, so ask its maintainers, or Kong, what support terms apply to the version you pick.
The total cost has five components. Software is zero for these open-source cores, but Enterprise or support contracts are a license-like line item where they apply. Infrastructure is recurring: hosting for the application, PostgreSQL, Redis, and for OpenMeter Kafka and ClickHouse, plus any payment gateway fees, which are charged per transaction by the processor rather than by the billing tool. Implementation is mostly one-time: integrating the gateway, tax and ERP connectors, and migrating existing subscriptions. Support retainers and upgrades are recurring. Internal staff time is the largest and least visible cost, because someone must run upgrades, watch backups and answer billing questions for finance.
Do not estimate these numbers from list prices, because none are published here. Ask each vendor or implementation partner for a quote built on a written scope that lists the deployment topology, the expected event volume, the payment and ERP integrations, the upgrade cadence and the support hours you need. Ask for each line to be marked one-time or recurring, and ask which items change if event volume grows. A quote that leaves out the Enterprise license terms or the gateway integration is not comparable with one that includes them.
What do teams ask before hiring help to self-host billing?
How much effort does self-hosting Lago, Kill Bill or OpenMeter take?
Effort depends on the platform's runtime footprint and on how many moving parts your team must own. Lago's Docker Compose deployment runs a front end, an API, an API worker, a clock worker, PostgreSQL, Redis and Gotenberg for PDF generation, and its docs point larger deployments to Helm charts and dedicated workers. Kill Bill is a Java WAR typically run in Tomcat, with plugins deployed as JARs and a database the core team tests against MariaDB 10 and PostgreSQL 12. OpenMeter needs Kafka, ClickHouse and PostgreSQL, with Redis and Svix optional. The more stateful services you run, the more upgrade, backup and monitoring work falls to your team.
Can our team run billing software without outside help?
A team with strong platform engineering and a finance-literate owner can run any of these three, but the harder question is whether it has time to own upgrades, data stores and payment integrations indefinitely. Ask whether you have an engineer who can own the database, the job queue and event pipeline, and who can read billing logic well enough to verify invoices. Kill Bill and OpenMeter in particular reward teams with Java or event-streaming experience. Outside help is most useful for initial hardening, backup design, upgrade runbooks and documentation, which can be scoped as a fixed engagement before the team takes over.
What drives the cost of self-hosted billing up or down?
Cost is mostly staff time and infrastructure, not licenses, since all three platforms are open source. The main drivers are pricing complexity (tiers, add-ons, entitlements and credits take longer to configure and test), event volume (high usage volumes push you toward ClickHouse or Kafka sizing), the number of payment gateways and accounting systems to integrate, and the size of any data migration from an existing billing system. Each driver can be reduced by simplifying the price catalog, batching events, limiting first-phase integrations and cleaning history before import. Ask any provider for a quote that lists these drivers separately.
How long does a billing pilot take to run?
No reliable duration can be stated without knowing your price catalog, event volume and integration list, so treat any single number with caution. The pilot length is driven by how many products and price models you must reproduce, whether usage events arrive in a clean format, how many payment gateways and accounting exports are in scope, and how much parallel invoicing you want before cutover. A pilot that limits scope to one product, one gateway and a sample of customers usually finishes faster than one that replays full billing history. Ask for a timeline tied to written deliverables.
What does the work need from our side?
Three inputs usually decide whether the engagement moves quickly. First, payment gateway accounts with API credentials and test-mode access, since Lago requires a separate processor such as Stripe, Adyen or GoCardless and Kill Bill connects through gateway plugins. Second, accounting access for the ledger or export format used by NetSuite, Xero or your ERP, if those integrations are in scope. Third, staff time from finance, product and an engineering owner to approve price definitions and sign off test invoices. Confirm each access request and named contact in the written scope before work starts.
Is OpenMeter production ready given its beta releases?
Not yet for most buyers, and you should plan on that basis. OpenMeter's releases are still beta and can include breaking changes, with v1.0.0-beta.236 published on October 9, 2026. Its README describes the Docker Compose quickstart as a local evaluation stack rather than a production topology, and its official Helm chart as intended for development deployments. That means a production setup would need your own topology design, high-availability planning and upgrade testing. Kong's acquisition announced on September 3, 2025 says the project stays Apache 2.0, but ask Kong and your team how the roadmap will affect self-hosted versions.
Which billing platform fits a team that wants low risk?
Lago and Kill Bill are the more established choices for self-hosted billing, and the right one depends on your model. Kill Bill has been in production since 2010 and is licensed under Apache 2.0, though it includes no support or SLA, so you would need a support contract from a third party or your own staff. Lago is AGPLv3 for the platform, which matters if you modify and distribute or host it for others, and its open-source edition offers fundamental billing features. Confirm your license obligations with counsel before choosing, and pin the version you deploy, which Lago's docs recommend.
The cost of switching billing platforms later
The hardest things to move out of a billing platform are the records that carry financial and legal weight, not the code. Customer records, subscription histories, invoice numbering, credit balances and payment gateway tokens all have to survive a migration intact. Invoice numbers must continue without gaps or collisions, credit balances must match the ledger the finance team already reconciles against, and subscription histories determine how proration and renewals were calculated for past periods. Before you commit, ask each vendor for a complete export of these objects, in a documented format, and test a partial export against your own data. Confirm whether gateway tokens are portable at all. Tokens are usually bound to the payment processor account, so moving them may mean asking the customer to re-authorize payment methods, which is a commercial and customer experience cost rather than a technical one.
A clear data model and documented APIs lower exit risk because they let you extract and rebuild this data without relying on the vendor's internal tooling. Kill Bill and Lago both expose their core objects through REST interfaces and run on relational databases you control, which makes a self-directed export a realistic exercise for your own team to scope. OpenMeter's usage data is ingested as CloudEvents and stored in ClickHouse, so the raw event history is a separate asset you should plan to retain outside the billing layer. Kong's acquisition of OpenMeter, announced on September 3, 2025, said the project would remain open source under Apache 2.0 and that metering, entitlements and invoicing would move into Kong Konnect. That may shape the roadmap, so confirm with the maintainers how the self-hosted feature set, release cadence and beta status are expected to change, and get that answer in writing before you build production workflows on it.
How DeployOpen scopes billing platform selection and implementation
DeployOpen plans, implements, customizes, integrates, hardens, backs up, upgrades, documents and supports self-hosted open-source platforms inside your own cloud accounts, data centers or air-gapped networks. For billing, that means working from a written scope that fits your business model, pricing complexity and payment gateway choices, before any platform is installed.
How we scope
- Map your pricing models, such as flat, usage-based, tiered or prepaid, to the billing features each candidate supports.
- List the payment gateways, accounting and CRM systems your invoices must reach, and confirm which connectors each platform offers today.
- Agree the scope, deliverables and timelines in writing before any work starts, since most engagements are fixed-scope.
How we build
- Deploy the chosen platform in your environment, pinning a tagged release and documenting the database, queue and worker topology.
- Configure plans, prices, taxes and invoice templates, then integrate the payment gateway and event flows you specified.
- Test invoice accuracy, proration, usage ingestion and failed-payment handling against scenarios your finance team signs off.
How we hand over
- Deliver runbooks covering installation, upgrades, backups, access roles and the procedure for moving between release tags.
- Document the data flows between billing, payment providers and ledgers so finance and audit teams can trace each charge.
- Train the operators and back-office users on the admin tooling and confirm they can run the platform without us.
How we support
- Offer ongoing support, upgrades and continuous testing as a retainer after the handover is complete.
- Review each new release for breaking changes and schedule upgrades in a staging environment before production.
- Ask for a quote built from the written scope, and confirm with the vendor which support terms, if any, the platform includes.

