What is the best usage-based billing platform for a small Node.js SaaS?

Stripe Billing is the simplest choice when payments and subscriptions already run on Stripe. Lago is attractive when open source or self-hosting matters, while Metronome is a stronger fit when prepaid credits, enterprise contracts, and real-time spend controls are required.

When should a company choose Metronome or Orb?

Choose them when pricing includes multidimensional meters, negotiated rate cards, minimum commitments, prepaid credits, amendments, simulations, and finance workflows that exceed a conventional subscription catalog.

Can a billing vendor be the only source of truth for usage?

No. Keep an immutable internal usage ledger and reconciliation process. The vendor should receive a durable, replayable billing projection so invoices can be explained, corrected, and migrated.

Best Usage-Based Billing Platforms for Node.js SaaS Apps in 2026

Usage-based billing turns product telemetry into revenue. That sounds simple until a SaaS must prove why a customer was charged a particular amount.

A Node.js application may bill for API requests, AI tokens, workflow runs, storage, seats, data transferred, successful transactions, or business outcomes. Every billable event must be captured once, mapped to the correct tenant and contract, rated with the correct historical price, assigned to the correct billing period, and reflected in customer-facing usage.

Billing errors are revenue errors. Undercounting leaks margin. Overcounting creates disputes. Late events can alter invoices. Duplicate events can create duplicate charges. Pricing changes can affect thousands of contracts.

This guide compares five commercial options:

Stripe Billing
Metronome
Orb
Lago
Amberflo

Metronome is now part of Stripe, but the products still serve different levels of complexity. Stripe Billing Meters fits conventional usage-based subscriptions. Metronome is positioned for multidimensional pricing, negotiated contracts, credits, and real-time monetization workflows.

Pricing and product details were checked against official sources on July 21, 2026. Quote-only plans, regional terms, and negotiated enterprise pricing must be confirmed before publishing or purchasing.

Quick Comparison

Platform	Pricing Signal	Best Capability	Deployment Model	Best Fit
Stripe Billing	0.7% of Billing volume. Basic meter usage includes up to 100M events monthly. Annual monthly-paid tiers start at $620 for up to $100K monthly Billing volume.	Integrated subscriptions, payments, invoices, dunning, customer portal, and basic usage meters	Managed SaaS	Startups already using Stripe with straightforward per-unit, package, tiered, or hybrid pricing
Metronome	Starter includes $100K Billing volume and 10M events; overages are 0.8% of Billing volume and $0.04 per 1,000 events	Multidimensional metering, credits, enterprise contracts, real-time spend controls, and embedded dashboards	Managed SaaS	AI, infrastructure, developer tools, and SaaS combining self-serve and negotiated contracts
Orb	Custom pricing based mainly on billings and raw events; Advanced and Enterprise may add a platform fee	Historical simulations, backfills, pricing migrations, amendments, invoicing, and finance integrations	Managed SaaS	B2B SaaS with rapidly evolving pricing and complex quote-to-cash workflows
Lago	Community edition free to self-host; Premium Cloud and Premium Self-Hosted use custom packages based on events, invoices, active customers, and features	Open-source metering, billing, credits, entitlements, invoices, and deployment control	Managed cloud or self-hosted	Teams prioritizing open source, data control, and a reversible vendor strategy
Amberflo	Public page displays $99 Startup (up to $10K Billing volume, 10K events) and $599 Growth (up to $100K Billing volume, 500K events); confirm before publishing as Essential and Custom plans are also promoted	AI cost attribution, margin analysis, metering, credits, billing, and usage guards	Managed SaaS	AI and infrastructure products needing customer-level cost, revenue, and margin in one system

Start with a Financial-Grade Usage Architecture

Do not send billable telemetry directly from an HTTP request to a billing vendor and then discard the source data.

Use three layers:

Product activity → immutable internal usage ledger → provider-specific billing projection

A practical internal event contains:

event_id
tenant_id
customer_id
subscription_id
meter_code
quantity
occurred_at
source_system
source_reference
dimensions_json
cost_amount
currency
schema_version
created_at

A separate delivery record tracks provider, provider event ID, status, attempts, acceptance time, and last error. This architecture supports replay, reconciliation, corrections, migration, and invoice explanation. The billing vendor is a calculation and invoicing platform, not the only evidence that usage happened.

Make Event IDs Deterministic

Retries must preserve the same event ID.

import crypto from "node:crypto";

export function usageEventId({
  tenantId,
  meter,
  sourceId,
}: {
  tenantId: string;
  meter: string;
  sourceId: string;
}): string {
  return crypto
    .createHash("sha256")
    .update(`${tenantId}:${meter}:${sourceId}`)
    .digest("hex");
}

A random ID generated during every retry defeats deduplication.

Stripe meter events accept an optional identifier. Lago uses transaction_id. Orb supports idempotency for API mutations, and raw events have unique identifiers. Regardless of vendor behavior, the internal ledger should enforce uniqueness.

Idempotency prevents duplicates. It does not correct an inaccurate quantity. The billing design also needs negative adjustments, replacement events, credit notes, or backfills.

Separate Usage from Pricing

A usage event should describe what happened:

{
  "event_id": "use_01J...",
  "customer_id": "cus_123",
  "meter": "llm_tokens",
  "quantity": 8450,
  "occurred_at": "2026-07-21T12:30:00Z",
  "dimensions": {
    "model": "model-x",
    "region": "us-east",
    "token_type": "output"
  }
}

Pricing belongs in versioned configuration: meters, rate cards, plan versions, customer contracts, credits, discounts, and minimum commitments.

This separation lets finance simulate a new price against historical usage without changing product instrumentation.

Platform Deep Dives

Stripe Billing: Best Integrated Starting Point

Stripe Billing combines subscriptions, invoicing, payment collection, dunning, customer portal, credits, and Meters.

Current public pricing includes:

Pay as you go: 0.7% of Billing volume
Annual monthly-paid plan: $620/month for up to $100,000 monthly Billing volume
Additional volume on that tier: 0.67%
Basic Meters API: up to 100 million events monthly within Billing pricing
Stripe Payments fees remain separate

Stripe Meters supports count, sum, and last-value aggregation. Meter processing is asynchronous, so invoice previews and usage summaries may not immediately show newly submitted events.

Choose Stripe Billing when payments already use Stripe and the product has conventional usage-based pricing. It is less attractive when contracts require extensive multidimensional rates, retroactive changes, complex prepaid-credit hierarchies, or sophisticated enterprise quote-to-cash workflows.

Metronome: Best Advanced Platform with Public Starter Economics

Metronome provides real-time metering, SQL-based metrics, rate cards, prepaid credits, minimum commitments, custom contracts, usage alerts, invoices, and embeddable dashboards.

Its Starter plan currently includes:

$100,000 Billing volume
10 million events
0.8% overage on additional Billing volume
$0.04 per 1,000 events above the allowance

Choose Metronome when self-serve and enterprise contracts coexist, customers need real-time usage and spend visibility, and the company expects credits, commitments, multidimensional pricing, amendments, or cloud-marketplace integration.

Model revenue and event count separately. A low-revenue AI product can generate millions of events before it produces meaningful Billing volume.

Orb: Best for Pricing Evolution and Finance Workflows

Orb is built around raw usage events, query-defined metrics, pricing versions, contracts, simulations, backfills, amendments, invoicing, threshold billing, and finance integrations.

Orb uses custom pricing based primarily on total billings issued through Orb, raw events ingested, and a platform fee for some Advanced and Enterprise arrangements.

Choose Orb when pricing changes frequently, finance needs to simulate plans against historical data, sales negotiates customer-specific contracts, or amendments must take effect immediately, in the future, or retroactively.

Orb supports idempotency keys for POST and PATCH operations for 48 hours. The application should still retain permanent internal command and usage records.

Lago: Best Open-Source and Self-Hosted Option

Lago provides open-source metering and billing with plans, subscriptions, invoices, credits, entitlements, payment integrations, and customer portals.

The Community edition is free to self-host. Premium is available in cloud and self-hosted forms with custom pricing based on company stage and usage dimensions such as events, invoices, active customers, and premium capabilities.

Lago uses transaction_id for usage deduplication. It supports REST, batched REST, Kafka or Redpanda, Kinesis, and S3 ingestion. Current documentation lists a default REST event-ingestion limit of 500 requests per second and batches of up to 100 events.

Choose Lago when open source, deployment control, self-hosting, or long-term portability matter. Self-hosting shifts cost into PostgreSQL or ClickHouse, streaming infrastructure, backups, upgrades, observability, and on-call ownership.

Amberflo: Best for AI Cost, Billing, and Margin Convergence

Amberflo combines metering, pricing, billing, prepaid credits, cost attribution, customer-level margin analysis, budgets, usage guards, and revenue reporting.

Its public pricing page currently displays:

Startup: $99/month, up to $10,000 monthly Billing volume and 10,000 meter events
Growth: $599/month, up to $100,000 monthly Billing volume and 500,000 events
Growth overages: 0.54% of additional Billing volume and $5 per additional 10,000 events

The same page also emphasizes Essential and Custom plans, so confirm the exact current packaging before publishing.

Choose Amberflo when AI tokens, agents, models, GPU workloads, or infrastructure usage drive both cost and revenue. It is differentiated by connecting usage, vendor cost, customer billing, and margin analysis.

A Provider-Neutral Node.js Adapter

Keep domain events independent from vendor IDs:

export interface UsageBillingProvider {
  sendEvents(events: UsageEvent[]): Promise<void>;
  getCurrentUsage(input: {
    customerId: string;
    meter: string;
    start: Date;
    end: Date;
  }): Promise<UsageSummary>;
  previewInvoice(customerId: string): Promise<InvoicePreview>;
}

Store vendor customer IDs, subscription IDs, meter codes, and price IDs in mapping tables. Business code should reference internal meter and price versions.

Close Billing Periods Explicitly

Use a controlled billing-close workflow:

Open
Soft close
Wait for late events
Reconcile internal and vendor usage
Preview invoices
Review exceptions
Finalize invoices
Collect payment
Lock the period

Reconcile internal event counts, provider acceptance, quantity by customer and meter, credits, commitments, invoice lines, corrections, payments, refunds, and tax.

A successfully generated invoice is not automatically a correct invoice.

Define Late-Event and Correction Policy

Answer these questions before launch:

How late may usage arrive?
Can an event replace an earlier event?
Can a negative event correct usage?
What happens after invoice finalization?
Is the correction placed on the next invoice?
Is a credit note required?
Who approves financial adjustments?
Can the customer see the correction history?

Stripe meter summaries update asynchronously. Lago assigns events using their event timestamp, but finalized invoice behavior differs by metric and billing state. Orb and Metronome are differentiated partly by their handling of backfills, amendments, and recalculation.

Total Cost Model

monthly billing-platform cost =
  base platform fee
  + percentage of Billing volume
  + raw event ingestion
  + invoices and active customers
  + premium integrations
  + customer dashboards and alerts
  + data warehouse and CRM synchronization
  + payment processing and tax
  + support, SLA, and compliance
  + engineering and finance operations

A billing platform with a low event fee can be expensive at high revenue. A low percentage fee can be expensive when an AI product emits several events per request. Self-hosting can reduce vendor fees while increasing infrastructure and staffing costs.

Model at least three scenarios:

High event volume with low revenue
High revenue with moderate event volume
Complex enterprise contracts with frequent amendments

Common Implementation Mistakes

Sending events to a vendor without retaining an internal ledger
Generating new IDs during retries
Mixing cost telemetry and billable usage without defined semantics
Hard-coding vendor meter IDs in product logic
Applying today’s price to historical events
Finalizing invoices before reconciliation
Ignoring nonproduction and duplicate events in forecasts
Treating the provider dashboard as the accounting source of truth
Launching without customer usage visibility
Failing to define correction and late-event rules

Decision Guide

Choose Stripe Billing when payments already run on Stripe and the usage model fits ordinary subscription meters.

Choose Metronome when credits, multidimensional pricing, enterprise contracts, real-time dashboards, and spend controls are central.

Choose Orb when pricing migrations, simulations, amendments, and finance integrations drive the project.

Choose Lago when open source, self-hosting, data control, and a reversible vendor architecture matter.

Choose Amberflo when AI or infrastructure cost attribution, billing, credits, and customer margin should share one system.

Production Readiness Checklist

Maintain an immutable internal usage ledger
Generate deterministic event IDs
Separate usage from pricing
Version meters, plans, and rate cards
Deliver events through an outbox or durable stream
Batch provider submissions
Record provider acceptance and failures
Reconcile usage by customer and period
Define late-event rules
Define corrections and credit-note behavior
Preview invoices before finalization
Lock finalized periods
Show current usage to customers
Add spend alerts and budget limits
Keep vendor identifiers outside domain logic
Test pricing migrations on historical data
Model events and Billing volume separately
Include payments, tax, integrations, and support
Test provider outage and replay
Document export and migration procedures

Conclusion

Usage-based billing is revenue infrastructure.

Stripe Billing offers the lowest-friction path for existing Stripe customers. Metronome provides a strong advanced platform with public starter allowances. Orb focuses on pricing evolution and finance workflows. Lago provides open-source deployment control. Amberflo connects AI and infrastructure cost to billing and margin.

The vendor cannot repair an unreliable event model. A production Node.js SaaS still needs deterministic usage events, an immutable ledger, versioned pricing, correction policy, invoice reconciliation, customer visibility, and a migration path.

Measure usage once, preserve the evidence, and make every invoice reproducible.