1. Hybrid Base + Usage

Structure: Charge a base subscription (covers fixed costs: access, support, onboarding) + a meter for incremental usage (API calls, tokens consumed, hours used).

Why it works: You give clients predictable minimum spend (they like that) while capturing upside as usage climbs. Good for products that have a fixed component plus elastic usage.

When to use: You’ve got users with varying usage but still want baseline revenue.

Key Features:

• Define a plan with base cost and usage fee within the same product object.

• Plug real‑time usage into your billing logic so clients can preview their bill.

• Use wallets or commit logic to buffer large users.

Pitfalls: If the base feels like “you’re paying even when you hardly use it,” you’ll hear complaints. Make the base clear: this covers platform upkeep, support, and minimal usage.

2. Tiered Usage Pricing

Structure: Create level tiers (e.g., up to 100k tokens = $X, up to 500k = $Y, above that prorated or at rate Z). Customers pick a tier that matches their forecast.

Why it works: Clean self‑selection, budgetable, and upsell path is built in. Good when usage is somewhat stable but you expect growth.

When to use: Your users sit in bands (startup, scale‑up, enterprise) and you want predictable billing yet elasticity.

Key Flexprice hooks:

• Define tier thresholds in plan definitions.

• Automatically switch to the next tier when thresholds are exceeded.

• Provide dashboards that show “you’re at 85% of Tier 2 threshold.”

• Use volume discounts so the next tier has better per‑unit economics.

Pitfalls: Setting wrong breakpoints kills value capture or frustrates users. Monitor monthly usage patterns and adjust tiers annually.

3. Volume or Graduated Discounts

Structure: Per‑unit cost drops as consumption climbs (e.g., first 100k tokens at $0.02 each, next 400k at $0.015 each, beyond at $0.01). Or pre‑sell large blocks at discounted unit cost.

Why it works: Encourages consolidation, rewards heavy users, builds loyalty.

When to use: You have clients with high growth trajectories or very heavy usage customers that you want to lock in.

Key Flexprice hooks:

• Build graduated pricing curves in the product schema.

• Meter dynamically, when the user crosses threshold, rate changes automatically.

• Show “Your effective unit cost this month: $0.011 (based on your 1.2M units)” in UI.

Pitfalls: Without volume visibility buyers may distrust savings. Transparency is key.

4. Prepaid Credits & Draw‑Down Wallets

Structure: Buyer deposits a credit balance. Usage events withdraw from the wallet. They refill manually or via auto‑top‑up. You can also expire credits to encourage commitment.

Why it works: Gives buyer budget control (“how much am I spending?”) while you get upfront cash. Great for variable usage and unpredictable spikes.

When to use: Ideal when usage is spiky (e.g., burst AI jobs) and customers prefer to pre‑approve spend.

Key Flexprice hooks:

• Create wallet objects per customer with balance and draw‑down logic.

• Trigger notifications when balance falls below threshold.

• Show projected burn rate, letting user top up proactively.

• Combine with base + usage so small users still pay something.

Pitfalls: If refill logic is broken or notifications missing, you’ll have frustrated users who can’t consume because credit ran out.

5. Minimum Commit + Overage

Structure: Customer commits to spending a minimum per month/quarter. Above that they pay for usage at agreed unit rates.

Why it works: Enterprise‑friendly buyers get budget commitment and you get revenue floor, while still allowing for extra usage.

When to use: Your product is mission‑critical and usage is expected to vary wildly (e.g., auto‑scaling ML workloads).

Key Flexprice hooks:

• Plan contains a “commitment” object (e.g., minimum spend $50k/month).

• Overage logic triggers after the commitment threshold.

• Dashboard shows “You’ve committed $50k; you’re at $38k; remaining usage is unbilled.”

• Alert when overage threshold is approaching.

Pitfalls: If a customer underuses the commit consistently, resentment builds. Use it selectively for enterprise only.

6. Entitlements & Feature‑Gating

Structure: Instead of plan grids going wild, you deliver modular limits/features (entitlements). Example: “Max 10M tokens,” “Access to advanced model,” “Priority support.” These can be purchased a‑la‑carte or bundled.

Why it works: Clean packaging, fewer SKUs, flexible upgrades. You avoid “plan explosion” and simplify monetization.

When to use: Your product has multiple modules/features plus usage; you want upsell motion beyond just “more units”.

Key Flexprice hooks:

• Each plan attaches entitlement objects (limits, features).

• UI/API to grant or revoke entitlements instantly.

• Combine entitlements with wallet/usage so you can say: “For $X you get advanced model + 5M tokens.”

Pitfalls: If entitlements and usage are disconnected your buyers will be confused (which is cheaper, feature or usage?). Keep UI clear.

How to Choose The Right Consumption Based Model

• Pick the unit your buyer already thinks in (tokens, render minutes, API calls, leads).

• Choose one stabilizer (base fee, commit, prepaid, tier) to reduce bill shock.

• Build visibility: live usage, dashboards, alerts.

• Ship one of these models via Flexprice first. After you gather data, iterate tiers, discounts or outcome billing.

Bottom line

Flat monthly‑fee billing is dying in usage‑driven tech. The winners adopt hybrid models that deliver elasticity and predictability. With Flexprice you get the engine to support metering, wallets, entitlements, rate curves and commits all in one. 

Pick the model that fits your product, use the tools Flexprice gives you, and iterate rapidly. Market expectations have shifted: value consumed = value billed. Time to upgrade your billing.