TL;DR: Token fraud is any AI compute consumed outside the economics you priced. Some of it nobody pays for, some of it someone else pays for, and some of it is paid at a price you never offered. It happens because identity, payment, usage and the ledger run on different clocks, and most stacks enforce from billing data after the GPU has already spent. The fix is architectural: treat credits as money, reserve before compute and settle after, and put one entitlement check on every path to the GPU.
****************
A few days ago, I had a call with a growth leader at one of the fastest-scaling AI companies out there. Before that, he spent years running self-serve monetization at one of the biggest SaaS companies in the world. I asked him what keeps him up at night.
He named three things: COGS, pricing and packaging, and fraud. At his last company those were three separate conversations. Here they are one conversation, with data, finance, growth and the CEO all in the room.
Then he said the line that made me write this post: “It's actually people who will come in with the nicest card and steal your compute.”
That isn't payment fraud. The card is good and the payment clears. The fraud happens after, in the runtime, where the GPU does the work and nothing checks whether that work will ever be paid for.
The numbers back him up. Stripe's data shows AI startups faced up to 4.3x the attempted transaction fraud rate of startups overall in Q3 2025. As card fraud got harder, fraudsters moved upstream: attempted multi-account abuse at AI subscription companies rose 40% in the first half of 2026, and 154% at the most-targeted ones.
I've been saying for a while that every AI company is accidentally building a bank. Credits are deposits, tokens are the currency, and the GPU is the vault. Banks get robbed, and most AI companies run theirs with the security model of a SaaS signup form.
Fraud vendors have started to name this. Sardine published a sharp lifecycle breakdown this week, and Stripe put numbers on it last month. Both look at it from where they sit, identity and payments, so this post is the other half: the ledger and the runtime, where the compute actually leaves the building.
What token fraud is
Token fraud is any consumption of AI compute outside the economics you priced. It comes in three flavors:
Compute nobody pays for. Farmed free tiers, promo loops, overdrafts, and usage that never reaches the ledger.
Compute someone else pays for. Stolen cards, leaked API keys, hijacked cloud accounts.
Compute paid for at a price you never offered. A flat consumer plan sitting behind a proxy, serving a whole fleet as wholesale API capacity.
The third flavor is the one most teams miss, because no payment system will ever flag it. The money is real. The usage is the fraud.
Three properties separate token fraud from anything SaaS dealt with before:
Marginal cost is real. A fake account in classic SaaS costs you a database row. In AI it costs GPU time on every request.
Delivery is instant and final. The output ships in seconds, and no refund or chargeback brings the compute back.
The asset is liquid. Tokens, keys and accounts resell, and Sardine points to underground resellers offering AI access at 70-90% off list price.
The cleanest mental model I've found: token fraud is clock arbitrage. Every AI company runs four clocks that don't tick together. The identity clock decides who you are, and the payment clock authorizes, settles and keeps a dispute window open for months.
The usage clock starts with the request and stops when the run ends. The ledger clock meters, aggregates, debits and locks. Card fraud lives in one gap, between authorization and chargeback, but an AI product has a gap between every pair of clocks.
How AI token fraud differs from e-commerce payment fraud and classic SaaS abuse
What differs
E-commerce payment fraud
Classic SaaS abuse
AI token fraud
What gets stolen
Shipped goods
Seats and features
GPU time, the moment it runs
Cost per abusive user
Cost of goods
Close to zero
Real, on every request
Payment to delivery
Hours to days
Instant
Milliseconds
Can you claw it back
Sometimes
Revoke access
No, the output is gone
Resale value
Goods resell
Low
High, and global
Who catches it
Payments risk team
Usually nobody
Identity, payments and the runtime, together
Six ways it shows up
Every self-serve AI product meets these six eventually. They're archetypes, not edge cases, and the same ring often plays several of them.
1. The farmer. Free credits are granted per account, so the farmer makes accounts. Stripe found a single user behind more than 86,000 accounts at one AI company, without a single legitimate payment (via Sardine). Rings run residential proxies, disposable emails, virtual cards and, more and more, agents that fill in signup forms.
Some farmers want your model, not your compute. Anthropic reported three AI labs generating more than 16 million exchanges with Claude through about 24,000 fraudulent accounts, a textbook distillation attack.
2. The reseller. Gets access cheaply, by farming it or by paying with stolen cards, then sells it at a discount on secondary markets or into regions you don't serve. The reseller's margin is your COGS. By the time the real cardholder disputes the charge, the access is already sold.
3. The key thief. Never logs in. An API key is a bearer instrument, so whoever holds it spends, and keys leak from repos, mobile apps, container images and third-party tools. In October, OpenCode told users that the OpenAI, Anthropic and Google keys they stored with it may have been accessed.
The industrial version is LLMjacking: stolen cloud credentials, a reverse proxy in front, access resold to other criminals. Sysdig put one victim's worst case at over $46,000 a day.
4. The nicest card. Passes every payment check, because the payment is legitimate. The abuse lives in consumption: one flat plan shared across a fleet, piped through a proxy, or pointed at the most expensive model you serve. Your payments stack can't see it, because there is no payment anomaly to see.
5. The overdrafter. Exploits the time between spending and debiting. One SaaS company we work with ran a bug bounty, and a researcher burned roughly 200 credits on a 50-credit free plan with a single long agent run.
The credits were only deducted when the task finished. Parallel calls at the last credit, and balances that keep spending until a cached lock catches up, are the same trick.
6. The hole-finder. Finds a path to your GPUs that never touches the ledger. A billing lead at a hyper-growth AI model platform told us they estimated about a million dollars a year leaked because they couldn't lock accounts fast enough.
The number dropped sharply once they fixed a marketplace integration that never wrote usage to their credit ledger. It was a side door, and 32,000 trial accounts had walked through it (Anton wrote it up).
Nobody knows whether a person or an agent found that hole first. It doesn't matter: agents are now the baseline user, and they're starving for tokens.
Why it happens: you priced compute like software
AI companies inherited the SaaS growth playbook: free tiers, trials, promo credits, referral bonuses, flat plans. That playbook assumed the marginal user costs nothing. In AI, every one of those levers is a liability you issue to the entire internet.
Four forces make it worse:
Growth runs on giveaways. Everyone is early, everyone runs campaigns and discounts to grow fast, and every campaign brings bad actors with it. Pricing and packaging is now a fraud control, whether you designed it as one or not.
Compute is liquid. Tokens resell at a discount, demand is global, and there are whole regions where your product isn't sold. That's a grey market waiting for supply.
You go global on day one. The growth leader pointed out that the AI companies doing well have India as their second or third market, which never happened in SaaS. New markets bring new payment methods, more PSPs and patterns your fraud models have never seen.
Agents want tokens. Demand for tokens is close to unbounded, and agents don't get tired, don't feel guilty and probe every path. As Anton put it, developers are desperate for tokens these days.
Fraud also moves like water, toward the layer with the least enforcement. Stripe watched it happen: attempted transaction fraud at AI startups fell from 4.3x to 2.6x the startup average by Q1 2026, and the pressure shifted to multi-account and free-trial abuse.
And nobody owns it. When fraud, COGS and pricing are one problem, it belongs to data, finance, growth and the CEO at once, which in practice means the runtime belongs to no one.
What allows it: enforcement that runs after the money is gone
Billing tells you what happened. It can't decide what's allowed. Most AI stacks enforce from billing-shaped data, so they discover fraud the way you discover a bad quarter: after it's over.
Seven structural gaps show up again and again:
Cached locks. The balance lives in the billing system, which is too slow for the hot path, so teams cache an account-locked flag. One billing lead walked us through exactly this setup: an account-level flag, a short cache, one central gateway. The cache TTL is your fraud budget.
Settle-after-run. Debiting when a task ends instead of reserving when it starts. Long runs overdraw by design.
Async meters doing a sync job. Metering pipelines built for invoices are high-throughput and eventually consistent. Great for billing, useless for stopping a request.
Read-then-write balances. Two concurrent requests both see credit available before either one debits. Agents fan out, so the last credit gets spent many times over.
Side doors. Marketplaces, partner channels, internal keys, retries, support grants. Every path to the GPU that doesn't cross the ledger is a free tier you didn't design.
Bearer keys with no budget. A key that can spend without limit, on any model, from anywhere, forever.
Signals in silos. Identity sits in one tool, payments in another, usage in a third. The farm, the stolen card and the leaked key are often the same ring, and no single system sees all three.
What it costs: financial, compliance and security risk
Token fraud hits three ledgers at once: the P&L, the compliance file and the security posture. Most teams only measure the first.
Financial
COGS you never collect. At AI gross margins, a few points of leakage is the difference between a path to margin and a story about one.
Chargebacks cost you three times. You refund the payment, pay the dispute fee, and you already paid for the compute. Pile them up and processors raise fees, hold reserves or close the account.
Forecasts trained on fraud. Farmed accounts inflate signups, activation and usage, so you end up setting prices from numbers fraudsters wrote.
A wrong balance sheet. Unused prepaid credits are a liability. Fraudulent grants and reversed purchases corrupt deferred revenue and revenue recognition unless every credit has provenance.
Capacity you can't sell. Abusive load eats rate limits and GPUs that paying customers need. Sysdig notes that an attacker maxing out quotas can lock the victim out of its own models.
Compliance
Card network programs. High fraud and dispute ratios land you in the networks' monitoring programs, with fines and, eventually, lost card acceptance.
Sanctions and export controls. Resellers route your models into places you aren't allowed to serve. You become an exporter by proxy.
Stored value. The closer credits get to cash (transferable, refundable, redeemable), the closer you get to stored-value and money-transmission questions. It's one reason credits are usually non-transferable.
Audit trail. Recognizing revenue on prepaid credits means tracing every credit from grant to consumption. A fraud reversal with no provenance is an audit finding waiting to happen.
Security
Keys are hunted at industrial scale. Anthropic's September 2026 threat report describes a group that downloaded 1.8 million Android apps to scan them for embedded AI keys (via Sardine).
Attackers avoid your logs. In the original LLMjacking case, attackers checked whether model-invocation logging was on, and the open-source proxy tied to the attack refuses keys with logging enabled.
Your model is the prize. Distillation turns your outputs into someone else's training set.
Blast radius compounds. Gateways, coding tools and aggregators hold their users' keys and their own provider keys, so one breach leaks both.
Common attack vectors
Every vector below exploits a gap between two clocks. The last column is the first control I'd ship, not the only one.
Common token fraud attack vectors, the gap each exploits, and the first control to ship
Vector
How it works
Gap it exploits
First control
Multi-account farming
Scripted signups claim per-account free credits
Credits granted before identity is resolved
Grant credits in stages; link accounts by device and network
Referral and promo loops
Self-referrals and stacked codes mint credits
Grant logic with no ceiling
Vest referral credits after the referee pays; cap every campaign
Card testing and stolen cards
Small top-ups validate cards; bigger ones buy credits to resell
Credits spendable before payment risk resolves
Risk-score top-ups; low limits on first purchases; 3DS step-up
Consume, then dispute
Burn the credits, then file a chargeback
A dispute window that outlives the compute
Spend limits that grow with payment age
Leaked API keys
Keys scraped from repos, apps, images and third-party tools
A bearer key with unbounded spend
Per-key budgets, scopes, IP allowlists, rotation
LLMjacking
Stolen cloud credentials behind a reverse proxy, access resold
Cloud spend with no product-level budget
Least privilege, invocation logging on, budget alerts
Plan sharing and resale
One flat plan serves a fleet through a proxy
A plan priced for one human, used by many
Per-seat concurrency and velocity limits; sharing signals
Model arbitrage
A cheap plan routed to your most expensive model
Request cost never checked against plan economics
Model allowlists per plan; cost-weighted credits
Long-run overdraft
A long job starts on a small balance; the debit lands at the end
Usage clock runs ahead of the ledger clock
Reserve the maximum cost at start; settle actuals at the end
Concurrency race
Parallel calls at the last credit all see a balance
Spending continues after the balance goes negative
Ledger ahead of a cached enforcement flag
Check limits in the request path; overdraft only by policy
Side-door channels
A marketplace or partner path never writes usage
A path to the GPU that skips the ledger
One entitlement check on every path; daily COGS reconciliation
Refund and retry abuse
Force failures to get credits back while keeping the output
Credit-backs with no provenance
Credit-backs as ledger entries with reasons; refund only undelivered work
Distillation
High-volume prompting to train a competing model
Abuse that looks like your best customer
Baselines on prompt patterns; volume gated by trust
The engineering playbook: enforce before, settle after
The fix isn't one more fraud model. It's an architecture where nothing reaches the GPU unless the runtime has already agreed it will be paid for. Here's the playbook I'd hand any team shipping AI to the public.
Every request crosses the same eight controls: four that decide before the GPU spends, and four that make the books match after.
The hot path decides before the GPU spends; the settle path makes the books match after. Most token fraud lives in requests that skip the first row or never reach the second.
1. Treat credits as money, not a counter
A mutable balance column has no memory of how it got there. Use an append-only, double-entry ledger where the balance is the sum of entries, and every entry records who, when, why and how much.
Keep grant types apart (paid, promotional, contractual), each with its own cost basis and expiry. A fraud reversal then becomes one more auditable entry, not a database edit.
2. Reserve before compute, settle after
Borrow authorize-and-capture from card payments. Before the model runs, reserve the maximum possible cost of the request against the balance. After it runs, settle the actual usage and release the rest.
The estimate is the authorization envelope, not the bill. This one pattern kills long-run overdrafts and most negative balances, and it turns every run's maximum cost into a decision instead of a surprise.
3. Make the balance impossible to race
Serialize writes per wallet and debit atomically; never read, then write. Holds count against the available balance the moment they're placed, so fifty parallel agent calls see the true remainder. Every usage event carries an idempotency key, so a retried settle never charges twice.
4. Close the lock-latency window
If enforcement reads a cached flag, the cache TTL is your fraud budget, so write it down and own it. Evaluate limits in the request path against the live balance. If you allow overdraft, make it an explicit credit decision per segment, the way a bank sets a credit line.
The fear behind slow locks is real: a false-positive lock breaks customer trust, as that same billing lead told us. The answer is precise tiers, a notification at the soft limit and a stop at the hard one, not a lock that arrives late.
5. Make every path to the GPU cross the same check
Inventory every entry point: app, API, SDKs, marketplaces, partner and OEM channels, internal tools, eval jobs, retries and support grants. One entitlement check, one ledger, no side doors.
Then reconcile daily: what you paid model providers or GPUs per account, against what the ledger debited per account. The difference is your leakage rate, and it should page someone when it drifts.
6. Give every key a budget and a blast radius
Scope keys to a project or subject, with spend caps per time window, model allowlists, rate and concurrency limits, IP allowlists and an expiry. Enterprise buyers already ask for this: that billing lead described customers setting daily limits per API key that either notify or lock.
Baseline each key's geography, volume, model mix and hours, and step limits down on anomalies before you revoke. When a key shows up from an IP it has never used, Sardine's CEO suggests revoking it and forcing a fresh login, because a login gives you a browser to fingerprint.
7. Price and package like a risk team
Grant free credits as an earn-in: a little at signup, more after verification, more after the first payment.
Keep trials on cheaper models, and open premium models only after some payment history.
Vest referral credits only after the referee pays.
Give new accounts a spend limit that ramps with trust, like a credit line instead of an open tab.
Ship every campaign with a cap, an expiry and a kill switch.
8. One view, one decision point
Your PSP and your fraud vendors score identity and payments, so let them. Feed those scores into the runtime as inputs to entitlements, so risk changes limits instead of only blocking signups. Fraud tools tell you who someone is; the runtime decides how much they can spend.
9. Measure leakage like a CFO
Metrics for measuring token fraud leakage
Metric
What it tells you
Unbilled compute ratio
Provider or GPU cost not matched by ledger debits
Time to enforce
How much gets spent after a limit is breached
Negative balance exposure
Credit you extended without ever deciding to
Promo burn by channel
What free credits cost you, per acquisition source
Compute per disputed dollar
What each chargeback really cost
First-week usage share
How much compute goes to accounts in their first week
Build the vault door
Token fraud is the tax on running a bank by accident. You can pay it in COGS, chargebacks and forecasts you can't trust. Or you can design for it: credits as money, a reserve before compute runs, and one check on every path to the GPU.
The controls that stop fraud are the same ones that make pricing changes safe, enterprise budgets enforceable and margins predictable. You're not building a fraud system. You're building the financial core of an AI company, and fraud is its stress test.
That's the layer we build at Stigg. Billing tells you what happened; Stigg decides what's allowed, before the GPU spends a cent.
If you’re fighting token fraud in production, come compare notes in HTTP 402, our community for engineers building monetization infrastructure, or talk to us. For the deep dives on ledgers, holds and settlement, read my co-founder Anton’s The Financial Engineer.⁹