6 best usage-based billing platforms(Developer Guide)

The best usage-based billing software for developers includes Credyt for real-time AI and API billing with per-usage authorization, Metronome for enterprise streaming aggregation, Orb for invoice-based billing with custom SQL metrics, Lago for open-source self-hosted billing, Stigg for entitlement orchestration over downstream billing systems, and Flexprice for early-stage SaaS adopting hybrid usage pricing through a no-code dashboard. These six platforms diverge on architecture (real-time wallet authorization vs invoice-based metering), customer balance model (first-class wallet primitive vs invoice add-on), pricing iteration interface (SQL vs no-code dashboard), event throughput, deployment model (cloud-only vs self-hostable), and pricing transparency. The right pick depends on which of those trade-offs matters most for the product being billed.

At a glance: ranking

Feature comparison

The two axes that decide most evaluations are whether authorization happens before or after usage, and whether a customer's balance is a first-class primitive or an add-on bolted onto an invoicing engine.

What developers should evaluate when comparing these platforms

The six platforms split on a handful of architectural and operational decisions. Each one shapes a different trade-off, and the right pick depends on which trade-offs match the product.

Real-time authorization vs post-usage metering. Credyt and Stigg check the customer's balance before the API call runs. Metronome, Orb, and Lago accept the event after the action completes and reconcile it into an invoice at cycle end. Flexprice is hybrid: real-time metering pipeline, but wallet debits fire on invoice payment, not on event ingestion. For AI inference, per-token, or per-GPU-hour products where the cost is incurred at the moment of the action, real-time authorization is the only architecture that can prevent a customer from drawing $5,000 of compute against a $100 balance. For products with predictable monthly contracts and small metered overages, invoice-based works.

Wallet as a first-class primitive vs invoice add-on. Credyt, Stigg, and Flexprice expose the customer balance as a wallet object with grants, expiry rules, multi-asset support, and atomic debit. Metronome models this as "commits and credits" tied to the invoice. Orb has "credits-on-invoice." Lago supports up to 5 wallets per customer on premium tiers. Wallet-as-primitive is the right model when 10,000 concurrent requests need to be authorized against the same $100 balance without races. Invoice add-on is enough when balance accuracy at month-end is the bar.

Pricing iteration: SQL vs no-code. Orb has SQL billable metrics and pricing simulation against historical usage. Metronome has SQL metrics and a 34-day event backdating window. Lago, Flexprice, and Stigg configure pricing through dashboards. Credyt models pricing as wallet grants and consumption rules. Engineering-owned pricing favors SQL; PM-owned pricing favors dashboards.

Event throughput. Metronome runs streaming aggregation at billions of events monthly. Orb's hosted rollups target millions of events per second. Lago and Flexprice run on event-stream backends (Kafka, ClickHouse). Credyt and Stigg are not benchmarked at the billion-event tier but are not the bottleneck at typical SaaS scale. AI infrastructure billing makes throughput a hard requirement; B2B SaaS at thousands of events per minute does not.

Open source and deployment model. Lago and Flexprice ship AGPLv3 cores that can be self-hosted in VPC or on-prem. Credyt, Metronome, Orb, and Stigg are cloud-only. Self-hosting matters for compliance, data residency, or license auditability, and moves Postgres, Redis, and upgrade work onto the developer team.

Customer portal. Credyt and Flexprice ship a drop-in branded portal. Stigg ships embeddable React, JavaScript, and Vue widgets. Orb has a pre-authenticated portal without self-service top-up. Lago's portal is premium-tier only. Metronome is signed-URL embeds, build-your-own. If end customers need to view balance, top up, or download invoices without billing-UI engineering work, Credyt and Flexprice are the only drop-in options.

Pricing transparency. Credyt ($1 per Monthly Active Wallet), Flexprice ($500 / $1,000 per month), and Stigg ($448/mo Growth floor) publish rates. Metronome, Orb, and Lago cloud tiers are sales-led. Budgeting without a sales call narrows the field to three.

Tool by tool

1. Credyt

Credyt is real-time, end-to-end billing infrastructure built for AI and API products where infrastructure costs hit before the invoice cycle runs. It provides Wallet APIs the platform queries before allowing an action, a multi-asset balance primitive (USD, tokens, GPU hours, custom units), and a drop-in branded billing portal with self-service top-up.

Best for: Real-time billing for AI and API products with variable, per-request infrastructure costs.

Pricing: $1 per Monthly Active Wallet (MAW), with the first 10 wallets free and the first 1M events per month free. No revenue percentage. No seat fees. At 100 active customers: $90/month plus pass-through PSP fees.

Strengths:

• Per-usage authorization. Before performing any action, the platform checks the wallet balance. If the balance is sufficient, it proceeds with the action and the wallet is debited atomically.
• Native multi-asset wallets. A single customer wallet can hold USD, tokens, GPU hours, and any custom unit in parallel.
• Drop-in customer portal. Branded, self-service top-up included; no frontend engineering required.
• Event-level cost attribution. Profitability is tracked per customer, per feature, per workload, not just at aggregate revenue level.
• Public, transparent pricing. No sales call to see the rate.

Trade-offs:

• Smaller partner ecosystem than incumbent platforms.
• Cloud-only deployment. No self-hosting option.
• No first-class enterprise contract management. Multi-year negotiated commitments with backdating and true-ups are not supported natively.
• Requires customers to prepay into a balance, which is not a fit for post-pay enterprise billing.

Learn more: Credyt's real-time billing infrastructure.

2. Metronome

Metronome is invoice-based usage-based billing for AI infrastructure and high-throughput SaaS. It processes billions of events per month for OpenAI, Anthropic, Databricks, NVIDIA, and Confluent, with a SQL-based rating engine and first-class enterprise contract management. Stripe acquired Metronome on January 14, 2026.

Best for: High-volume enterprise streaming aggregation with multi-product contracts and complex pricing.

Pricing: Not publicly available. Enterprise sales conversation required.

Strengths:

• Streaming aggregation architecture. Billions of events monthly; peak processing of 10,000 invoices per second on the Confluent pipeline (Confluent case study).
• SQL billable metrics. Custom aggregation logic authored in a SQL editor without bespoke engineering.
• Enterprise contracts. Multi-year deals, commitments, amendments, true-ups, and 34-day event backdating.
• Post-acquisition Stripe ecosystem access. Payments, tax, and revenue recognition through the parent platform.

Trade-offs:

• Post-usage invoicing only. Usage accumulates and is billed at cycle end. There is no real-time wallet debit reserving funds before consumption.
• SQL and engineering dependency. Setting up events and billable metrics requires developer resources.
• 34-day backdating window limits retroactive corrections.
• Customer portal is build-your-own. Signed-URL embeds, not a drop-in portal.
• Post-acquisition roadmap items (real-time spend alerts, hierarchical accounts, seat-based credits) were acknowledged as in progress at acquisition close.

Learn more: Metronome on AI Billing.

3. Orb

Orb is invoice-based usage-based billing for engineering-led teams that treat pricing as a core product function. The platform is built around custom SQL metrics, pricing simulation against historical data, and dimensional pricing. Named customers include Vercel, Replit, Supabase, Redis, Neo4j, and LaunchDarkly.

Best for: Invoice-based usage billing with custom SQL metrics, pricing simulation, and dimensional pricing.

Pricing: Not publicly available; sales-led. Third-party analysis cited a previously public rate of approximately $720/month at 100-customer scale before Orb removed public pricing; current rates may differ.

Strengths:

• Custom SQL billable metrics for unusual aggregation logic.
• Pricing simulation. Test pricing changes against historical usage before deployment.
• High-throughput hosted rollups. Designed for millions of events per second.
• Dimensional pricing across region, model, tier, and customer segment.
• Deep finance integrations with NetSuite and Salesforce.
• Agentic Payment Methods, launched in 2026, support AI-agent-driven payment flows.

Trade-offs:

• Post-usage invoicing only. Threshold invoicing can fire mid-cycle but is still post-consumption.
• No customer self-service top-up in the hosted portal.
• Auto top-up is platform-configured, not customer-controlled.
• Pricing is enterprise-level and not public.
• Implementation requires dedicated billing engineering.

Learn more: Orb on AI Billing.

4. Lago

Lago is an open-source billing platform under AGPLv3 with managed cloud, white-label embedded, and AI-agent options on commercial tiers. The core ships subscriptions, usage-based metering, prepaid credits, coupons, and entitlements. Named customers include Mistral AI, Groq, PayPal, Synthesia, and Arcee AI.

Best for: Open-source AGPLv3 billing for engineering-led teams with code transparency or compliance and data residency needs.

Pricing: AGPLv3 core is free to self-host. Cloud tiers (Business, Enterprise) require sales contact as of April 2026. Public discussion during Lago's April 2024 Series A on Hacker News cited a $3,000/month starting cloud tier; current pricing is not published.

Strengths:

• AGPLv3 core. Auditable, forkable, self-hostable. 9,500-plus GitHub stars; 183 releases shipped.
• Flexible deployment. Cloud, self-hosted Docker Compose, on-premise, or VPC.
• SOC 2 Type II certified.
• Up to 5 wallets per customer with priority ordering.
• Native integrations: Stripe, Adyen, GoCardless, NetSuite, Salesforce, HubSpot, Xero.
• Lago AI agents (February 2026) and Lago Embedded white-label (March 2026).

Trade-offs:

• Invoice-based architecture. The authoritative wallet balance moves at invoice finalization, not on event ingestion.
• The "real-time burndown" feature maps to a 5-minute-refresh ongoing-balance estimate, premium-only.
• The AGPLv3 core does not include the customer portal, credit notes and refunds, automatic dunning, tax integrations, or CRM and accounting connectors. Production billing typically means paying for the cloud tier or building those pieces.
• Self-hosting adds infrastructure cost (Postgres, Redis, 5+ services) and ongoing engineering for upgrades.

Learn more: Lago on AI Billing.

5. Stigg

Stigg is a monetization control layer that orchestrates entitlements, pricing, and credits across a downstream billing system (Stripe, Zuora, Chargebee). The product gates feature access in real time through a typed entitlement API; payment collection still runs through the connected billing system at cycle end. Named customers include Webflow, Miro, Cloudinary, AI21, New Relic, PagerDuty, Upwork, and Airbyte.

Best for: Real-time entitlements and credit orchestration on top of Stripe, Zuora, or Chargebee.

Pricing: Sandbox is free. Growth starts at $448/month billed annually with a contract minimum. Scale is enterprise custom.

Strengths:

• Typed entitlement API with documented P95 latency under 100ms.
• Unified Boolean, Numeric, and Metered feature primitive in one model.
• Credits Suite with stacked grants, priority ordering, expiry dates, prepaid pools, and an append-only ledger.
• No-code pricing console. Non-engineers configure plans and entitlements without engineering tickets.
• Embeddable React, JavaScript, and Vue widgets for pricing tables, checkout flows, and customer portals.
• Billing-system agnostic. Connects to Stripe, Zuora, Chargebee, AWS Marketplace, and the Apple App Store.

Trade-offs:

• Stigg does not handle the billing transaction itself. Payment collection runs through the connected billing system.
• No hosted redirect-style billing portal. Embed-only via widgets.
• No profitability analytics. Usage and revenue reporting only; no cost ingestion for margin analysis.
• $448/month Growth floor. Per-unit costs below the floor are paid at the floor.
• Sandbox is non-production only.

Learn more: Stigg on AI Billing.

6. Flexprice

Flexprice is an open-source hybrid billing platform with a no-code dashboard, designed for early-stage SaaS adopting usage pricing for the first time. Real-time event metering runs on a ClickHouse-backed pipeline. Customer Simplismart reports 6x faster pricing iteration; Segwise migrated billing in approximately two weeks.

Best for: Early-stage SaaS adopting hybrid usage-and-credit pricing through a no-code dashboard.

Pricing: Free tier (100K events per month, 3-month validity). Starter $500/month ($400 billed annually). Premium $1,000/month ($800 billed annually). Enterprise custom.

Strengths:

• AGPLv3 open-source core. 3,600-plus GitHub stars; 4,633 commits.
• No-code pricing dashboard. Non-engineers manage pricing without code deployments.
• ClickHouse-backed real-time event metering.
• Wallet system with auto top-up, low-balance alerts, and promotional credit grants.
• PSP integrations: Stripe, Razorpay, Paddle, Chargebee.
• Cloud or self-hosted deployment.
• Public, transparent tier pricing.

Trade-offs:

• Usage-based wallet debit is invoice-driven, not event-driven. Charges accumulate and debit on INVOICE_PAYMENT, not at event ingestion. Manual debit via API is synchronous, but automatic usage debit is not real-time.
• Customer portal is read-only. End customers can view balances and invoices but cannot initiate payments or self-service top-ups.
• Auto top-up is merchant-controlled. Customers cannot set their own thresholds.
• Advanced features (real-time prepaid balance, recurring wallet top-ups, entitlement management) require paid tiers.
• PSP support is limited to four providers.

Learn more: Flexprice on AI Billing.

How to choose

If you bill per AI inference, per API request, or per token and need to authorize spending before the cost is incurred: Credyt fits. Per-usage authorization is the architectural primitive that invoice-based platforms cannot provide; Stigg can authorize entitlements but does not handle the billing transaction itself.

If you negotiate enterprise contracts with multi-product, multi-year commitments and process billions of events monthly: Metronome fits. Streaming aggregation and contract management are first-class. The post-Stripe roadmap is still in progress as of April 2026, which matters if seat-based credits or hierarchical accounts are on the requirement list.

If you need to simulate pricing changes against historical usage before deploying, with dimensional pricing across regions or models: Orb fits. Pricing simulation is the differentiating capability and the reason developer-led teams at Vercel and Replit picked it.

If your team needs code transparency, on-premise or VPC deployment, or open-source license control for compliance reasons: Lago fits. Budget for either a cloud sales contact or premium-tier engineering build, since the AGPLv3 core does not include the customer portal, dunning, or tax integrations.

If you want to keep Stripe, Zuora, or Chargebee for billing but centralize entitlements and credits in one no-code control layer: Stigg fits. The architecture sits above the billing system rather than replacing it, which is useful for teams that have already standardized on a downstream provider.

If you are an early-stage SaaS team adopting usage pricing for the first time and want transparent published tier pricing with a no-code dashboard: Flexprice fits. The wallet debit is invoice-driven rather than event-driven, so for products that need real-time balance enforcement, this is the wrong choice.

Bottom line: which usage-based billing platform fits your product

The six usage-based billing software platforms reviewed here cover three architectures: real-time end-to-end billing (Credyt), invoice-based usage-based billing (Metronome, Orb, Lago), real-time orchestration over downstream billing (Stigg), and hybrid (Flexprice). Which architecture fits depends on the cost structure of the product being billed.

AI inference, API requests, and per-compute pricing favor real-time architectures because the cost is incurred before the invoice cycle runs. Enterprise contracts with quarterly invoicing and high-volume event aggregation favor invoice-based architectures. For developer teams comparing transparent published rates against sales-led tiers, Credyt's transparent per-wallet pricing and Flexprice's published $500 / $1,000 monthly tiers are the two of the six that publish a number without a sales call.

Compare pricing across all six platforms

Public rates, sales-led tiers, free thresholds, and per-event overage costs for every platform in this list are mapped side by side at aibilling.dev/pricing.

FAQ

What's the difference between real-time and invoice-based usage-based billing?

Real-time billing authorizes and debits the customer's balance as usage happens, in one atomic operation. Invoice-based billing meters usage events through a separate metering layer and reconciles them into an invoice at cycle end. Real-time fits products with infrastructure costs that hit before the invoice runs (AI inference, GPU workloads, API requests). Invoice-based fits enterprise contracts with quarterly invoicing and high-volume aggregation. Neither is universally better; they solve different problems.

Which of these six platforms work for AI products specifically?

Credyt is designed for AI and API billing where per-inference or per-token cost hits in real time, with multi-asset wallets (USD, tokens, GPU hours, custom units) and per-usage authorization. Metronome runs production billing for OpenAI, Anthropic, Databricks, and NVIDIA with streaming aggregation at AI infrastructure scale. Orb powers Vercel, Replit, Supabase, and Redis with SQL metrics and dimensional pricing. Lago is used by Mistral AI, Groq, and Arcee AI on self-hosted or cloud tiers. Stigg powers AI21's entitlements. Flexprice targets early-stage AI SaaS with a no-code dashboard. AI fit is not the differentiator; the differentiator is whether billing must enforce balances in real time (Credyt) or aggregate them for end-of-cycle invoicing (Metronome, Orb, Lago).

Are the open-source options truly free?

The AGPLv3 cores of Lago and Flexprice are free to self-host. The cost to reach production-readiness is not zero. Lago's AGPLv3 core does not include the customer portal, credit notes and refunds, dunning, tax integrations, CRM connectors, or AI agents; all are premium features. Flexprice's open-source tier excludes entitlement management and recurring wallet top-ups, which sit behind the paid tiers. Add infrastructure (Postgres, Redis, Docker), upgrades (Lago has shipped 183 releases), and engineering time for webhook wiring and PSP integration. Open-source is "free as in AGPLv3 core," not "free as in everything you need to run a billing system in production."

When does an entitlement orchestration layer like Stigg fit better than an end-to-end billing platform?

Stigg fits when the team has already standardized on Zuora, Chargebee, or another billing system and does not want to migrate, but needs a typed entitlement API, a unified plan model, and credits with stacked grants, priority ordering, and expiry dates. Stigg gates feature access in real time; payment collection still runs through the connected billing system. Picking Stigg over Credyt, Metronome, Orb, Lago, or Flexprice trades end-to-end billing ownership for a control layer that fits cleanly on top of existing infrastructure.

How should a team choose between real-time, invoice-based, and hybrid architectures?

Real-time (Credyt, Stigg) fits products where per-action cost is incurred at the moment of the action and the balance must enforce spending before the action runs. AI inference, GPU compute, per-token pricing, and concurrent API calls are the canonical cases. Invoice-based (Metronome, Orb, Lago) fits enterprise contracts with negotiated terms, quarterly invoicing, and high-volume event aggregation where end-of-cycle reconciliation is acceptable. Hybrid (Flexprice) fits teams that want event-level metering but bill on a traditional invoice cadence. Concurrent request flows where atomic balance authorization is required to prevent credit depletion races force real-time. Predictable monthly contracts with small metered overages do not.