Multi-tenant subscription billing, metering, and revenue on one correct double-entry ledger. Route money through any processor, swap it in a day — and watch the books reconcile in the sandbox before you wire a cent.
Private beta. Founding customers lock pricing for life.
Every charge routes to a gateway, resolves through its lifecycle, and lands as a double-entry journal. The books match the processor to the cent.
Synthetic feed for illustration
Four processors live today, each a config value behind the same ledger. And because the edge is adapters, the next one is a day of work, not a rewrite.
Sixty-two bounded domains behind one API, each built for the failure mode that costs a team real money.
The entire payment, payout, and webhook edge sits behind adapters. Changing a processor is a config value, not a re-platform.
without it a re-platform every time you change processor
Row-level security on every query. One tenant can never read another, enforced below the handler where it cannot be forgotten.
without it one tenant reading another's money
Every mutation carries a key. Retries, webhook replays, and double clicks collapse to a single effect.
without it double charges on a retry
A hard sandbox boundary that batch jobs respect too, so test data never bills a real customer.
without it test data billing a real customer
A hash-chained log of every state change. Tamper with one row and the chain breaks visibly.
without it an audit you cannot defend
No floats, ever. Zero-decimal currencies handled natively, so the books never round the wrong way.
without it rounding that quietly breaks the books
Sixty-two bounded domains behind one API. Each is a system you would otherwise staff, maintain, and get subtly wrong — already here, already reconciled.
If it touches money, it is already in the box — not a roadmap item.
See every domainThe whole commercial motion on one system — the deal, the contract, and the money that follows — so they never drift apart. Billing is one part of a longer line.
Build a quote in any pricing model and send it for approval. Nothing is committed yet.
Redline, approve, and e-sign. A clause library, obligations, and legal hold come with it.
The signature flips entitlements on. Access and billing start the moment the ink dries.
Subscription and metered lines drafted together, tax resolved, numbered per your scheme.
Route to any gateway, charge, retry soft declines, and reconcile against the processor 1:1.
Revenue posts to the double-entry ledger and the next renewal schedules itself.
From first redline to recognized revenue without a handoff. The paper and the money are the same system, so nothing is re-keyed and nothing drifts.
Approved language with owners, versions, and restore — reused, not retyped.
Track changes, route for approval, and lock the final before anyone signs.
Sequential signers, magic-link signing, a signed PDF, and a certificate of completion.
The signature is the switch — entitlements flip on and billing starts the same instant.
Track what each side owes, and schedule renewals before they lapse.
Amend live contracts and freeze records under hold without breaking the chain.
The same path runs for a one-dollar metered charge and a six-figure renewal.
Ingest events over the API, deduped on an idempotency key and aggregated inside a locked period.
Apply the price model, flat to graduated, and draft an invoice with tax resolved. Nothing charged yet.
Pick a gateway per rule, charge, clear 3DS, retry soft declines. The processor is configuration.
Land a double-entry journal, reconcile against the gateway 1:1, recognize revenue.
subinc does not track money with a float and a balance column. It posts double-entry journals in minor units, so debits equal credits on every write and the books never drift.
The gateway clears the charge and the webhook normalizes.
Balances match the processor to the cent, one to one.
Revenue posts to the ledger and the audit chain extends.
Free to build. In production, meter usage or take a share of volume — switch the basis to whichever matches your model.
Illustrative pricing, plans not final
Test mode only — nothing billed
Build and test against the full API. No card, no limits on test data.
+ metered on billing events
Production billing for a scaling SaaS. A platform fee plus what you meter.
Volume rates + SLAs
For teams moving serious money. Dedicated support, SLAs, and controls.
No sales call, no demo booking. Sign up, run a real charge in test mode, and watch the ledger balance itself.
Sandbox in seconds. No card, the full API in test mode.
Pick a price and get a hosted checkout link back.
Open the link, pay in test mode, clear 3DS like production.
A balanced double-entry journal posts. The books match the processor to the cent.
Start in the sandbox, wire one gateway, and go live when the ledger reconciles. Card data never touches your code.
We are onboarding a small group of founding customers before public launch. Founding teams lock pricing for life and help shape the platform.
Lock founding-customer rates before public pricing goes live — grandfathered through every change after launch.
A shared channel with the people writing the code. Tell us where billing hurts; shape what ships next.
Priority sandbox access and hands-on onboarding the moment we open.
Bring your gateway, your currency, your edge case — we build the adapter to it.