How to implement usage-based pricing for an AI product

1. Pick a pricing model: per-action, per-token, or hybrid

Per-action ("$X per render") is simplest to communicate; per-token ("$Y per 1M tokens") is fairest; hybrid ("$X/mo includes 100 renders, then $Y per overage") is what most mature AI products land on.

2. Define limit groups for the billable units

For per-action: unit "count". For per-token: unit "tokens" or "cents". For hybrid: stack a fixed quota group with an overage group on the same plan.

3. Reserve, call AI, commit, refund

Same atomic pattern as anywhere. The novelty for usage-based is the refund - when you reserved 4k tokens but only used 800, you must track a refund event so the user is not over-charged.

const r = await vevee.reserve(userId, "llm.tokens", 4000, { model: "gpt-4o" });
if (!r.allowed) throw new LimitError();

try {
  const res = await openai.chat.completions.create(/* ... */);
  const used = (res.usage?.prompt_tokens ?? 0) + (res.usage?.completion_tokens ?? 0);
  await vevee.commit(r.reservationId!);
  if (used < 4000) {
    await vevee.track(userId, "llm.tokens.refund", 4000 - used, {
      reservationId: r.reservationId!,
    });
  }
} catch (err) {
  await vevee.release(r.reservationId!);
  throw err;
}

4. Sync usage to Stripe at period close

Vevee tracks; Stripe invoices. At the end of each billing period (or in real time, depending on your Stripe plan setup), push the user's consumed quantity to a Stripe usage record on the relevant meter.

import Stripe from "stripe";
const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);

export async function syncUsageToStripe(userId: string, stripeCustomerId: string) {
  const usage = await vevee.usage(userId);
  const tokens = usage.counters.find(c => c.label === "Billable tokens")!;

  await stripe.billing.meterEvents.create({
    event_name: "llm_tokens",
    payload: {
      stripe_customer_id: stripeCustomerId,
      value: String(tokens.count),
    },
    timestamp: Math.floor(Date.now() / 1000),
  });
}

5. Surface live spend to the user

Use a pk_live_ key in the browser to render "$3.42 used this month, $46.58 remaining on your $50 plan". Pulls from vevee.usage(userId) - safe to expose.

Margin math (the part nobody talks about)

If GPT-4o input costs $5/1M tokens to you, do NOT charge users $5/1M tokens. You need margin for: GPU latency overhead, rate-limit headroom, support cost, your gross margin target, and surprise model price changes. A 50-100% markup is normal for AI.

Pre-paid credits vs post-paid invoicing

Pre-paid: user buys $50 of credits, you decrement. Predictable revenue, no chargebacks, but blocks happy users mid-task. Post-paid: user uses, you bill. Better UX, but you carry credit risk and surprise bills are common. Most consumer AI is pre-paid; most B2B AI is post-paid; many products offer both.

Avoiding the "free tier was a mistake" trap

Free tiers for AI must have hard caps that break exactly when you intend them to. If your free tier covers 1k tokens but you allow up to 4k due to imprecise enforcement, your margin gets murdered. Vevee's atomic reserve closes this.

Communicating price to the user

Variable bills make users anxious. Always show "this prompt will cost approximately X" before the call runs (use a local tokenizer for the estimate). Show "$X used this month, $Y remaining" prominently. The biggest predictor of churn for usage-based AI products is users feeling out of control.