DEV Community: Credyt.ai

How to track LLM costs per customer in production

Credyt.ai — Tue, 02 Jun 2026 10:35:26 +0000

Tracking LLM costs per customer means attributing every model-provider charge to a specific user inside a multi-tenant product. Aggregate dashboards hide which customers are unprofitable; per-customer attribution surfaces it. This article covers instrumentation patterns, the attribution choices that scale, and what to do with the data.

Why tracking LLM costs per customer matters

Most teams cannot do this. According to CloudZero's 2025 State of AI Costs report, only 43% of organizations can attribute AI cost to a customer, and only 22% can attribute it to a transaction (CloudZero, May 2025). The FinOps Foundation's State of FinOps 2026 puts AI in the scope of FinOps practice at 98% of organizations, up from 31% in 2024, so the recognition is there. The instrumentation is not.

The cost is structural. At scaling-stage AI B2B companies, model inference runs at roughly 23% of revenue and does not decline meaningfully with scale (ICONIQ AI B2B Operating Index, January 2026). A 23%-of-revenue cost center that the team cannot break down per customer is the operating equivalent of running a SaaS business without knowing which seats are paid.

The tail is what kills the average. A user who is profitable at the median can flip to break-even at the 75th percentile and to a monthly loss at the 90th as query volume compounds (Todd Gagne, Wildfire Labs, March 2026). Replit reported a production case in February 2026 where gross margin swung from 36% to -14% after its agent consumed more LLM than the pricing covered. Aggregate dashboards do not show this. A per-customer ledger does.

What attribution gives you: pricing decisions you can hold up at a board meeting, and a margin number that drives the next deprovisioning or repricing call.

What "per customer" actually means in a multi-tenant AI product

In a multi-tenant AI product, per-customer LLM cost attribution should track three IDs at once: organization, end-user, and session or agent task. Picking only one at instrumentation time means rebuilding the pipeline the first time the pricing model changes.

Organization. For B2B products where each account is the cost-bearing entity. "Customer X cost $4,200 this month" is the question the CFO is asking.
End-user. For B2C products and for B2B products with seat-level visibility. Per-seat cost exposes credential sharing and free-tier abuse.
Session or agent task. For products where one customer can spawn many concurrent agents. "Per task" is sometimes the right unit because a single customer's monthly cost can vary by 100x depending on which workflows ran.

In practice, the data model propagates all three IDs through every model-provider call. Aggregations follow later. The same three IDs feed multi-tenant LLM billing decisions as soon as the team starts charging by usage.

The Cursor pricing incident illustrates what happens when attribution is missing at the product layer. In June 2025, Cursor replaced request caps with a credit pool priced at frontier-model API rates. Users exhausted credits in days with no real-time visibility, refunds followed, and TechCrunch traced the root cause to the absorbed cost of longer-horizon agent tasks under the old flat plan.

Attribution is not a back-office concern. Without it, the product cannot warn the user, and the team cannot price the next iteration.

The four attribution patterns

There are four common patterns for binding a model-provider charge to a customer. None of them is universally correct.

Provider-side metadata. Both major providers expose per-user tagging. OpenAI accepts a user parameter on the Chat Completions and Responses APIs, and the OpenAI Usage API (launched December 2024) supports group_by=user_id for programmatic per-user cost breakdown. The Costs endpoint requires an admin key. Anthropic accepts metadata.user_id on every API request, capped at 256 characters and explicitly not for PII. The trade-off: provider metadata is the lowest friction, but it is provider-tied and does not show real-time per-customer running totals inside the application. (Side note: the request-to-Usage-API binding for OpenAI's user parameter should be re-verified against the live API reference before treating it as definitive.)

Client-side instrumentation. Wrap the provider SDK to emit a typed cost event with customer_id, model, input/output/cached token counts, and a per-call cost computed from a local pricing table. Portable across providers. Owns the customer_id propagation problem head-on, which is the part of the work that is going to bite no matter which pattern is picked.

Gateway or proxy attribution. A reverse proxy in front of the model-provider API records the request, computes the cost, and exposes per-customer breakdowns. Open-source options include Helicone, LiteLLM, Langfuse, and OpenLLMetry. Hosted equivalents serve as the AI cost observability layer for teams that want centralized visibility: LangSmith, Datadog LLM Observability, Arize Phoenix. Adds a network hop. Centralizes instrumentation across a fleet of services.

Computed attribution from raw logs. Capture the full request and response, compute attribution after the fact in a nightly job. The "figure it out later" path. Common, lossy on cached input and streaming, hard to reconcile when prices change mid-period.

A defensible production setup usually combines two of these: provider metadata as cheap insurance, and one of the active patterns (client-side or gateway) as the source of truth.

What you are actually attributing: the cost-line items

A per-completion charge is not one number. Treating it as one is how attribution drift starts.

The line items the model has to handle:

Input tokens × input rate. Claude Opus 4.x: $5 per 1M input tokens, $25 per 1M output (Anthropic pricing, May 2026). Sonnet 4.5/4.6: $3 input, $15 output (Anthropic pricing, May 2026).
Output tokens × output rate. Same idea, separate rate, often 5x the input rate.
Cached input tokens with their own rate. OpenAI applies a 50% discount on cached input for prompts of at least 1,024 tokens, automatically and without code changes. Cache TTL is 5 to 10 minutes idle, up to 1 hour (OpenAI prompt caching announcement, October 2024). Anthropic charges 0.1x base input on cache reads (a 90% discount) and 1.25x base input on a 5-minute cache write, or 2x base input on a 1-hour cache write (Anthropic pricing, May 2026). The attribution gotcha: a system prompt cached at the organization level and reused across customers concentrates the write cost on one cost center while the read savings spread across many. A uniform attribution model misallocates this.
Tool or function call tokens. Anthropic's tool use adds 497 to 675 system tokens depending on the tool_choice setting (Anthropic pricing, May 2026). Tools are not free, and the cost belongs to whichever customer triggered the call.
Embeddings. Separate endpoint, separate pricing. Often pre-computed once and reused across customers, which makes the per-customer model different.
Batch API. Anthropic's Batch API gives 50% off both input and output tokens, with results returning within 24 hours (Anthropic pricing, May 2026). OpenAI has an equivalent. The discount is large. The timing is what creates the problem: the cost lands on a different day than the customer interaction.
Streaming responses. Tokens emit incrementally. Bind on the response id, not on connection close, or the count is lost when the connection drops.

The edge cases nobody mentions

Every production AI product hits the same five attribution edge cases: async batch APIs, background workflows, retries, multi-step agent chains, and provider failures. The naive attribution model fails on each.

Async and batch APIs. The cost shows up on a different day than the customer interaction that triggered it. A daily ledger keyed on event time will record the wrong day; a ledger keyed on request creation time will record the right one.
Background workflows with no clear customer. Periodic re-indexing, internal evals, cached system prompts. Route them to an internal customer_id so they do not contaminate per-customer numbers.
Retries. The provider charges twice but the customer interaction is one. Attribute once at the boundary; log the retry separately so reconciliation against the provider invoice still ties out.
Multi-step agent chains. An agent serving Customer A loads a context object shared with Customer B. Whose cost is it? Pick one rule and document it: attribution at the request boundary, with a separate log of cross-customer dependencies.
Provider failures. The customer's request failed; the provider still charged. Attribute the cost, write it off, or socialize it. Pick a rule. The downstream margin number depends on which.

A reference implementation

A solid production setup for tracking LLM costs per customer combines provider metadata for cheap insurance, a client-side wrapper as the source of truth, and nightly reconciliation against the provider invoice. The table below compares the four attribution patterns on setup cost, accuracy, and multi-provider correctness. The scoring is the author's synthesis of deployed patterns, not a benchmarked study.

Pattern	Setup cost	Attribution accuracy	Multi-provider	Multi-tenant correctness	Per-request overhead
Provider metadata	Lowest	Provider-dependent	No (one per provider)	Limited (not real-time inside the app)	None
Client-side wrap	Medium	High	Yes	High when customer_id is required at the call boundary	Negligible
Gateway or proxy	Higher	High	Yes (one integration point)	High	Adds a network hop
Computed from logs	Lowest at write, highest at read	Lossy on cached, batch, streaming	Yes	Depends on log fidelity	None at write

A minimal TypeScript wrapper around the OpenAI SDK is a single function. It takes customerId, calls the provider with the user parameter set, and parses response.usage for prompt_tokens, completion_tokens, and prompt_tokens_details.cached_tokens. It multiplies each count against a local pricing constant and emits a typed LLMCostEvent with the customer ID, model, line items, and total. The pricing constant is a separate file with one entry per model and per line item. When a provider raises prices or adds a cached-input rate, that file is the only change.

Nightly reconciliation catches the cost-line items that drift: retries, cache writes, and unmodeled tool tokens are the usual culprits. A delta of more than a few percent against the provider invoice is a signal that the pricing table or the instrumentation lost a line item, not that the provider is wrong.

Teams that would rather not own the attribution stack at all can offload it to a usage-based billing platform that handles real-time wallet attribution natively. The broader usage-based billing platforms directory on aibilling.dev compares the options side by side.

What to do once you can track LLM costs per customer

Per-customer cost data is only useful if it changes a decision. Three decisions it should drive.

Build the per-customer margin number. Revenue per customer minus inference cost per customer minus everything else, computed monthly. A margin number is what turns "we should switch this customer to Sonnet" into a real conversation rather than a hunch.

Alert on the top 5% by cost. Not by usage. By absolute model spend. Ridgeway's CFO advisory framing is direct: "The 90th percentile view is critical. Most margin blowups come from heavy users." The top 5% is where the next pricing failure is already happening.

Use the data for pricing decisions. Intercom Fin charges $0.99 per AI resolution, and a single customer's monthly bill ranges from $50 to $30,000 depending on the bot resolution rate (Intercom Fin pricing, February 2026). That range is not a hypothetical. It is the documented operating spread for a live product at scale. A team that cannot see where its own customers sit in that distribution cannot pick the next pricing iteration confidently.

When a customer crosses the line: raise the price, switch the model, set a cap, or deprovision. The data is what makes any of these a considered move rather than a panic move.

Want this done for you?

If the data model, edge cases, and reconciliation pipeline above sound like work you would rather not own, that is what Credyt does.

Credyt is real-time billing infrastructure for AI products. It handles per-customer cost attribution, real-time wallet authorization, and a customer-facing billing portal, so the team can skip the months of engineering this article describes.

6 best usage-based billing platforms(Developer Guide)

Credyt.ai — Tue, 12 May 2026 00:35:09 +0000

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

Rank	Tool	Best for
1	Credyt	Real-time billing for AI and API products with variable, per-request infrastructure costs
2	Metronome	High-volume enterprise streaming aggregation with multi-product contracts and complex pricing
3	Orb	Invoice-based usage billing with custom SQL metrics, pricing simulation, and dimensional pricing
4	Lago	Open-source AGPLv3 billing for engineering-led teams with code transparency or compliance needs
5	Stigg	Real-time entitlements and credit orchestration on top of Stripe, Zuora, or Chargebee
6	Flexprice	Early-stage SaaS adopting hybrid usage-and-credit pricing through a no-code dashboard

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.

Feature	Credyt	Metronome	Orb	Lago	Stigg	Flexprice
Architecture	Real-time, end-to-end	Invoice-based	Invoice-based	Invoice-based	Real-time orchestration over downstream billing	Hybrid (invoice-based primary)
Usage authorization	Per-usage	Post-usage	Post-usage	Post-usage	Per-usage entitlement; billing post-usage downstream	Post-usage
Customer balance	First-class wallet primitive	Add-on (commits and credits)	Add-on (credits-on-invoice)	Add-on (up to 5 wallets)	First-class wallet primitive	First-class wallet primitive
Multi-asset support	Native (USD, tokens, GPU hours, custom)	USD-with-labels	USD-with-labels	USD-with-labels	USD-with-labels	USD-with-labels
Open source	No	No	No	Yes (AGPLv3 core)	No	Yes (AGPLv3 core)
Customer portal	Drop-in, branded, self-service top-up	Build-your-own (signed-URL embeds)	Pre-authenticated, no self-service top-up	Premium-tier, pre-authenticated	Embeddable React, JavaScript, and Vue widgets	Drop-in, read-only
Auto top-up	Customer-controlled	Platform-configured	Platform-configured	Platform-configured	Platform-configured	Platform-configured
Pricing transparency	Public ($1 per Monthly Active Wallet)	Sales-led, not public	Sales-led, not public	Sales-led on cloud tiers	Public ($448/mo Growth floor)	Public ($500 / $1,000 per month)

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.

5 best usage-based billing platforms for vibe coders

Credyt.ai — Tue, 05 May 2026 17:21:06 +0000

The best usage-based billing platforms for vibe coders include Credyt for real-time AI billing with prompt-based setup inside Cursor, Lovable, Bolt, and Claude Code, Stripe Billing for subscription-first SaaS with metered overages, Lago for open-source self-hosted billing, Flexprice for early-stage AI teams that want a no-code pricing dashboard, and Stigg for entitlement and credit orchestration over an existing Stripe account. These five tools split on one architectural axis: whether usage is authorized and billed as it happens, or captured and invoiced at cycle end. Stripe Billing is the default first try for most vibe coders, but it is subscription-first and bills after the action, which is why teams running per-token, per-request, or prepaid-credit AI pricing look elsewhere.

At a glance: ranking

Rank	Tool	Best for
1	Credyt	Real-time AI billing for solo builders shipping inside Cursor, Lovable, Bolt, or Claude Code
2	Stripe Billing	Subscription-first SaaS with metered overages and global payment coverage
3	Lago	Open-source AGPLv3 billing for engineering-led teams that want to self-host or audit code
4	Flexprice	Early-stage AI teams adopting hybrid usage-and-credit pricing through a no-code dashboard
5	Stigg	Real-time entitlements and credit orchestration on top of Stripe, Zuora, or Chargebee

Feature comparison

Feature	Credyt	Stripe Billing	Lago	Flexprice	Stigg
Architecture	Real-time, end-to-end	Subscription-first (invoice-based)	Invoice-based	Hybrid (invoice-based primary)	Real-time orchestration over downstream billing
Usage authorization	Pre-usage authorization	Post-usage	Post-usage	Post-usage	Pre-usage entitlement; billing post-usage downstream
Setup path for vibe coders	MCP server + AI coding tool prompt	Manual API integration (Subscription Items + Meter Events API)	Manual API integration; self-hosting on Docker Compose	Dashboard + API integration	Manual API + downstream billing system already in place
Wallet architecture	First-class primitive	Add-on (credit grants on invoice)	Add-on (up to 5 wallets per customer)	First-class primitive	First-class (orchestration)
Multi-asset support	Native (USD, tokens, GPU hours, custom)	USD only	USD-with-labels	USD-with-labels	USD-with-labels
Open source	No	No	Yes (AGPLv3 core)	Yes (AGPLv3 core)	No
Customer portal	Drop-in, branded, customer-controlled top-up	Hosted, invoice-centric (no top-up)	Premium-tier, pre-authenticated	Drop-in, read-only	Embeddable React/JS/Vue widgets
Auto top-up	Customer-controlled or platform-triggered	Not available	Platform-configured	Merchant-configured	Platform-configured
Pricing transparency	Public ($1/MAW, 10 free)	Public (0.5%-0.8% on Billing + Stripe processing)	Sales-led on cloud tiers	Public ($500 / $1,000/mo)	Public ($448/mo Growth floor)

Why look for an alternative to Stripe Billing for usage-based billing

Stripe Billing is the default first try for most vibe coders, and the reasons are real. The product crossed $500M in annual run-rate revenue in early 2025 (Fortune, February 2025). It sits on top of Stripe Payments with mature SDKs, 135+ currencies, 50+ payment methods, automatic tax handling, and a hosted Customer Portal that finance teams already understand. If you are building a subscription-first SaaS with predictable monthly fees and a small metered overage component, Stripe Billing is the lowest-friction path to revenue.

The friction shows up when AI products get specific. Stripe Billing's architecture is built around the recurring invoice cycle. Per-request, per-token, or per-inference pricing requires real-time event ingestion, dimensional pricing, and the ability to authorize spend before the cost is incurred. None of those are native to Stripe Billing. The Meter Events API is post-usage; it records what already happened.

Setup time is the other constraint. Warp and MiniMax shipped metered billing using Stripe APIs in two to three weeks (Metronome AI Pricing in Practice 2025 Field Report). Stripe's own billing lead acknowledged users reporting up to six months for small billing changes on legacy stacks (Fortune, February 2025). For a vibe coder who shipped the product itself in a weekend and needs to iterate pricing weekly, those timelines are disqualifying.

The market splits into three architectures. Real-time end-to-end billing collapses authorization, pricing, and balance debit into one atomic operation (Credyt). Real-time orchestration handles entitlements and credits in real time but settles billing through a downstream system at cycle end (Stigg). Invoice-based billing meters usage events through a dedicated metering layer and reconciles them into an invoice at cycle end (Lago, Flexprice's primary path). Each architecture is current and valid; the right pick depends on the cost structure of the product being billed.

The 5 platforms compared

1. Credyt

Real-time, end-to-end billing infrastructure built for AI products with prompt-based setup inside AI coding tools.

Best for: Real-time AI billing for solo builders shipping inside Cursor, Lovable, Bolt, or Claude Code.

Pricing: $1 per Monthly Active Wallet. The first 10 wallets are free every month. The first 1M events per month are free. No revenue percentage. No seat fees. At 100 active customers: $90/month + pass-through PSP fees.

Strengths:

MCP server (mcp.credyt.ai) connects natively to Cursor, Windsurf, Claude Code, Codex, Lovable, Bolt, Replit, and V0. Builders add billing through a prompt conversation inside the tool they already use, with no backend code or webhook configuration required.
Per-usage authorization via the Wallet API. The platform queries the customer's balance before the action runs and decides whether to allow, throttle, or block based on the team's policy. Credyt provides the real-time balance state; the usage decision belongs to the platform.
Native multi-asset wallets. A single wallet can hold USD, tokens, GPU hours, and custom units in parallel.
Drop-in branded billing portal with self-service top-up and customer-configurable auto-recharge thresholds (saved card required).
Transparent public pricing. No sales call to start.

Trade-offs:

Newer platform with a smaller partner ecosystem than Stripe.
Cloud-only deployment; no self-hosting option.
Enterprise contract management (multi-year commitments, backdating, true-ups) is not first-class.
Requires customers to prepay into a balance. Not a fit for post-pay enterprise billing where customers expect a quarterly invoice.

Learn more: Credyt's MCP server and prompt-based setup.

2. Stripe Billing

Subscription-first billing on top of Stripe Payments, with metered usage support added through Subscription Items and the Meter Events API.

Best for: Subscription-first SaaS with metered overages and global payment coverage.

Pricing: 0.5% (Starter) or 0.8% (Scale) on recurring payments, plus Stripe Payments at 2.9% + $0.30 per US card transaction. Custom enterprise pricing available (Stripe Billing pricing, accessed April 2026).

Strengths:

Default payments infrastructure, with mature SDKs, extensive docs, and third-party tutorials covering most edge cases.
135+ currencies, 50+ payment methods, and global tax handling.
Hosted Customer Portal for subscription management.
ASC 606 revenue recognition, NetSuite and Salesforce integrations.
Smart Retries for failed-card recovery, with documented ~9% revenue lift.
Metronome acquired January 14, 2026; the post-acquisition roadmap signals deeper metering and contract primitives, with GA dates not yet public (Stripe newsroom, January 2026).

Trade-offs:

Subscription-first architecture. Usage billing accumulates and resolves at invoice cycle end. No real-time wallet debit.
Customer Portal is invoice-centric. No real-time prepaid balance, no self-service top-up.
No native multi-asset wallet primitive. Tokens and GPU hours have to be modeled as monetary credits.
Tied to Stripe Payments. Replacing or mixing PSPs means rebuilding billing.
Setting up usage-based billing requires combining Subscription Items, the Meter Events API, and custom application logic. Realistic time-to-ship is weeks, not hours.

3. Lago

Open-source invoice-based billing platform under AGPLv3, with managed cloud, AI agents, and a white-label embedded option on commercial tiers.

Best for: Open-source AGPLv3 billing for engineering-led teams with code transparency or self-hosting needs.

Pricing: AGPLv3 core is free to self-host. Cloud tiers (Business, Enterprise) are sales-led as of April 2026. Public discussion in April 2024, around Lago's $22M Series A (TechCrunch, March 2024), cited a $3,000/month starting cloud tier; current pricing is not published.

Strengths:

AGPLv3 core. Auditable, forkable, self-hostable on Docker Compose.
Active development. 9,500+ GitHub stars and 183 releases shipped through April 2026.
Native PSP integrations for Stripe, Adyen, and GoCardless.
Up to 5 active wallets per customer with priority ordering.
SOC 2 Type II certified.
Lago AI agents (February 2026) and Lago Embedded white-label (March 2026).

Trade-offs:

Invoice-based architecture. The authoritative wallet balance updates at invoice finalization, not on event ingestion.
"Real-time burndown" maps to a 5-minute-refresh ongoing-balance estimate, available only on premium tiers.
The AGPLv3 core does not include the customer portal, credit notes and refunds, automatic dunning, tax integrations, or CRM and accounting connectors. All are paid-tier features. Open-source is "free as in AGPLv3 core," not "free as in everything you need to run a billing system in production."
Cloud pricing is not public.
Self-hosting adds infrastructure (Postgres, Redis, five or more application services) and ongoing engineering for upgrades.

4. Flexprice

Open-source hybrid billing platform with a no-code dashboard, designed for early-stage AI and SaaS teams adopting usage pricing for the first time.

Best for: Early-stage AI teams 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/month annual); Premium $1,000/month ($800/month annual); Enterprise custom (Flexprice pricing, accessed April 2026).

Strengths:

AGPLv3 open-source core. 3,600+ GitHub stars, 4,633 commits.
No-code pricing dashboard for non-engineers.
ClickHouse-backed real-time event metering.
Wallet system with auto top-up, low-balance alerts, and promotional credit grants.
Multiple PSP integrations: Stripe, Razorpay, Paddle, Chargebee.
Customer Simplismart reports 6x faster pricing iteration and reclaimed 30% of engineering bandwidth; Segwise completed core implementation in approximately two weeks (Flexprice customer stories, accessed April 2026).

Trade-offs:

Usage-based wallet debit is invoice-driven, not event-driven. Charges accumulate and debit on INVOICE_PAYMENT, not at event ingestion. If you need real-time blocking before a model runs, this is the wrong choice.
The customer portal is read-only. No self-service top-up.
Auto top-up is merchant-controlled, not customer-controlled.
Advanced features (real-time prepaid balance, recurring top-ups, entitlement management) require paid tiers.
PSP support is limited to four providers; no bring-your-own PSP model.

5. Stigg

Real-time monetization control layer that orchestrates entitlements, pricing, and credits across an existing downstream billing system (Stripe, Zuora, or Chargebee).

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

Pricing: Sandbox free; Growth from $448/month billed annually with a contract minimum; Scale enterprise custom (Stigg pricing, accessed April 2026).

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, expiry, prepaid pools, custom consumption formulas, and an append-only ledger.
No-code pricing console for non-engineers.
Embeddable React, JavaScript, and Vue widgets for pricing tables and customer portals.
Broad SDK coverage: Node, Python, Go, Ruby, Java.
Billing-system agnostic. Connects to Stripe, Zuora, Chargebee, AWS Marketplace, and the App Store.
Named customers include Webflow, Miro, Cloudinary, AI21, New Relic, PagerDuty, Upwork, and Airbyte.

Trade-offs:

Does not handle the billing transaction itself. Payment collection runs through the downstream billing system at cycle end.
Requires a downstream billing system already in place. Not a fit for vibe coders starting from scratch.
No hosted redirect-style billing portal. Embed-only widgets.
No profitability analytics; no event-level cost ingestion.
$448/month Growth floor with a contract minimum.
Sandbox is non-production only.
No documented MCP server or AI coding tool integration.

How to choose

If you are a solo builder shipping an AI app inside Cursor, Lovable, Bolt, Claude Code, or Replit and want to add billing through a prompt conversation rather than backend code: Credyt fits. The MCP server is the only documented prompt-based setup path among the five platforms above. The integration becomes a question you ask the AI coding tool, not a sprint.

If you are building a subscription-first SaaS with predictable monthly fees and a small metered overage component, and your customers expect a hosted Stripe Customer Portal: Stripe Billing fits. It is the lowest path of resistance for subscription billing where usage is the exception, not the rule.

If your team needs code transparency, on-premise or VPC deployment, or self-hosting for compliance reasons: Lago fits. Budget for either a cloud sales conversation or premium-tier engineering work for the customer portal, dunning, credit notes, and integrations. The AGPLv3 core alone is not enough to run production billing without rebuilding those pieces in-house.

If you are an early-stage AI or SaaS team adopting hybrid usage-and-credit pricing through a dashboard, and you do not need real-time balance enforcement on every event: Flexprice fits. The wallet debit is invoice-driven; if you need real-time blocking before a model runs, pick a real-time architecture instead.

If you already run Stripe, Zuora, or Chargebee and want to centralize entitlements and credits in one no-code control layer above your billing system: Stigg fits. Stigg sits above the billing system rather than replacing it. If you are starting from scratch with no billing system, Stigg requires you to set up a downstream system first.

Bottom line

The five platforms above cover four architectures: real-time end-to-end billing (Credyt), subscription-first with metered overages (Stripe Billing), invoice-based open-source (Lago), hybrid with a wallet add-on (Flexprice), and real-time orchestration over a downstream billing system (Stigg). For vibe coders specifically, the pivotal axis is setup time.

Stripe's Meter Events API and Subscription Items integration takes weeks even for experienced engineers. Lago and Flexprice ship to production over multiple weeks once self-hosting and webhooks are wired. Stigg requires a downstream billing system already in place. Credyt's MCP server changes the shape of the integration: billing setup happens through a prompt inside the AI coding tool the vibe coder is already using. Which fits depends on the cost structure of the product being billed and how much engineering time is available to spend on billing instead of product. See Credyt's transparent per-wallet pricing for one reference point.

FAQ

How do I add usage-based billing to my app?

The fastest path depends on the AI coding tool you build with. If you use Cursor, Lovable, Bolt, Claude Code, Replit, Windsurf, V0, or Codex, you can add billing through a prompt by connecting the Credyt MCP server (mcp.credyt.ai) and asking the tool to wire it up. If you build on Stripe, the path is to define a Meter, add a Subscription Item, and submit usage events from your product code. If you self-host, Lago's AGPLv3 core covers metering and invoicing on Docker Compose, with paid tiers required for the customer portal, dunning, and integrations. Flexprice and Stigg both support pricing dashboards, but Stigg requires a downstream billing system already in place.

What billing platform works best for AI applications?

It depends on how your costs hit. AI products with per-token, per-request, or per-inference infrastructure costs benefit from real-time architectures (Credyt, Stigg) because they can authorize spend before the cost is incurred. AI infrastructure costs run 35-40% of revenue for AI-native companies versus around 10% for traditional SaaS (Bessemer Venture Partners, State of AI 2025). Billing architecture is a margin-defense decision in this environment, not just a convenience. For subscription-led products with a small AI overage feature, Stripe Billing is fine. For high-throughput enterprise workloads with quarterly contracts, invoice-based platforms designed for that use case (Metronome, Orb) are a better fit; those are covered separately for a developer audience in the sister listicle.

Can I use Stripe and a usage-based billing platform together?

Yes. Most purpose-built usage-based billing platforms integrate with Stripe rather than replacing it. Stripe handles payment processing; the usage-based billing platform handles metering, pricing, wallets, and invoice generation. This split is the norm: payments stay where they are; billing logic moves to a tool designed for usage. Stigg is explicitly architected as an orchestration layer over Stripe (or Zuora, or Chargebee). Credyt and Lago integrate with Stripe natively for payment collection.

Are open-source billing platforms truly free?

The AGPLv3 cores of Lago and Flexprice are free to self-host. The cost to reach production isn't zero. Lago's AGPLv3 core doesn't include the customer portal, credit notes and refunds, automatic dunning, tax integrations, CRM connectors, or AI agents. All are premium features.

Flexprice's open-source tier requires the paid tier for entitlement management and recurring wallet top-ups. Add infrastructure (Postgres, Redis, Docker), upgrades (Lago has shipped 183 releases through April 2026), 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."