How are people pricing AI model usage in their app?

Last updated: August 31, 2026

Why is AI usage pricing getting harder right now?

AI usage pricing is getting harder because one user request can now cost almost nothing or several dollars depending on what the app actually does behind the scenes.

A few years ago, “one message” was a reasonable approximation for one model call. That assumption has broken down. A user can type “fix this bug,” and an AI coding agent may inspect dozens of files, call the model repeatedly, run commands, test the result, browse documentation and retry failed approaches before answering.

Replit ran directly into this problem with Agent. Its original system charged $0.25 per checkpoint. Once Agent became capable of working autonomously for much longer, Replit said some requests could consume more than $10 of compute. A customer interaction that looked almost identical in the interface could therefore cost the company forty times more.

The range keeps widening as agents become more autonomous. A short rewrite can use one cheap model call. Deep research, coding or computer-use tasks can trigger long chains of calls and tools.

That makes the pricing question much more interesting than deciding whether to charge $20 or $30 a month. AI apps now have to make customer spending predictable while dealing with an underlying cost that can be wildly unpredictable.

Are most AI apps actually charging users per token?

Most AI apps currently avoid showing raw token pricing to customers, even though tokens still determine much of their cost underneath.

Token pricing makes sense when the product being sold is inference itself. OpenAI, Anthropic and other model providers can charge per million tokens because developers buying their APIs understand what that unit means.

People using applications usually think differently. Someone using an AI sales tool wants a company researched. Someone using a coding agent wants a feature built. Someone using a support agent wants a ticket resolved. Almost nobody naturally thinks, “I would like to buy another two million output tokens.”

We see that distinction across current AI products. Cursor tracks model consumption internally but packages it into monthly usage pools. Lovable uses credits. Replit combines subscription access with credits and effort-based usage. OpenAI itself now translates many ChatGPT Business and Enterprise activities into credits even though the underlying models are still token-metered.

Andreessen Horowitz recently tested this preference with 50 technical AI buyers. Twenty-seven preferred credits tied to recognizable work, while 14 preferred tokens. It is a small survey, but the gap matches what we see in actual product pricing.

Tokens are increasingly becoming the accounting unit inside the machine rather than the price shown on the checkout page.

What pricing model are AI apps using most often today?

The most common structure now is a monthly subscription with included AI usage, followed by credits or pay-as-you-go charges when customers consume more.

Cursor is a clean example. Its paid plans include monthly model usage, and customers who exhaust it can enable on-demand billing or move to a larger plan. ChatGPT increasingly works the same way for agentic products: the subscription includes usage first, then eligible customers can buy additional credits. Lovable gives paid workspaces a recurring credit balance and sells additional capacity. Replit combines monthly access with metered premium work.

Stripe's 2026 review of AI pricing reaches the same conclusion from a broader set of companies. It says mature AI businesses often converge on hybrid subscription-plus-usage pricing because subscriptions make budgets predictable while metering prevents the heaviest customers from consuming unlimited variable-cost compute.

That is why the structure keeps showing up.

A pure subscription works beautifully until a small group of customers starts running agents all day. Pure usage pricing protects margins but makes the bill feel unpredictable. Combining both lets most customers behave as if they bought normal software while the expensive tail pays more.

Why are so many AI apps inventing credits?

AI credits give companies room to change models, routing and infrastructure without forcing customers to understand every change in the underlying compute bill.

Lovable currently gives us a very concrete example. Its Default Mode charges different amounts according to the work performed. Its public examples put changing a button color at roughly 0.5 credits, removing a footer at 0.9, adding authentication at 1.2 and building a landing page with generated images at 1.7.

The customer can understand that a landing page took more work than changing a button. The exact number of model calls behind either task does not need to be explained.

OpenAI is using the same abstraction at a larger scale. In its current ChatGPT Business and Enterprise rate card, a Sol chat message costs about 10 credits, an Agent message 30, a Deep Research task 50, an image generation 5 and one minute of voice 5. More complex products such as Workspace Agents can still be token-metered underneath while drawing from the same broader credit system.

This gives the application an important advantage. If better routing cuts the cost of a workflow from $0.20 to $0.04, the company can keep some of that efficiency gain instead of automatically lowering the retail price fivefold.

Credits become much less useful when they are just tokens with a different name. “17 credits per 437,000 tokens” gives customers another calculation to make without giving them more clarity.

The good credit systems connect consumption to work people can recognize.

Does charging one price per AI message still work?

Fixed per-message pricing is becoming a poor fit for autonomous AI agents because one message can trigger radically different amounts of work.

Replit provides the clearest case study. The early version of Agent mostly handled short, predictable tasks, so charging $0.25 per checkpoint was workable. As Agent learned to debug its own errors and keep working for much longer, Replit found that 20 minutes of autonomous work could cost the company more than $10.

Replit eventually switched to effort-based pricing. Simple requests could cost around $0.06, while complicated ones could cost more than $1 and occasionally several dollars. The price started following the computing work performed rather than the number of times the customer interacted with Agent.

Lovable has moved in a similar direction. Its Default Mode varies credit consumption with task complexity, while its simpler Plan Mode can still use one credit per message.

That distinction is useful. Message pricing can work perfectly well for chat where costs stay relatively narrow. Once the same message can launch a long-running agent, the unit stops telling us much about cost.

How much can the model alone change the cost of an AI feature?

Choosing a different current OpenAI model can change the model bill for the same token workload by roughly 18 to 19 times.

The gap has become particularly large after recent price cuts. OpenAI currently charges $0.20 per million input tokens and $1.20 per million output tokens for GPT-5.6 Luna. Terra costs $2 and $12. Sol currently costs $4 and $20.

So take a small workflow using 2,000 input tokens and producing 500 output tokens. Luna costs around one-tenth of a cent. Sol costs roughly 1.8 cents.

At 100,000 input tokens and 5,000 output tokens, Luna costs about 2.6 cents while Sol reaches $0.50.

None of these calculations includes web searches, computer use, third-party APIs, retries, database work or other infrastructure. An agent repeating the process several times multiplies the difference again.

That is why model routing has become part of pricing strategy. If routine work can move onto a model costing a fraction as much while customers barely notice a quality difference, an app suddenly has much more room to bundle that work into its subscription.

Example workload	GPT-5.6 Luna	GPT-5.6 Terra	GPT-5.6 Sol
2K input + 500 output	$0.001	$0.010	$0.018
10K input + 2K output	$0.0044	$0.044	$0.080
100K input + 5K output	$0.026	$0.260	$0.500

Are cheaper AI models bringing unlimited usage back?

Cheap AI models are making generous or effectively unlimited everyday usage much more viable, while expensive agentic work is staying metered.

Replit has just pushed this idea unusually far. Its new Free Mode uses GPT-5.6 Luna and lets subscribers perform everyday Agent tasks without consuming credits. Replit says customers can create up to 30 times more within the same monthly subscription.

The timing makes sense. OpenAI recently cut Luna's API pricing sharply, and Luna now costs $0.20 per million input tokens and $1.20 per million output tokens. Sol currently costs $4 and $20. A task that can safely move from Sol to Luna can therefore become dramatically cheaper without disappearing from the product.

ChatGPT's current business rate card shows a similar separation. Instant chat can be unlimited under applicable guardrails, while Sol messages, Agent mode and Deep Research draw credits at progressively higher rates.

This gives us a fairly strong clue about where AI subscriptions are going. Routine intelligence can increasingly disappear into the base plan. Long-running agents, premium reasoning and expensive tools remain the places where customers encounter a meter.

How are AI coding apps pricing model usage now?

AI coding apps are mostly combining a subscription with some form of metered capacity because coding agents produce exactly the kind of uneven usage that flat pricing struggles with.

Cursor currently has two monthly usage pools. One covers Cursor's own models, where it can offer substantially more usage. The other covers third-party models and charges them at provider API prices. Cursor says daily Agent users typically consume around $60 to $100 a month in total model usage, while power users running multiple agents or automations often exceed $200.

Replit now goes further in the other direction for routine work. Cheap Agent activity can run through its subscription-funded Free Mode, while more demanding work can still consume paid capacity.

Lovable has unified building, cloud and AI usage into one credit balance. Bolt continues to make token allowances relatively visible. v0 also translates model consumption into a credit-based billing system.

These products have different user interfaces, but their economics increasingly resemble one another. Customers get a predictable starting bill, then increasingly expensive behavior consumes more of a limited resource.

Product	What customers mainly buy	How heavier usage is handled
Cursor	Subscription + included model usage	On-demand usage or larger plan
Replit	Subscription + included cheap Agent work	Credits for more expensive work
Lovable	Subscription + shared credits	Variable credit consumption and top-ups
Bolt	Subscription + token allowance	Larger token capacity
v0	Subscription + credits	Additional usage consumes more credits

How do regular SaaS products price AI when AI is only one feature?

Regular SaaS products increasingly bundle ordinary AI into the subscription and meter the autonomous features that can create much larger bills.

Notion illustrates the split well. Business and Enterprise customers get core Notion AI functionality inside their plans, subject to usage allowances. Custom Agents can run autonomously on triggers or schedules and consume separate Notion credits.

ChatGPT's own pricing is moving in a comparable direction. A subscription provides the normal usage allowance, while agentic products such as Codex, ChatGPT Work and other eligible features can continue through purchased credits after the included capacity runs out.

Clay offers another useful version of the idea. Its current pricing separates Actions from Data Credits. Actions cover work Clay performs inside its platform, such as running enrichments, AI research and workflows. Data Credits cover third-party resources Clay buys on the customer's behalf. Clay says its normal Action allowance is deliberately sized so around 90% of customers never hit the limit.

For SaaS founders, this suggests a practical boundary. Cheap AI that improves an existing feature can usually disappear into the plan. Autonomous AI that performs repeated external work needs much tighter metering.

Are AI agents starting to charge for results instead of model usage?

Yes. Outcome-based AI pricing is becoming a real commercial model where the result can be measured cleanly, especially in customer support and sales.

Intercom has gone particularly far. Fin currently charges $0.99 for a standard resolution, procedure handoff or disqualification. A successful sales qualification costs $9.99. One conversation can involve multiple model calls and procedures, but Intercom charges at most one successful outcome.

That difference in price is revealing. A qualified sales prospect is worth much more to a customer than answering a basic support question, so Intercom prices the two outcomes differently even though nobody outside Intercom needs to know which one consumed more tokens.

Zendesk also bills AI Agent usage through automated resolutions. Its latest system groups successful resolutions into tiers reflecting the value of the work. Customers pay when an AI agent resolves the request without human escalation.

Salesforce sits slightly lower down the same ladder. Agentforce can use Flex Credits, with a standard action consuming 20 credits worth $0.10, or conversation pricing at $2 per conversation.

We can already see the commercial unit moving away from raw inference as agents take responsibility for more of the workflow.

Product	Billing unit	Current example
Intercom Fin	Successful outcome	$0.99 resolution; $9.99 qualification
Zendesk AI Agents	Automated resolution	Charged when the AI successfully resolves the request
Salesforce Agentforce	Action or conversation	About $0.10 per action or $2 per conversation

When does outcome-based AI pricing actually work?

Outcome pricing works best when everyone can agree that the AI completed a specific result and there is little ambiguity about who produced it.

Customer support fits unusually well. A ticket either reached a successful AI resolution or moved to a human. Lead qualification can also be defined through clear conditions and routing rules.

Coding gets messy very quickly. Should Cursor charge when code is generated, when a pull request is created, when the code gets merged, or when it reaches production? A coding agent may have contributed 80% of a change or just fixed one line.

Research, writing and design have the same attribution problem. A research report is easy to count, but the value of that report might range from zero to thousands of dollars depending on what the customer eventually does with it.

Credits are useful in that middle territory. They move pricing closer to recognizable work without pretending the application can measure the customer's final business result.

So we should expect outcome pricing to spread fastest in narrow workflows where success has an obvious end state. Broader copilots will probably keep using subscriptions and usage for longer.

Should expensive AI models consume more credits?

Expensive AI models usually need to consume more internal capacity, although customers do not need to see every model-specific cost difference.

The economics are hard to ignore. At current OpenAI prices, a Sol workload can cost close to twenty times as much as the same token workload on Luna. Third-party frontier models introduce another set of prices.

Cursor makes part of this visible. Its own models receive a much larger included usage pool, while third-party models draw from a separate pool based on provider API pricing. Its Auto system can also route requests among models depending on the selected optimization mode.

Other applications simplify further. OpenAI's ChatGPT rate card can charge a fixed credit amount for a Sol message even though actual token consumption differs from message to message.

That is probably the better customer experience for many apps. Internally, we should track model cost down to the cent. Externally, two or three understandable capability levels are usually enough.

A customer who cannot perceive any difference between two models will struggle to understand why one unexpectedly consumed eight times more of the monthly allowance.

Should an AI app pass model costs through or let customers bring their own API key?

Direct model-cost billing and BYOK can work well for technical power users, especially when a small number of customers generate unusually large bills.

Cursor currently supports customer-provided API keys for several model providers. That lets technically sophisticated users pay the model provider directly while still paying Cursor for the product around it.

Clay provides an even more interesting example. Its new pricing separates its own orchestration from third-party resources. If customers bring their own provider API keys, they can avoid Clay's Data Credit charge while still consuming Actions for the workflow Clay performs.

The structure keeps the two forms of value separate. The supplier's expensive or volatile resource can be paid more directly, while the application still gets paid for orchestration, workflow, interface and proprietary features.

For a consumer product, making people create API accounts and manage keys would usually be a terrible onboarding experience. For developer tools, data products and enterprise software, BYOK can prevent a handful of massive users from distorting the economics of the entire plan.

How much gross margin should an AI app target?

AI apps need to price from the total cost of serving the customer, because a simple 2x markup on model spend can leave surprisingly little gross margin.

Suppose an AI app charges $100 per month and wants a 70% gross margin. It has $30 available for all direct costs combined. If model inference already averages $20, only $10 remains for search APIs, voice, external data, hosting and any human work tied directly to delivering the service.

A blanket 2x markup on inference produces 50% gross margin before those other costs are included.

Actual AI-company margins show how real this problem is. Bessemer's benchmark of extremely fast-growing AI “Supernovas” found gross margins around 25% on average, with some companies even running negative margins during hypergrowth. Its more SaaS-like “Shooting Stars” averaged around 60%.

Those figures come from different types of companies and should not be treated as a universal target. They show how far AI economics can sit from the 80%+ gross margins people often associate with mature SaaS.

The company should therefore know cost per customer, cost per major workflow and cost distribution across customers. Pricing can then be based on customer value while those figures act as a hard economic constraint underneath.

How much AI usage should a monthly subscription include?

A monthly AI plan should normally cover the vast majority of ordinary customers without making them constantly think about credits.

Clay gives us a rare public benchmark for this. Its current Launch and Growth plans are sized so roughly 90% of customers should stay below their Action limit. Customers who need more can increase capacity instead of immediately changing the entire product tier.

That is a much better starting point than inventing an attractive-looking number such as “1,000 AI credits.”

For a new product, we would first measure the actual usage distribution. The median customer tells us what ordinary use looks like. The 75th and 90th percentiles tell us how quickly usage spreads. The top few percent show how dangerous unlimited pricing might become.

If 40% of customers hit the limit every month, the product will feel like a usage meter wearing a subscription costume. If 99.9% never come close, the allowance may have little economic purpose.

Around the 90th percentile is an interesting starting point when margins allow it: most customers can forget the meter, while genuinely heavy usage still produces additional revenue.

What should happen when customers run out of AI credits?

AI apps increasingly let customers buy extra capacity rather than blocking them or forcing an immediate subscription upgrade.

Cursor lets users turn on on-demand model usage after exhausting the amount included in their plan. ChatGPT now offers purchasable credits for eligible agentic products once normal plan limits are reached, and some users can enable automatic credit reloads. Lovable sells top-up credits separately from the credits delivered by the subscription. Clay also lets customers increase usage capacity without necessarily jumping to another product tier.

Rollover policies solve the opposite problem: customers dislike losing capacity simply because they had a quiet month.

Lovable's monthly plan credits currently expire two months after issuance, while purchased top-up credits last twelve months. Clay treats its two meters differently: Actions reset each billing cycle, but Data Credits can accumulate up to twice the monthly allowance on standard paid plans.

The difference makes sense. Platform capacity resembles a monthly allowance, while purchased credits behave more like money already deposited into the system.

A good AI pricing setup therefore needs somewhere for both sides of usage volatility to go. Customers need room for unusually busy months, and they should not feel punished every time they have an unusually quiet one.

Should one AI credit equal one dollar of model usage?

One AI credit should usually represent understandable product capacity rather than a permanent one-to-one mapping to the company's model bill.

Dollar-linked credits are easy to understand for technical customers. They can also make sense when the application mainly passes through third-party resources.

The drawback appears once the product improves. Imagine an AI research task costs us $0.40 today and we later cut that to $0.08 through caching, better prompts and cheaper model routing. If customer pricing directly mirrors model cost, most of that fivefold efficiency gain automatically leaks into the retail price.

Lovable's task-based credit system gives it more freedom. The user sees that adding authentication consumes more credits than a tiny visual edit. ElevenLabs similarly lets one credit balance fund different types of AI generation at different rates. ChatGPT can use one broader credit system for messages, research, images, agents and voice.

Internally, we still need the dollar ledger. Every workflow should have a measurable expected cost and a distribution around that expectation.

The customer-facing unit can sit one layer higher. Ideally, people learn that a certain amount of credits buys roughly a certain amount of useful work without needing to reverse-engineer our inference bill.

So how should a new app price AI model usage today?

For most new AI apps today, the strongest default is a monthly subscription with plenty of routine AI usage included and a simple credit or usage system for expensive work.

Cheap, repetitive model calls can increasingly disappear into the subscription. Recent model price cuts make that easier than it was even a few months ago. Replit's credit-free Luna mode shows how far this can go when routing and model economics line up.

Once users launch long-running agents, premium models, deep research, computer use or expensive third-party tools, usage should start consuming a meter. Credits usually give customers a clearer experience than raw tokens. Top-ups handle temporary spikes without forcing a permanent upgrade.

If the application eventually owns a result that everyone can measure, the pricing unit can move higher. Intercom can charge for a resolved support issue or qualified lead because customers understand exactly what they bought. Most apps will not have such a clean outcome on day one.

We would therefore price the first version around three layers. The subscription pays for access and normal use. Credits absorb expensive and uneven AI work. Internal cost tracking stays much more detailed than anything the customer sees.

The biggest mistake now would be treating an AI app as a thin reseller of model tokens. Model prices are already falling sharply, routing is becoming more sophisticated, and apps are doing much more than forwarding prompts to one API.

Customers ultimately pay for useful work. The closer the pricing unit gets to that work without becoming confusing or impossible to measure, the stronger the model becomes.