Skip to content
Biller
CanadaMoneris cards and RBC PAD

Billing that keeps its own books.

Biller runs quotes, contracts, subscriptions, invoices and collections through one API, on the card processor and bank you already use. Every change is priced before it’s committed, every posting balances, and nothing is rewritten.

Request a demo Explore the API

Quotes · Contracts · Subscriptions · Invoices · A/R · Payments · Entitlements

The Biller console overview: monthly recurring revenue, open receivables, a receivables aging chart, work queues and the latest payments.

One system of record

From signed quote to settled cash.

Each stage is its own record with its own rules, linked by policy, so a change in one place never quietly rewrites another.

  1. Quote

    Versioned, accepted by link

  2. Contract

    Sealed with a checksum at signing

  3. Subscription

    Effective-dated, never edited

  4. Invoice

    Finalized once, corrected by credit note

  5. Collections

    Reminders, fees and holds on a policy

  6. Payment

    Idempotent, reconciled when uncertain

  7. Settlement

    Matched to the deposit, fees posted

  8. Entitlement

    Access that follows the bill

Processor-independent

Subscriptions and invoices stay valid when you change gateways. Processors and banks move the money; Biller keeps the terms, the math and the books.

Immutable by design

Executed contracts, finalized invoices and posted journal lines are locked by the database. Corrections are amendments, credit notes and reversals.

Preview before commit

Plan changes and contract amendments are priced by the same code that commits them, so the preview is the invoice.

Exactly-once effects

Idempotency keys on money commands, one claim per billing period, and a timeout is never mistaken for a decline.

Quotes & contracts

Quotes customers accept with a link. Contracts nobody can quietly edit.

Send a versioned quote with a single-use acceptance link. Acceptance records who decided, when and from where, then drafts the contract. Executing it seals the terms and creates the subscriptions and one-time charges in one transaction.

  • Negotiated prices snapshot onto each line, untouched by later catalog changes
  • Ramps, one-time charges, renewals and notice terms on the contract
  • Amendments preview the exact proration before they execute
  • Terminations end billing at local midnight and credit unused time
A quote as the customer sees it: line items, recurring and one-time totals, notes, and the form to accept it.

Subscriptions & invoicing

Change a plan mid-cycle. See the exact invoice first.

Subscriptions are effective-dated schedules, not mutable rows. A change closes one segment and opens the next, and proration is computed to the second in the subscription’s own time zone.

  • Flat, per-unit, volume, graduated, package and metered prices
  • Calendar billing with month-end anchors and real daylight-saving hours
  • Prorations land on the next invoice, invoice now, or not at all
  • Finalized invoices are frozen; credit notes and voids post reversing entries
Changing a subscription in the console: the item quantity goes from 46 to 52 and the preview shows the credit, the charge and the amount on the next invoice.

Accounts receivable

Collections that run on schedule and stop the moment an invoice is paid.

Build dunning policies from reminders, late fees, service holds, tasks and autopay retries, timed from each invoice’s due date. Every invoice keeps the policy version it was finalized under.

  • Payment plans pause dunning while they’re kept, and resume it if they default
  • Late fees with caps, never charged on an invoice made of late fees
  • Statements with an opening balance, running balance and aging
  • Aging by currency and customer, as of any date
Two collection policies drawn as timelines: reminders before and after the due date, a capped late fee, a service hold and a follow-up task.

Entitlements & usage

Access that follows the bill.

Products grant features and subscriptions carry the grants. Your application asks one endpoint whether a customer may use something, and the answer already accounts for overrides and collection holds.

  • Typed features: switches, limits, allowances, durations
  • Overrides with a reason and an effective date, revoked rather than deleted
  • Usage events are idempotent by event id; corrections are new events
  • Usage summaries aggregate exactly the way invoicing does
A customer’s effective entitlements: a feature that is enabled, a vehicle limit raised by an override, and an access check.

Subledger

A subledger that balances, or doesn’t post.

Every invoice, payment, credit, refund and processing fee posts a double-entry journal entry. The database rejects an unbalanced entry and refuses edits to posted lines. Customer balances are derived from postings, never from invoice flags.

  • Receivables, revenue, tax payable, cash clearing, customer credit, fees and bad debt
  • Voids, returns and write-offs are reversing entries with their own audit trail
  • Settlement fees post as they’re reconciled
The journal: processing fees, finalized invoices, received and returned payments, each with its accounts and amount.

Payments

Your processor. Your bank. One orchestration layer.

Biller never holds funds. It prepares each attempt, submits it to the gateway and records the normalized outcome, so a network timeout becomes a reconciliation, not a double charge.

How payments work
Cards

Moneris

Payment methods are processor tokens, so card numbers stay out of your systems and ours. Status checks settle attempts whose outcome is unknown.

Pre-authorized debit

RBC

Mandates with agreement evidence, Rule H1 confirmation and pre-notification, CPA-005 files, and returns that reopen invoices and reschedule collections.

Reconciliation

Settlements

Import a processor’s settlement once. Each item is matched by reference, fees post to the ledger, and the expected net is checked against the deposit.

Developers

An API designed for the retry.

Every endpoint the console uses is public. Retries are safe, errors are typed, and webhooks arrive as signed CloudEvents.

  • Idempotency-Keyon every money command, replayed with Idempotent-Replayed: true
  • RFC 9457problem details with stable error codes
  • Cursor paginationwith ETags and If-Match on versioned resources
  • Test and liveenvironments with separate keys and data
Read the developer guide 
curl "$BILLER_API/subscriptions/$SUBSCRIPTION/preview-change" \
  -H "Authorization: Bearer $BILLER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "changes": [{
      "subscription_item_id": "01a10b01-070f-7008-aa36-e1d6e866f415",
      "quantity": "52"
    }],
    "proration_behavior": "create_prorations"
  }'
Response200 OK
{
  "data": {
    "currency": "CAD",
    "effective_at": "2026-10-05T07:57:43Z",
    "credits_minor": -6214,
    "charges_minor": 7025,
    "tax_minor": 105,
    "amount_on_next_invoice_minor": 916,
    "next_recurring_total_minor": 133905,
    "lines": [
      {
        "description": "Unused time on Fleet Telematics — Per vehicle",
        "quantity": "46",
        "total_minor": -7022,
        "calculation_trace": {
          "fraction": "0.075052854938271605",
          "proration_policy": "proration/v1"
        }
      },
      …
    ]
  }
}

Security

Built so the wrong thing can’t happen.

Controls live where they can’t be skipped: in the database, at the token, and at the boundary with your processor.

Security overview

Isolation in the database

Row-level security is forced on every tenant table, and composite keys stop a row from ever pointing at another tenant’s data.

No card numbers, anywhere

Payment methods are processor tokens. Card numbers and security codes never reach Biller.

Bank details in a vault

Account numbers for pre-authorized debit live in a separate encrypted vault. Files that contain them are rebuilt on download, never stored.

Append-only records

Triggers lock finalized invoices, executed contracts and posted journal lines. A correction is always a new record.

A complete audit trail

Every change made through the API or the console records who made it, what changed and the request it came from.

Signed, fenced webhooks

HMAC-SHA256 signatures with timestamps and overlap during secret rotation. Endpoints can’t target private or metadata addresses.

Questions

The short answers.

Something else? Ask us directly.

Does Biller hold or move money?

No. Your card processor and bank move funds and hold payment credentials. Biller owns the commercial terms, the billing math, invoices, the receivables subledger and the orchestration around each payment.

Can we keep our current processor?

Gateways are adapters behind one interface. Biller ships with Moneris for cards, RBC for pre-authorized debit and a sandbox for testing. Subscriptions and invoices don’t change when a gateway does, although processor tokens usually have to be collected again.

What happens when a payment request times out?

The attempt is recorded as unknown and reconciled by asking the gateway about the original reference. It is never retried blindly, and every attempt carries its own idempotency reference, so a resubmission can’t charge twice.

Can an invoice be edited after it’s finalized?

No, by design. Issue a credit note, void it with a reversing entry, or write it off. Each correction posts its own journal entry and audit record.

Is there a test environment?

Every account has test and live environments with separate API keys, data and gateway accounts. The console always shows which one you’re in.

How are Canadian PAD rules handled?

Mandates store the agreement evidence and are checked before every debit: confirmation lead time, pre-notification for variable amounts, and cancellation that blocks future debits at once. Lead times and transaction codes are configurable to match your financial institution.

See your billing on Biller.

Walk through your contracts, invoices and payment rails with us, or start with the API.

Request a demo Sign in to the console

Test and live environments from day one