Platform Capability
Extend Kill Bill Without Forking the Core
Build custom plugins in Java or Ruby, react to real-time events, and integrate with any system through a comprehensive REST API. Kill Bill's plugin architecture keeps your customizations isolated, upgradable, and production-safe.
Trusted by companies processing billions in revenue
Capabilities
What You Can Do
Connect, extend, and automate across your billing and business systems.
Custom Plugins
Write plugins in Java or Ruby that run inside the Kill Bill process. OSGi isolation means your code has its own classloader and lifecycle. Deploy, update, or roll back plugins without touching the core.
Learn more →
Real-Time Event Bus
Subscribe to billing events (invoice created, payment succeeded, subscription changed) and trigger custom logic in real time. Build workflows, sync to external systems, or enforce business rules without polling.
Learn more →
Comprehensive REST API
Every Kill Bill operation is available through a well-documented REST API. Create subscriptions, generate invoices, process payments, manage accounts, and query data programmatically. Client libraries are available for Java, Python, Ruby, PHP, and Node.js.
Learn more →
Payment Gateway Plugins
Integrate with any payment processor through the plugin framework. Kill Bill includes plugins for major gateways, and you can build custom plugins for internal or regional processors. Switch gateways without changing application code.
Learn more →
ERP and CRM Integration
Connect Kill Bill to your enterprise systems. Sync invoices and payments to NetSuite, SAP, or QuickBooks. Push subscription data to Salesforce or HubSpot. The event bus and APIs make bidirectional integration straightforward.
Learn more →
1,100+ Automated Tests
The Kill Bill core and plugin framework are backed by over 1,100 automated tests. Your custom plugins run in the same tested environment, and the plugin testing harness lets you write integration tests for your own code.
Learn more →
How It Works
From Plugin to Production
1
Build Your Plugin
Use the Kill Bill plugin framework to write Java or Ruby code. Implement well-defined interfaces for payment, notification, invoice, or custom logic. Test locally against the Kill Bill test harness.
2
Deploy and Configure
Install the plugin into Kill Bill's plugin directory. OSGi isolation ensures your plugin runs independently. Configure it through the API or admin UI. No core restarts required for plugin updates.
3
React and Integrate
Your plugin receives events from the billing engine and executes your custom logic: syncing data, calling external APIs, modifying invoices, or routing payments. Everything is logged and auditable.
Why Kill Bill
Why Teams Choose Kill Bill's Plugin Architecture
Customize Without Risk
Plugins run in isolated classloaders. A bug in your plugin cannot crash the billing engine. Deploy, update, and roll back independently of the core platform.
Upgrade-Safe
Because plugins use stable interfaces, you can upgrade Kill Bill to newer versions without rewriting your customizations. The plugin contract ensures backward compatibility.
Real-Time Automation
The event bus delivers billing events as they happen. No batch jobs. No polling delays. Your integrations respond in real time to every subscription, invoice, and payment event.
Any Integration
REST APIs and event hooks connect Kill Bill to any system: ERPs, CRMs, data warehouses, analytics platforms, custom dashboards, or internal tools. No vendor lock-in on integrations.
Open Source Community
Dozens of community-maintained plugins are available for common use cases: payment gateways, email notifications, analytics, and more. Start with existing plugins and customize as needed.
Developer-Friendly
Comprehensive API documentation, client libraries in five languages, a local test harness, and an active community. Engineers are productive from day one.
FAQs
Frequently Asked Questions
What languages can I use to write plugins?
Kill Bill supports plugins written in Java or Ruby. Java plugins use the OSGi framework and are packaged as bundles. Ruby plugins use JRuby and are simpler to write for lightweight integrations. Both have access to the same plugin APIs and event bus.
Can I use Kill Bill as an embedded library?
Yes. Kill Bill can run as a standalone server or be embedded directly into your Java application. In embedded mode, you call Kill Bill APIs directly from your code without HTTP overhead. This is useful for high-performance or tightly coupled architectures.
How do I test plugins before deploying to production?
Kill Bill provides a test harness that runs the full billing engine locally. You can write integration tests for your plugins that create subscriptions, generate invoices, and verify your plugin's behavior end-to-end before deploying.
Does a plugin failure affect the billing engine?
Plugins run in isolated OSGi containers with their own classloaders. A plugin crash does not bring down the Kill Bill core. The engine continues processing, and plugin errors are logged and can trigger alerts through your monitoring setup.
Are there pre-built plugins for common integrations?
Yes. Kill Bill has pre-built plugins for Stripe, Adyen, PayPal, and other payment gateways, as well as plugins for email notifications, analytics, and tax calculation. These are open source and can be used as-is or as starting points for custom plugins.
Ready to Build on Kill Bill?
Explore the plugin framework, REST APIs, and integration patterns. Start with the sandbox or talk to our team about your architecture.