Revenue Per Token (RPT) Overview
Understand how bizSupply meters AI usage and converts tokens into credits — the unit you see on your plan, your balance, and your invoice.
Revenue Per Token (RPT) is the metering and billing engine behind bizSupply. Every time the platform uses an AI model to process a document — classifying it, extracting data from it, benchmarking it, or answering a question about it — a small amount of tokens is consumed. RPT translates those tokens into a single, consistent unit of account called credits, so you always know what you paid for, and why.
In one sentence: RPT turns AI model usage into a fair, auditable, and predictable bill.
Why RPT Matters
Different AI models have very different price points. A single platform feature might call two or three models in one request, each with its own provider, currency, and pricing structure. Without a normalized unit, every invoice would look like a raw vendor dump.
RPT solves three problems at once:
| Problem | RPT’s answer |
|---|---|
| Opaque billing | A single unit (credits) across every feature, every model, every provider. |
| Unpredictable cost | Subscription plans fix the credit budget up front; overages are explicit. |
| Audit gaps | Every AI call is recorded and reconcilable, forever. |
Core Concepts
A small glossary so the rest of this section reads cleanly.
| Term | Meaning |
|---|---|
| Token | The smallest billing unit an AI model reports back. A short sentence is roughly a dozen tokens. |
| Credit | bizSupply’s internal currency. Credits are what you purchase and consume. |
| Allocation | A grant of credits to your account — from a subscription, a renewal, or a plan change. |
| Consumption | Credits you have used over time. |
| Balance | Allocated − Consumed. What you have left. |
| Entitlement | Your active subscription record, whether via Stripe or a cloud marketplace. |
| Plan | The subscription tier that determines your monthly allocation and feature set. |
Tokens are the raw unit reported by AI providers. Credits are the stable unit you see. RPT is the translation layer between the two.
How a Request Becomes a Charge
At a high level, the path from "you clicked a button" to "a credit was consumed" looks like this:
┌───────────┐ ┌─────────────────┐ ┌────────────────┐
│ You / │────▶│ bizSupply │────▶│ AI model │
│ your app │ │ processes the │ │ (OpenAI, │
│ │ │ request │ │ Gemini, ...) │
└───────────┘ └────────┬────────┘ └────────┬───────┘
│ │
│ tokens used │
◀───────────────────────┘
│
▼
┌──────────────────────┐
│ RPT metering layer │
│ tokens → credits │
└──────────┬───────────┘
│
▼
┌──────────────────────┐
│ Your account ledger │
│ (allocations + │
│ consumption) │
└──────────┬───────────┘
│
▼
┌──────────────────────┐
│ Your bill / your │
│ subscription quota │
└──────────────────────┘Five stages, nothing hidden:
- Request — You (or your integration) ask bizSupply to do something.
- AI work — bizSupply selects the right model(s) and executes the task. Each model returns the number of tokens used.
- Pricing — RPT looks up the current price of that model and computes the underlying cost.
- Credit conversion — RPT converts the cost into credits using a published conversion rule (cost-based, plus a platform overhead that funds infrastructure, support, and product development).
- Ledger update — Your balance is updated. Your plan decides whether this counts against a prepaid allocation or against metered usage for your marketplace subscription.
Only successful AI calls produce token usage. Failed calls do not consume credits. Internal retries performed by bizSupply are not double-billed.
What You Will Never See Change
RPT is built on a handful of invariants that hold across every plan, every provider, and every release. They are the contract between the platform and your bill.
- Single unit of account. Credits are the only unit you will ever be asked to reason about. Providers can change, models can be added or retired — the credit line on your usage report does not change shape.
- Cost-based conversion. Credits derive from the actual underlying AI cost. If a provider drops their prices, your credits go further.
- Append-only ledger. Credit grants and consumption events are immutable once recorded. No retroactive rewrites.
- Predictable caps. Each plan has a monthly allocation. You know your ceiling in advance.
- Fail-safe enforcement. Metering never blocks your request path. Quota checks are designed to fail open when the billing layer is momentarily unavailable, never to drop billing data.
Where to Go Next
- Plans & billing models — credit allocations by plan, self-serve (Stripe) and marketplace (metered) billing.
- Fairness & observability — the principles and APIs that let you explain your bill.
- Compliance & audit — how usage reporting and data handling meet enterprise requirements.
- FAQ — the shortest path to common questions.
- Managing your subscription — the tactical guide for upgrading, downgrading, invoices, and API keys.