How to calculate customer usage for billing

1. Define the billable unit

Before you can measure anything, you need to decide what counts as “usage” for your product. 

This isn’t just a technical decision; it shapes your pricing, your customer’s understanding, and how fairly you can bill for value.

Start by asking: what does your product deliver to customers? In the AI and agentic world, that might be API calls, the number of tokens processed, compute minutes, hours of GPU time, or even the number of unique agents running. 

Your billable unit should directly tie to the value your product provides, otherwise, you’ll end up with confusing invoices and support tickets asking, “What am I actually paying for?”

Let’s break down a few common examples:

• API Calls: You charge every time a customer’s system makes a request to your platform.

• Tokens: If your product processes text, you might bill based on the number of tokens handled, helpful for LLMs, but make sure customers know what a token actually is.

• Compute Minutes or GPU Hours: For heavy workloads, charging for raw compute time keeps things fair and lets customers scale as their needs grow.

• Unique Agents: If your platform spawns independent agents, you might count how many are running in a given billing period.

The billable unit you pick should be easy for your team to measure and for your customers to understand. If it feels abstract, take the time to explain it. A clear unit of measure is the foundation of billing that both sides can trust.

2. Pre-process raw usage data

Once you’ve picked your billable unit, you need to make sure the data behind it is clean, complete, and ready to be used. 

Most of the time, your product doesn’t produce neatly packaged usage summaries. 

It generates raw events, logs, traces, API hits, inference outputs. Turning those into something you can bill on requires a bit of prep work.

Think of this as organizing the workbench before you start building.

Here’s what you need to do:

• Sort Usage by Customer and Product

Usage data usually comes in fast and messy. Group it by customer first. 

If you offer multiple features or SKUs, tag each event with the relevant product, service, or feature category. This helps you apply the right pricing later.

• Handle Multi-Org or Business Units

If a customer has several teams or accounts under one contract, you’ll need to pool that usage before billing. 

That means summing usage across business units and billing it as a single line item, even if reporting stays separated.

• Filter Out Non-Billable Usage

Not every action needs to count. Internal testing, failed requests, or usage tied to sandbox environments should be excluded. Define those rules early and make them easy to audit.

• Subtract Free or Included Units

If your plan includes, say, 100,000 free tokens or 1,000 agent hours per month, subtract those before you calculate charges. 

These entitlements often reset each billing cycle, so you’ll need to track and apply them per customer, per period.

• Normalize to Billable Units

You might track data in seconds but bill in minutes. Or meter at the event level but bill in blocks of 10,000. Convert all raw numbers into the unit you charge for. That means rounding, dividing, or aggregating based on your pricing logic.

This step isn’t glamorous, but skipping it leads to billing confusion, disputes, or worse, missed revenue. If your data is clean, every step after this becomes easier.

3. Aggregate usage

Now that your data is clean, it’s time to sum it up. But aggregation isn’t just about totals—it’s about choosing the right logic for your product. The way you combine usage events determines whether your billing feels accurate or confusing.

In a usage-based model, you rarely bill per event. Instead, you aggregate over time—daily, hourly, monthly, or by a specific customer action. For AI and agentic products, this step is where most of the nuance lives.

Common aggregation strategies:

• Sum

This is the most straightforward method. Count everything and charge based on the total. It works well for API calls, compute seconds, or image generations.

• Count Unique

You charge based on the number of distinct items—like unique agents deployed, users served, or customer accounts reached. This is useful if you’re pricing by active users or agent IDs rather than total volume.

• Latest Value

Capture only the most recent data point in a series. This is common for things like usage caps or peak metrics (e.g., highest concurrent agents run during a period).

• Multiplier

Multiply two values to compute the charge for example, token count × model size, or image frames × resolution. This is helpful when a single dimension doesn’t capture the full cost.

• Custom

Some products need more complex logic. You might define your own formulas or use external metrics (like cursor-based tracking or GPU burst patterns) to create a billable unit.

The right aggregation method matches how your product delivers value. 

Don’t just default to “sum” because it’s easy, your customers will feel the difference when billing reflects what they actually used.

4. Apply pricing logic

You’ve got clean, aggregated usage data. Now comes the part that turns that data into revenue: pricing.

But applying pricing isn’t just “X units times Y dollars.” It’s where business rules meet billing infrastructure. If you skip the nuance here, your invoices won’t reflect your pricing strategy, and your customers will feel it.

Here’s what to layer in:

• Apply Plan-Specific Rules

Every customer plan has its own pricing logic. Free tiers might include usage caps, while enterprise plans might bundle discounts or special entitlements. 

Before pricing, check which plan the customer is on, and what that plan unlocks.

• Handle Pricing Tiers

If your pricing includes usage tiers like $0.002 for the first million tokens, then $0.001 after you’ll need to apply the right rate to the right portion of usage. 

This is where most errors creep in. Make sure your system can break usage into blocks and price each one correctly.

• Respect Minimums and Maximums

Some plans have minimum charges per period or maximum spend caps. These get applied after all usage is priced. 

They’re not just edge cases they’re often what makes or breaks customer trust in a billing cycle.

• Time-Based Pricing Logic

If your pricing changed mid-cycle, or your customer switched plans, you need to split the period and apply different rates to each section. 

Time-based logic is common in AI workloads, where plan upgrades or model changes happen fast.

• Currency and Tax Considerations

You might support multiple currencies or need to apply taxes based on customer location. Pricing logic should account for that before invoices go out not as a post-processing step.

Pricing logic is where your monetization strategy lives. If your platform can't express it clearly, you're stuck either undercharging or manually fixing things later.

5. Generate billable records

At this point, you’ve captured, cleaned, and priced your customer’s usage. Now, you need to turn that into something your billing system—or customer—can actually act on: a billable record.

This is the source of truth for every invoice line item. It doesn’t just say what the customer used, it shows why they’re being charged that amount. That transparency is what prevents disputes, builds trust, and lets you automate the rest of your revenue operations.

A strong billable record includes:

• Customer Identifier

Tie the usage to the exact account or organization being billed. No ambiguity.

• Product or Feature

What was used, whether that’s “GPU hours,” “Text Completion API,” or “Voice Agent session.”

• Billing Period

Make it clear what timeframe the usage occurred in. Monthly, hourly, calendar-based, whatever your system supports.

• Billable Quantity

After entitlements and aggregation, how much of the unit is actually billable? This is the final quantity that gets priced.

• Rate Applied

The exact rate (or tiered rates) used to calculate charges. If discounts or minimums were applied, that should be traceable here too.

• Final Charge

The total amount for that line item, including any rounding logic or special pricing rules.

Each billable record becomes a line in your invoice, a row in your revenue report, and a breadcrumb for every future reconciliation.

If this part is messy, everything downstream (invoicing, collections, revenue recognition) will become brittle. Clean records give you leverage everywhere else.

6. Store and sync billing data

Once you’ve generated billable records, you need to make sure they don’t just sit in isolation. 

They have to flow into the right systems so invoices can be created, reports can be generated, and your team has a single version of the truth.

Think of this step as moving from a scratchpad to a ledger. The calculations are complete, but unless they’re stored and synced, they can’t power your business.

What to do here:

• Centralize Billable Records

Store every billable record in a reliable datastore, something auditable and resilient. This becomes your single source of truth for all usage-based charges.

• Connect to Invoicing

Your billing system (whether it’s homegrown or integrated) should pull from this datastore to assemble invoices. That means no manual copying, no back-and-forth between spreadsheets.

• Feed Finance and Revenue Ops

Sync the same records into your accounting and revenue recognition systems. This keeps finance aligned with product usage and avoids messy reconciliations at month-end.

• Enable Customer Visibility

Expose the records, directly or through aggregation—in customer dashboards. This lets your users trace every charge back to their own activity, reducing support tickets and disputes.

• Maintain Auditability

Keep a clear log of every adjustment: credits applied, usage corrected, or late-arriving events processed. Billing data should be explainable months or even years later.

When you treat billable data as a product artifact, stored, synced, and versioned, you give your customers clarity and your team confidence. Without this, billing becomes a game of “trust me,” which never scales.

7. Backtest and improve

Usage-based billing isn’t set-and-forget. It’s a system that needs to evolve with your product, your pricing strategy, and your customers’ behavior.

Once a billing cycle ends, your job isn’t over. It’s just the start of the feedback loop.

Here’s how to close that loop:

• Re-run the Cycle with Historical Data

Backtest new pricing logic against past usage. What would revenue have looked like if you switched from token-based pricing to outcome-based? Or if you introduced volume discounts? You’ll spot underpriced usage and see where margins improve or shrink.

• Investigate Anomalies

Did a customer’s invoice spike unexpectedly? Did certain features drive more usage than expected? Look at usage logs, aggregation strategies, and grant logic. These insights aren’t just helpful, they often uncover edge cases your product team missed.

• Identify Revenue Leaks

Billing isn’t just about what you charge. It’s also about what you miss. Every time you skip tracking a product event, misapply a plan, or forget to set a rate—it’s silent revenue loss. Track it down.

• Align with Product and Finance

Share billing patterns with Product and Revenue teams. High usage doesn’t always mean high revenue, and this misalignment is where pricing upgrades, feature gating, or new SKUs are born. Revenue growth often starts with billing data no one’s looking at.

• Iterate on Experience

If customers opened support tickets or struggled with invoices, audit the UX. Were usage units too abstract? Was the rate structure too complex? Simplify wherever it doesn’t hurt business logic.

Build this Entire Flow with Flexprice

Everything you just read, tracking raw usage, aggregating events, applying pricing, syncing records, generating transparent invoices, and learning from billing data—you can do with Flexprice.

Flexprice is the open billing engine built for AI-native and agentic products.

We support:

• Event-level usage tracking tied to compute, token, or API behavior

• Advanced aggregations like sum, count unique, latest, and multiplier—designed for real-world agent workloads

• Wallet-based credit systems with grant logic that supports recurring top-ups, expiry, and usage priority

• Granular invoice workflows with line-item breakdowns and plan-aware billing

• Backtest-ready architecture so you can experiment with pricing logic before rolling it out

You don’t have to rebuild billing logic every time your monetization evolves. You don’t have to rely on black-box systems that hide the math behind your invoices. And you don’t have to choose between developer control and revenue accuracy.

Flexprice gives you billing infrastructure that scales with your product complexity—without slowing you down.

If you’re monetizing AI workloads, running voice or video agents, or experimenting with hybrid pricing:

→ Join the Slack community

→ Explore our GitHub

→ Book a demo