Blog
/
Engineering

Token Fraud: The Nicest Card on the Internet Is Stealing Your Compute

A field guide to AI token fraud: what it is, how it shows up, why it happens, what it costs, and the engineering that stops it.

Dor SassonDor Sasson
Written by
Dor Sasson
Last updated
November 16, 2026
read time
10
minutes
AI Token Fraud: How It Happens and How to Stop It

Table of contents

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 differsE-commerce payment fraudClassic SaaS abuseAI token fraud
What gets stolenShipped goodsSeats and featuresGPU time, the moment it runs
Cost per abusive userCost of goodsClose to zeroReal, on every request
Payment to deliveryHours to daysInstantMilliseconds
Can you claw it backSometimesRevoke accessNo, the output is gone
Resale valueGoods resellLowHigh, and global
Who catches itPayments risk teamUsually nobodyIdentity, 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:

  1. 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.
  2. Settle-after-run. Debiting when a task ends instead of reserving when it starts. Long runs overdraw by design.
  3. 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.
  4. 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.
  5. 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.
  6. Bearer keys with no budget. A key that can spend without limit, on any model, from anywhere, forever.
  7. 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
VectorHow it worksGap it exploitsFirst control
Multi-account farmingScripted signups claim per-account free creditsCredits granted before identity is resolvedGrant credits in stages; link accounts by device and network
Referral and promo loopsSelf-referrals and stacked codes mint creditsGrant logic with no ceilingVest referral credits after the referee pays; cap every campaign
Card testing and stolen cardsSmall top-ups validate cards; bigger ones buy credits to resellCredits spendable before payment risk resolvesRisk-score top-ups; low limits on first purchases; 3DS step-up
Consume, then disputeBurn the credits, then file a chargebackA dispute window that outlives the computeSpend limits that grow with payment age
Leaked API keysKeys scraped from repos, apps, images and third-party toolsA bearer key with unbounded spendPer-key budgets, scopes, IP allowlists, rotation
LLMjackingStolen cloud credentials behind a reverse proxy, access resoldCloud spend with no product-level budgetLeast privilege, invocation logging on, budget alerts
Plan sharing and resaleOne flat plan serves a fleet through a proxyA plan priced for one human, used by manyPer-seat concurrency and velocity limits; sharing signals
Model arbitrageA cheap plan routed to your most expensive modelRequest cost never checked against plan economicsModel allowlists per plan; cost-weighted credits
Long-run overdraftA long job starts on a small balance; the debit lands at the endUsage clock runs ahead of the ledger clockReserve the maximum cost at start; settle actuals at the end
Concurrency raceParallel calls at the last credit all see a balanceRead-then-write balance checksAtomic per-account debits, holds, idempotency keys
Lock latencySpending continues after the balance goes negativeLedger ahead of a cached enforcement flagCheck limits in the request path; overdraft only by policy
Side-door channelsA marketplace or partner path never writes usageA path to the GPU that skips the ledgerOne entitlement check on every path; daily COGS reconciliation
Refund and retry abuseForce failures to get credits back while keeping the outputCredit-backs with no provenanceCredit-backs as ledger entries with reasons; refund only undelivered work
DistillationHigh-volume prompting to train a competing modelAbuse that looks like your best customerBaselines 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.

Diagram of an AI request path. The hot path runs synchronously before the GPU spends: authenticate key, score the actor, check and hold, run the model. The settle path runs asynchronously after the run: meter usage, settle the hold, write the ledger, reconcile COGS. Each step lists the token fraud it stops.
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
MetricWhat it tells you
Unbilled compute ratioProvider or GPU cost not matched by ledger debits
Time to enforceHow much gets spent after a limit is breached
Negative balance exposureCredit you extended without ever deciding to
Promo burn by channelWhat free credits cost you, per acquisition source
Compute per disputed dollarWhat each chargeback really cost
First-week usage shareHow 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.⁹

‍

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.