Your heaviest user sets the price of your AI feature.

The usual way to price an AI feature is to estimate what an average user costs, check that it comes in under the subscription, and ship. It looks safe on paper, because the average is a few cents. But you don't pay for the average user. You pay for every user, and the bill is set by the ones who press the button all day. Price the feature for them, or they will price it for you.

Why the average is the wrong number

Usage of almost any creative feature is lopsided. Most people try it a few times and move on. A small group adopts it as a habit, and a handful treat it as a slot machine, regenerating until something lands. A mean taken across all of them blends the dabblers with the obsessives and lands on a figure that describes nobody. Worse, the dabblers are mostly on your free tier, so they pull the average down while paying nothing.

The number that matters is what your most active paying users cost, set against what they pay you. If that number is fine, every lighter user is margin. If it isn't, no amount of healthy averages will save the month.

Do the per-call arithmetic first

Start with real prices for a single call. On Google's paid tier, Gemini 3.5 Flash-Lite costs $0.30 per million input tokens and $2.50 per million output tokens, and the output rate includes thinking tokens. A typical text call for a headline or a description might send 3,000 tokens and get 1,000 back, half of it thinking. That works out to $0.0009 for the input and $0.0025 for the output, about a third of a cent in total. Notice which half dominates: output costs over eight times as much per token as input, so a generous thinking budget can cost more than the prompt it's thinking about.

Images are a different scale. Gemini 3.1 Flash Image charges $0.067 for one 1K image and $0.151 at 4K. A single 1K image costs about as much as twenty of those text calls. This is the pattern in most AI products: the text features round to zero and one generative feature carries nearly the whole bill. Find that feature before you set any limits, because it's the only one the limits really need to cover.

Then set it against what a subscriber actually pays you

The price on the paywall isn't your budget. Take a $8.99 monthly plan. Under Apple's Small Business Program, or Google Play's subscription rate, the store keeps 15%, which leaves about $7.64. In regions where the store collects VAT, proceeds are lower still. At $0.067 an image, that subscriber can generate about 114 images a month before you're paying them to use your app, roughly four a day. Text barely registers: the same $7.64 covers over two thousand calls at a third of a cent each.

Four images a day sounds like plenty, until you watch someone iterate. A user who regenerates a backdrop twenty times to get the mood right, twice a week, uses 160 images a month and costs you about $10.70. That isn't abuse. It's your most engaged customer doing exactly what the feature invites.

Annual plans make it tighter, not looser. A $69.99 yearly plan leaves about $59.49 after a 15% cut, or $4.96 a month, so your most committed customers have the smallest monthly budget of anyone. We've argued before that an annual plan is a loan, not a windfall; with metered AI behind it, that loan gets spent every time they tap generate.

Free users are a cost with no revenue line

The free tier is where the arithmetic goes quiet and the bill gets loud. Suppose free accounts get ten images to try the feature: that's $0.67 for each user who uses them all. If one free user in forty eventually subscribes, a number to replace with your own, every paying customer carries 39 × $0.67, about $26 of other people's trials. That's more than three months of their proceeds, spent before they paid you anything.

None of this means you shouldn't offer a free taste. It means the free allowance should be set by your conversion rate and margin, not by a round number that felt generous. Often the right free tier is unlimited cheap features and a small, explicit taste of the expensive one.

Meter the expensive thing, in a unit people understand

Once you know which feature carries the cost, limit that one and leave the rest open. Counting every text call frustrates users while protecting almost nothing. A clear allowance on the expensive action, such as "40 backdrops a month," protects the margin and is something a person can reason about. Opaque credits that different actions consume at different rates feel like a casino currency, and people tend to hoard them or resent them.

When someone hits the allowance, decide what happens before it happens. A hard wall is honest but abrupt. Softer options include dropping to a lower resolution at a lower price ($0.045 for a 0.5K image instead of $0.067 at 1K), or moving the request to a slower, cheaper lane. Gemini's batch tier charges $0.034 for a 1K image, and our batch API walkthrough covers which work can wait for it. Show the remaining count in the interface well before it runs out, so the limit is never a surprise.

Enforce it where nobody can skip it

A limit that lives in the app is a suggestion. ShotCanvas debounces its backdrop button so a user can't fire a burst of generations by tapping repeatedly, and that catches accidents. It does nothing against someone who calls the backend directly. Anyone with a valid login can script requests to your proxy, so the real counter has to sit on the server, keyed to the account, checked before the request is forwarded to the model.

That assumes you have a proxy at all. If your app calls a model provider with a key embedded in the client, there's no per-user limit to enforce, because every user is you. We learned that the expensive way when a key in our web bundle got scraped. Every AI call in ShotCanvas now goes through an authenticated server-side proxy that holds the key and identifies the caller by their sign-in token. Generated backdrops are Pro-only and cached per set, because each one is a real cost and the same set shouldn't pay for its backdrop twice.

Finally, set a spending cap at the provider or billing-account level. It's the limit you hope never fires, and the only one that still works when your own code has a bug.

Watch the tail, not the mean

Log tokens and image counts per account on the server, every call, and look at the spread. The median tells you what a normal user costs. The 95th percentile tells you whether your allowance is set right. The single most expensive account tells you whether something is wrong: a runaway retry loop, a shared login, or a script. Review those three numbers each month alongside revenue. When a new model ships at a different price, rerun the per-call arithmetic before you switch, because a model that's 5% better and three times the output price changes every line above.

In ShotCanvas the text work (headlines, layouts, translations) is the part that rounds to zero. The generated backdrops are the line item, so that's where the gating lives.