Blog
/
Guides

AI Credit Infrastructure for LLM Products: From Design to Scale

Understand AI credits from pricing to production. Explore credit wallets, ledgers, atomic deductions, grant expiration, and real-time usage controls.

Sara NelissenSara Nelissen
Written by
Sara Nelissen
Last updated
May 20, 2026
read time
9
minutes
What Are AI Credits? Pricing, Examples, and Enforcement

Table of contents

A database counter can tell you how many AI credits remain, but it can't tell you which promotional grant expires tomorrow, whether another agent has reserved the balance, or how much to refund after a failed generation.

This is important when credits become the currency for an AI product. Every request changes the available balance, and each deduction must follow the customer's pricing rules without charging twice or allowing unapproved spending.

This guide covers how AI credits are priced, how a ledger tracks each grant, and how to enforce balances while requests run.

What are AI credits?

AI credits are usage units that customers spend to access AI features such as text generation, image creation, and agent workflows. Each action has a credit cost, which the product deducts from the customer's available balance.

For example, a plan includes 2,000 AI credits per month. Here's how different actions could affect that balance:

AI action Credits used Remaining balance
Starting balance — 2,000
Generate a text response 1 1,999
Create an image 20 1,979
Render a video clip 200 1,779

Illustrative rates. Actual credit costs vary by product.

Customers use one credit balance across multiple AI features, even when those features have different processing costs. Engineering teams define the credit rate for each action and track deductions against the shared wallet.

What determines how many credits an AI action uses?

An AI action's credit cost depends on how the product maps consumption to its internal pricing rules.

Common approaches include:

  • Token-based consumption: Charge credits according to input and output tokens processed by an AI model.
  • Per-action pricing: Deduct a fixed number of credits for each request, generation, or agent operation.
  • Weighted consumption: Apply different credit rates based on model choice, task complexity, or compute requirements.

For example, a product might charge 1 credit for a basic text generation and 10 credits for a premium reasoning model. The customer spends the same currency, while the product applies different rates behind the scenes.

Our token-based pricing guide explains how token consumption becomes a billable usage unit.

Why AI products use credits

AI products use credits to charge for consumption across features with different processing costs. This gives customers a common unit for tracking usage while allowing the product to price individual operations differently.

Consider two customers on the same subscription.

One uses an AI assistant for short summaries, and the other runs autonomous agents that process large documents, call external tools, and generate reports throughout the day.

Their subscriptions may be identical, but their compute costs can differ considerably.

Credits help AI products address three challenges:

  • Different workloads: Expensive models and actions can consume more credits than lightweight requests.
  • Shared allowances: Teams and agents can draw from one account-level balance.
  • Spending control: Products can set hard limits, soft limits, and top-up options around consumption.

The trade-off is additional infrastructure. Once several features share a balance, every deduction needs to be accurate, including when requests overlap or fail.

AI credits pricing and cost breakdown

AI credits cost different amounts depending on the provider, subscription plan, and AI feature being used. Each vendor sets its own credit rates, with some including credits in monthly subscriptions and others selling additional credit packs.

To estimate the cost of credits included in a subscription, use this formula:

Implied cost per credit = Monthly subscription price ÷ Included credits

For example, a $20 monthly plan with 4,000 credits works out to $0.005 per credit. This is an estimated rate, since the subscription may include other features and benefits.

How AI providers price their credits

Adobe Firefly publishes monthly subscription prices alongside generative credit allowances, so we can compare implied rates.

Adobe Firefly plan Monthly price Included credits Implied cost per credit
Standard $9.99 2,000 $0.0050
Pro $19.99 4,000 $0.0050
Premium $199.99 50,000 $0.0040

Prices are subject to change without notice. Always visit the official company websites for the most up-to-date pricing information.

Other providers structure credits differently:

  • Microsoft 365: Eligible subscriptions include AI credit allowances and feature-specific limits, with no single published dollar rate per credit.
  • Google AI: Google AI Pro and Ultra subscribers can buy additional AI credits for extra usage in Google Flow and Google Antigravity, and the number of credits used varies by feature and model.

For AI product teams, the cost of a credit should reflect the compute it represents. A lightweight text request and a complex agent workflow may consume very different resources, even when customers pay using the same credit wallet.

When setting your own rates, account for model costs, expected usage, and margins. Our credit pricing guide covers how to value credits and manage consumption across AI features.

How Adobe, Microsoft, Google, and Miro run AI credit systems

Adobe, Microsoft, Google, and Miro show how AI credits work across different pricing models. Each handles consumption, limits, and credit allocation differently, with useful lessons for engineering teams building their own systems.

1. Adobe generative credits

Adobe combines monthly generative credits with unlimited access to eligible standard AI features.

Credits cover premium operations such as certain video, audio, and partner-model generations. The system needs to distinguish between actions included in the subscription and those that deduct credits.

What engineers can learn:

  • Define consumption rates by feature and model.
  • Check feature eligibility before deducting credits.
  • Reset monthly grants without affecting other access rights.

2. Microsoft 365 AI credits

Microsoft uses two types of consumption controls: monthly AI credits for AI features across Microsoft 365 and Windows apps, and separate limits on how many times specific features can be used.

For example, some features, such as Vision, are capped by how many times they can be used in a set period, while others draw from the monthly AI credit allotment. If a customer reaches a feature limit or uses all of their AI credits, that feature may be unavailable until the allowance resets.

That means the application needs to know which control applies to each feature, the shared credit allowance or a feature-specific limit, before approving an operation.

3. Google AI credits

Google combines included usage allowances with optional credit purchases for supported AI features, including Google Flow and Antigravity.

Customers can purchase additional credits when they need more capacity, and those purchases may have their own expiration dates.

The engineering challenge is managing multiple credit grants:

  • Source: Whether credits came from a subscription or purchase.
  • Expiration: When each grant becomes unusable.
  • Eligibility: Which AI operations can consume the credits.
  • Burn order: Which eligible grant gets deducted first.

4. Miro's AI credit system

Miro introduced AI credits alongside its existing seat-based subscriptions. Monthly allocations depended on seat counts, while separate pools supported trials, production usage, and beta features.

The challenge was applying different credit rules across customers without rebuilding pricing logic each time.

We helped Miro launch its hybrid AI credit model in six weeks using Stigg, with automated allocation and runtime enforcement.

The results included:

  • 5,000 engineering hours saved through reduced infrastructure work.
  • 6x faster deployment of pricing and packaging changes
  • Support for multiple credit pools with different allocation and enforcement policies.

These examples highlight an important design choice, which is that credit systems need rules for how usage is priced, which balances apply, and when consumption is allowed. Those rules determine the ledger and enforcement infrastructure each AI product needs.

What happens when AI credits run out

AI credit depletion policies determine whether customers can continue using a product after exhausting their allowance. Depending on their plan, the application may block new requests, allow approved overages, offer credit top-ups, or restore the allowance at the next billing cycle.

Depletion policy What customers experience Engineering requirement
Hard limit Requests stop when the allowance is exhausted Block unauthorized consumption before execution
Soft limit Eligible usage can continue beyond the available balance Record negative balances or overage consumption
Top-up Customers purchase more credits to continue Grant purchased credits and refresh spending eligibility
Monthly reset Included allowances return at the next billing cycle Issue new grants and apply expiration rules

For example, an AI developer tool might block trial accounts when their credits run out but permit enterprise customers to continue under an approved overage agreement.

The difficult part is enforcing the correct rule while requests are running.

If an agent consumes more credits than expected, the application needs a clear policy for handling the final amount. Blocking future requests will not recover compute already consumed.

Our guide to AI usage control explains the runtime checks behind allowances, budgets, and spending limits.

AI credit rollover and expiration rules

AI credits can roll over or expire based on the provider's policy and credit grant type. Monthly allowances often reset, while purchased and promotional credits may have separate expiration dates.

Policy How it works
No rollover Unused credits expire at the end of the billing period
Limited rollover Credits carry forward for a set period or up to a cap
Grant-specific expiry Each credit grant has its own expiration date

Adobe Firefly's subscription credits reset monthly without rolling over, while Google says purchased AI credits may expire after a period set out when you buy them..

The technical challenge starts when customers hold multiple grants. Say an account has 500 promotional credits expiring tomorrow and 1,000 purchased credits expiring next month.

Under an earliest-expiry-first policy, the next request should consume promotional credits first. The system must track each grant, enforce spending order, and handle concurrent deductions without double-counting.

A single balance counter cannot enforce these rules. Grant-level tracking determines which credits are spent, expired, or still available. Explore our prepaid credits guide for more on expiration policies, credit packs, and top-ups.

How AI credits fit into pricing models

AI credits can be bundled into subscriptions, allocated by plan or seat count, purchased upfront, or billed after consumption.

Each model comes with different rules for issuing credits, tracking balances, and controlling spending:

Pricing model How credits work Best fit
Subscription credits Monthly fee includes recurring credits Products with steady AI usage
Tiered credit plans Higher tiers include larger credit allowances Products with different usage levels
Seat-based credit pools Credits are allocated per seat and shared across an account Collaborative AI products
Prepaid credits and top-ups Customers purchase credits upfront Compute-heavy workloads
Usage-based credit billing Customers pay for approved consumption beyond their allowance AI APIs with variable demand

Subscription credits

The appeal of subscription credits is predictability. Customers pay, for example, $29/month, receive 1,000 credits, and know what their plan covers.

Renewals introduce a few technical decisions. Do unused credits expire? What happens to requests running when the billing cycle ends?

Recurring grants need clear renewal and expiration rules, with runtime checks that prevent expired allowances from funding new workloads.

Tiered credit plans

Moving from a $29 plan with 1,000 credits to a $99 plan with 10,000 gets tricky when someone upgrades halfway through the month.

Giving them another 10,000 credits could be generous. Prorating the difference might make more sense, depending on the contract.

The platform must adjust grants and entitlements at the plan's effective time, preserve consumption history, and prevent duplicate allowances.

Seat-based credit pools

Twenty seats at 500 credits each gives an AI collaboration team 10,000 credits to share. Now five employees launch agents that draw from the same balance.

Without concurrency controls, multiple requests can pass the balance check and overspend the account. Atomic deductions protect the shared pool, and per-user budgets can also prevent one employee's agents from consuming the team's entire allowance.

Prepaid credits and top-ups

Prepaid credits suit customers whose AI workloads come in bursts. A developer might purchase $50 in credits for testing, then add another $100 before running a large batch.

Each purchase creates a separate grant, potentially with its own expiration date.

Which credits should the next request consume? Grant-level tracking and spending priorities determine the deduction order, while purchase events update the available balance.

Usage-based credit billing

What if a customer's workload exceeds the credits included in their plan, but stopping the job would cause more trouble than the extra charge?

An AI API could include 2,000 credits and bill another 1,500 as overage when consumption reaches 3,500.

Approved overages require request-time eligibility checks, spending caps, and billable usage records. Contract rates determine the final invoice amount.

A product can combine these approaches by offering subscription credits alongside prepaid top-ups and approved overages. The runtime must apply the correct spending policy across every credit source.

The building blocks of an AI credit system

An AI credit system combines wallets, grants, consumption rates, a ledger, and request-time enforcement. Each component has a separate responsibility, but they must agree on the customer's available balance.

Component What it does What can go wrong
Credit wallet Represents credits available to a customer or account Incorrect available balance
Credit grant Records issued credits, eligibility, and expiration Credits expire or burn incorrectly
Consumption rates Converts AI actions into credit deductions Different services apply different rates
Credit ledger Records grants, deductions, and adjustments Missing audit history or duplicate charges
Runtime enforcement Approves, blocks, or reserves usage Requests exceed allowed spending
Usage metering Captures actual operations and consumption Missing or duplicate usage events

Consider an AI image-generation request. The product checks feature access, calculates the credit cost, and confirms spending eligibility before execution. Once generation finishes, it records actual usage and settles any reserved credits.

The available balance must account for completed usage, active reservations, and grant rules, especially when multiple agents launch requests at the same time.

How the AI credit ledger works

An AI credit ledger tracks every credit grant, deduction, expiration, refund, and adjustment. It gives teams a reliable record of where credits came from, how they were spent, and why a customer's balance changed.

Each credit grant needs several key details:

  • Grant identity: Unique ID and credit source.
  • Credit quantity: Credits issued and remaining.
  • Validity period: Effective and expiration dates.
  • Category: Eligible features or workloads.
  • Cost basis: Financial value of the credits.
  • Burn priority: Order in which eligible grants are consumed.

A customer gets 1,000 credits from their subscription and buys another 500. Their dashboard shows 1,500 credits, but the ledger tracks both amounts separately because subscription credits may expire before purchased credits.

Burn order determines which credits get spent first. A product might consume the earliest-expiring grant before touching purchased credits, which helps customers use credits before they expire.

Every deduction must follow the same policy, even when multiple agents spend credits at once. An append-only ledger preserves the transaction history so it’s possible to trace consumption, correct balances through new entries, and reconcile credit activity with billing records.

Where AI credit systems break under concurrent usage

AI credit systems risk overspending when multiple agents draw from the same balance at once.

An account has 100 credits left, and two agents each request 80 credits and check the balance before either deduction completes. Both proceed, authorizing 160 credits against an available 100.

Atomic reservations prevent double-spending by securing credits before execution. Other failures need their own safeguards.

Failure Risk Protection
Concurrent deductions Overspending Atomic reservations
Duplicate events Double charges Idempotency keys
Failed operations Locked credits Reservation release
Delayed usage reports Outdated balances Request-time checks
Inconsistent rates Incorrect deductions Versioned rates

After execution, settlement records the final cost and releases unused reserved credits. If consumption exceeds the estimate, the system applies the configured overage policy.

How to enforce AI credits in real time

Real-time AI credit enforcement determines whether a customer can afford an AI operation before it runs. The system checks entitlements, reserves credits when needed, and settles the final cost once usage is known.

Here's how the process works in production.

1. Check entitlements and spending limits

Every request starts with an account, a feature, and a set of usage rules. The system checks whether the customer can access the selected model, how many credits remain, and whether a hard or soft limit applies.

A customer might have access to a premium reasoning model but lack enough credits to run another expensive request.

2. Reserve credits before execution

AI costs aren't always known upfront. A request estimated at 20 credits might end up costing 14 or 25.

The application can reserve 20 credits before execution by using atomic operations to prevent concurrent requests from claiming the same balance. Requests without sufficient credits follow the account's depletion policy.

3. Run the operation and calculate usage

Once approved, the model or agent runs while the application captures token counts, model usage, and other billable activity.

The rating logic converts that usage into credits using the applicable rate version. A 20-credit estimate might become a final charge of 14 credits.

4. Settle the final balance

The system deducts the 14 credits and releases the remaining six. If consumption exceeds the reservation, the configured spending policy determines how to handle the difference.

Failed requests and retries need special handling. Reservation releases follow the product's billing rules, while idempotency keys prevent duplicate charges.

5. Record consumption and update balances

Each completed operation produces a usage record and ledger entry. Customers can track their remaining credits, while finance teams can reconcile consumption with billing.

Multi-step AI agents make request-time checks especially important. An agent might have enough credits to start a task but exhaust its allowance after several model calls. Each billable step needs its own spending decision before more compute is consumed.

How AI credits affect revenue recognition

Paid AI credits can create deferred revenue obligations when customers purchase credits before using the service. Revenue recognition depends on contract terms, consumption, and applicable accounting standards.

Finance needs accurate records from the credit ledger to track these obligations.

Record Why it matters
Grant source and value Distinguish paid, included, and promotional credits
Cost basis Link consumption to financial value
Usage transactions Trace credits spent
Expiry and rollover Track unused credits and potential breakage
Refunds and adjustments Reconcile balance changes

A customer purchases 10,000 credits for $100, giving each credit an implied value of $0.01. After consuming 4,000 credits, the ledger should show which grant funded the usage and what remains.

Finance uses those records to assess revenue recognition and outstanding obligations. Spending 40% of the credits doesn't always mean recognizing 40% of the revenue. Contract terms, performance obligations, and expiration policies can affect the calculation.

Grant-level tracking gives finance the transaction history needed to apply the correct accounting treatment.

Build vs. buy AI credit infrastructure

A credit balance seems easy enough to build. Store the number, deduct credits after each request, and block usage when the balance reaches zero.

Then a customer buys a top-up while three AI agents are running. One request fails, another exceeds its estimated cost, and the customer's monthly credits expire at midnight.

Now your team needs to handle:

  • Credit grants: Expiration, rollover, top-ups, and spending order.
  • Concurrent usage: Atomic deductions and reservations across agents.
  • Entitlements: Plan limits, add-ons, and contract overrides.
  • Recovery: Failed requests, retries, and balance reconciliation.
  • Reporting: Usage history, spending alerts, and financial records.

Each new pricing rule brings more edge cases to test, and the maintenance work can grow faster than the original implementation.

The decision comes down to what your team wants to own. If your credit rules rarely change, building may be reasonable. If engineers are spending their time fixing balance discrepancies and updating entitlement logic, buying deserves serious consideration.

Put AI credits to work with Stigg

An AI agent doesn't wait for your billing system to catch up. It can launch multiple model calls, consume hundreds of AI credits, and exhaust a customer's allowance while usage events are still being processed.

Stigg puts credit enforcement where those costs happen: inside the application request path. Your team can authorize spending, deduct credits across shared wallets, and stop requests that exceed the customer's allowance.

Here's what your team can manage with Stigg:

  • Grant-level credit tracking: Manage paid, included, and promotional credits with expiration dates, cost basis, categories, and burn order.
  • Real-time credit deductions: Apply deductions as usage is reported and use idempotency keys so retries don’t charge twice.
  • Request-time spending limits: Enforce hard limits, approved overages, and entitlement rules before expensive operations run.
  • Shared credit wallets: Control usage across organizations, workspaces, users, and AI agents.
  • Low-latency checks: Run the Stigg Sidecar alongside your application to serve cached entitlement checks instantly. Cache misses are fetched from Stigg’s Edge API, typically in around 100ms.
  • Existing billing integrations: Connect with Stripe, Zuora, or your in-house billing system while keeping credit enforcement close to the application.
  • Flexibility with deployment: Run usage metering in your own VPC through BYOC (currently in early access) for infrastructure and data residency requirements.

Your engineers can focus on building AI features while Stigg handles who can spend credits, which grants get consumed, and when usage must stop.

Want to see how those decisions work inside an AI request? Stigg's documentation walks through credit management and runtime enforcement.

Frequently Asked Questions

1. How much do AI credits cost?

AI credit prices vary by provider and the type of generation. Adobe Firefly Standard costs $9.99/month for 2,000 credits, equivalent to about $0.005 per included credit. The number of credits consumed depends on the AI feature used.

2. How many AI credits do I get?

Your AI credit allowance depends on the plan. Adobe Firefly Standard includes 2,000 monthly credits, while Pro includes 4,000. Other platforms may offer larger allowances, shared credit pools, or prepaid packs.

3. What happens when you run out of AI credits?

Running out of AI credits can stop new requests, trigger a top-up option, or allow approved overages. The product’s depletion policy determines whether usage continues or pauses until credits renew.

4. Do AI credits roll over or expire?

AI credits often expire at the end of their billing period, though some providers allow rollover. Adobe Firefly’s monthly credits reset each billing cycle and don’t roll over, while Google says purchased AI credits may expire after a period set when you buy them.

5. What is the difference between AI credits and usage-based pricing?

The main difference between AI credits and usage-based pricing is how consumption is measured and charged.

AI credits assign a common unit to different AI operations, while direct usage-based pricing charges for tokens, API calls, or compute time. A usage-based model can also charge customers through credits.

6. Are AI credits real money?

AI credits aren’t money, but they usually stand in for money a customer has already paid. A product sells or bundles credits at a set price, so each credit carries an implied value. 

For example, 10,000 credits bought for $100 works out to $0.01 per credit. Paid credits bought before use can create deferred revenue obligations for the product, and unused credits may expire under the provider’s rollover rules.

Latest news.

One email per month.
From engineers, for engineers.

Thank you! Your submission has been received.
Oops! Something went wrong while submitting the form.