Someone else is paying for it.
On November 2, 2026, Google's Mandiant team published a report called "LLMjacking: Monetizing Compromised Cloud Models." The headline number is the one that got shared: attackers who hijack corporate LLM access can run up more than $100,000 a day in charges, and some victims reached $1 million before they revoked access. Source: The Register
The detail worth a second look is a product. Google's Threat Intelligence Group describes a token routing service called Jet Night that sells an unlimited plan for about $60 a month, with alleged access to frontier models. A comparable consumer service costs $100 to $250. In one case, an intruder made more than 500,000 LLM API calls in under eight hours with stolen third-party API keys to power it. GTIG's conclusion: "the service relies on stolen keys to operate profitably." The service has posted outages on its Telegram channel, which GTIG attributes to victims finding the compromise and revoking keys.
So the story has two victims. One is the company whose key gets burned. The other is the team that, under pressure to cut its AI bill, signs up for a cheap "unlimited" API and sends its prompts through it. This post is for both. It shows how to tell from the price alone that a plan can't be real, what an eight-hour burst costs the key owner, and the legitimate ways to get close to that price.
Cost figures below come from our own illustrative model, built on Anthropic list prices retrieved November 2, 2026 (per million tokens: Opus 5.5 $4 input and $20 output, Sonnet 5.5 $2 and $10, Haiku 5.5 $0.10 and $0.50, cache reads at 0.1x input). They are not measured traces and not Nadir customer data. Mandiant does not say which models Jet Night resold. We price the same usage on one rate card so the math is easy to check.
What the report adds.
LLMjacking isn't new. Sysdig's threat research team named it in May 2024, when attackers used stolen cloud credentials to reach hosted models and resold the access through reverse proxies. We covered the cost side of that era in Denial of Wallet Is the New DDoS, and a single leaked key in $600K in the Noise. The November report adds three things.
- A division of labor. One group gets initial access to cloud and AI accounts. Others, which the report calls "LLM Mixers," run the resale business downstream. Stolen keys are now an input to a supply chain.
- Quieter ways in. A group Google tracks as UNC6993 used a misconfigured service account key to get into a cloud instance, then granted itself access to a model API, created more keys, and enabled services in the victim's projects. Another actor signed victim accounts up for pay-as-you-go access to premium models and used a "burn and rotate" pattern of short-lived service accounts to stay under rate limits. That actor also checked the billing page to see how much damage it was doing.
- A phishing page that skips MFA. A fake application portal for an LLM user group sent users to the real provider site and asked them to paste back a JSON payload. The payload held a live access token, which went straight to the attackers. Password and MFA never came into it.
GTIG's chief analyst John Hultquist expects attackers to put LLMjacking ahead of cryptojacking. A stolen model key is worth more than stolen compute because the victim's provider has already done the hard part: the model is hosted, metered, and ready to resell.
The too-cheap test.
You don't need threat intel to spot a plan like Jet Night. You need a rate card and a calculator. No reseller can sell tokens below what it pays for them for long. A legitimate reseller pays list price minus whatever volume discount it has negotiated. So divide the plan price by the list cost of the usage it sells.
Take one heavy user of a coding or research agent. We assume 8 million input tokens and 120,000 output tokens a day over 22 working days, with 85% of input served from the prompt cache. That's an ordinary agent day: the context is re-read on every turn, which is why input dwarfs output.

| Usage, one user, one month | List cost | $60 plan as a share of list |
|---|---|---|
| Light chat on Sonnet 5.5 (100k in, 25k out a day) | $9.90 | 606% |
| Agent on Sonnet 5.5, cached | $109 | 55% |
| Agent on Opus 5.5, cached | $218 | 27% |
| Agent on Opus 5.5, uncached | $757 | 8% |
A flat $60 plan is honest for a light chat user. Plenty of subscriptions work that way: light users pay for heavy ones. But "unlimited frontier models" is sold to heavy users, and for them the plan lands at 27% of list on cached Opus and 8% if the client doesn't cache. Nobody's volume discount is 73%.

When a price fails this test, the difference comes from one of three places, and none of them is good for the buyer.
- Someone else's key. The Jet Night pattern. The service works until the victim notices, then it goes down, and your traffic goes with it.
- A different model than the one on the label. The "frontier" model is a cheaper model, a smaller quantized one, or a mix. We showed in Same Weights, Different Model how much quality moves between providers serving the same open weights. A reseller swapping the model entirely is harder still to catch.
- Your data as the product. Prompts and outputs get logged and sold or used for training. The plan is cheap because you are the inventory.
A gray-market plan also puts your traffic on the same rails as stolen access. If a provider bans the reseller's keys, or law enforcement takes the service down, your logs and prompts sit on infrastructure you have no contract with.
The check, in code.
Twenty lines. Plug in the plan price and the usage you'd actually send.
PRICE = {"opus": (4, 20), "sonnet": (2, 10), "haiku": (0.10, 0.50)} # $/M in, out
CACHE_READ = 0.1 # cache reads bill at 0.1x the input price
def list_cost(model, input_m, output_m, cached_share=0.0):
"""Monthly cost in USD at list price. Token counts in millions."""
pin, pout = PRICE[model]
fresh = input_m * (1 - cached_share) * pin
cached = input_m * cached_share * pin * CACHE_READ
return fresh + cached + output_m * pout
def too_cheap(plan_usd, model, input_m, output_m, cached_share=0.85, floor=0.70):
cost = list_cost(model, input_m, output_m, cached_share)
share = plan_usd / cost
verdict = "plausible" if share >= floor else "ask who pays the difference"
return round(cost, 2), f"{share:.0%} of list", verdict
# One heavy agent user: 8M input and 120k output tokens a day, 22 working days.
print(too_cheap(60, "opus", 176, 2.64)) # (218.24, '27% of list', 'ask who pays the difference')
print(too_cheap(60, "sonnet", 176, 2.64)) # (109.12, '55% of list', 'ask who pays the difference')
print(too_cheap(60, "sonnet", 2.2, 0.55, cached_share=0)) # (9.9, '606% of list', 'plausible')
The 70% floor is our assumption for the deepest plausible volume discount, not a published rate. Swap in your provider's rate card and your own token counts from a week of logs. If your provider bills cache writes at a premium, add them; we left them out to keep the example short, which flatters the plan.
What eight hours costs the key owner.
Now the other side. Mandiant counted 500,000 calls in under eight hours on one stolen key. The bill depends on what each call carried, which the report doesn't say. So we priced the burst across a range of context sizes, at 500 output tokens a call and no caching, which is how a reseller fanning out unrelated customers' traffic would look.

| Input tokens per call | Opus 5.5 | Sonnet 5.5 | Haiku 5.5 |
|---|---|---|---|
| 2,000 | $9,000 | $4,500 | $225 |
| 10,000 | $25,000 | $12,500 | $625 |
| 20,000 | $45,000 | $22,500 | $1,125 |
| 40,000 | $85,000 | $42,500 | $2,125 |
At agent-sized contexts on a frontier model, one eight-hour shift lands between $25,000 and $85,000. Three shifts make a day, which is how the report's "$100,000 a day" becomes believable. Note what the attacker picks. Nobody steals a key to run the cheapest model. The burst goes to whatever the key can reach that costs the most, which is the opposite of how you'd spend the same budget yourself.
If you're the one being drained.
Mandiant's recommendations are standard: least-privilege identity, a central secrets manager with rotation, and automated secrets scanning in code. Here is the version that maps to the attack paths in the report.
- Don't let service accounts create keys or enable APIs. UNC6993's path was a misconfigured service account that could grant itself model access and mint new keys. Strip those permissions from anything that runs workloads.
- Alert on new keys, new service accounts, and newly enabled model APIs. These are rare events in a healthy project. A burst of short-lived service accounts is the "burn and rotate" pattern.
- Alert on billing-page reads by non-humans. The report's actor audited the billing interface. Your finance team reads it. A workload identity shouldn't.
- Give every app and every agent its own key with its own cap. A cap doesn't cut cost (see Spend Caps Are Not Cost Cuts), but it turns a six-figure incident into a bounded one. Watch each key against its own history, not against the org total, which is where METR's leak hid.
- Treat tokens like passwords in user training. "Paste this JSON to finish signing up" is the new "enter your password here." No legitimate portal asks for a raw access token.
- Route all model traffic through one egress point. If every call leaves through a gateway you control, a key used from anywhere else is an anomaly by definition.
If you're the one shopping.
The demand side of LLMjacking is a team trying to spend less. That pressure is real and it's legitimate. The answer isn't a cheaper reseller. It's paying list price for fewer expensive tokens. Before you sign up for any API reseller or gateway, ask:
| Question | A legitimate answer | A red flag |
|---|---|---|
| Who bills the inference? | The provider, on your own key, or a published list price | "Unlimited," with no rate card |
| Can you bring your own key? | Yes | No, only their pooled keys |
| What model served this request? | Named per request, in a header or log | "Frontier," unnamed |
| Where do my prompts go and for how long? | A DPA and a retention period | A Telegram channel and no terms |
| What happens when your upstream key is revoked? | You never depended on their key | Outages "under investigation" |
| Is the price above the too-cheap floor? | Within a plausible discount of list | 8 to 30% of list for heavy use |
Also check your own house. The buyer is often an engineer with a corporate card, not procurement. Our shadow AI post covers how to find those tools before a breach report finds them for you.
The legitimate way to $60.
Look again at the first chart. The cheapest honest bar for the heavy agent user, $68 a month, isn't a discount. It's the same usage at list price, with most of it sent to cheaper models: in our illustration, half the tokens on Haiku 5.5, 40% on Sonnet 5.5, and 10% on Opus 5.5, with the same 85% cache hit rate. That mix is an assumption to show the mechanism, not a measurement or a forecast. Routing between models also costs some cache hits, since each model keeps its own cache, so a real mix lands a little higher.
The levers that move a bill toward that bar are all on the up-and-up:
- Route per request. Most agent steps are reads, lookups, and formatting. They don't need the top model. See Route the Step.
- Cache the prefix. Keep the system prompt and tool schemas stable so cache reads stay at 0.1x.
- Stop re-reading. Clear old tool results and reasoning from the history. See Forget the Thinking.
- Batch what can wait. Provider batch APIs trade latency for a lower rate on work nobody is waiting on.
Where Nadir fits.
Nadir recommends the lowest-cost model it expects to handle each task. With model="auto" the gateway picks per request, and the model that served each call comes back in an x-nadir-model response header, so you never have to guess what "frontier" meant. On your own keys there is no Nadir fee on any plan, and the provider bills you directly. On Nadir-managed keys, credits draw down at each provider's published list price with no per-request markup, plus a platform fee on credit purchases (5.5% on Pay as you go). Either way, there's no mystery in the price: it is the provider's rate card, applied to fewer expensive tokens.
Routing all traffic through one gateway also gives you the single egress point from the defense checklist above. If you run the self-hosted core, NadirClaw, it adds daily and monthly spend budgets with a warning threshold. Savings depend on your workload, and nothing in this post forecasts yours.
Try Nadir with a free key, or estimate savings from your current spend.
Limitations.
- One illustrative usage profile. Real agent days vary by an order of magnitude in both directions.
- Priced on one provider's rate card. Mandiant doesn't name the models Jet Night resold.
- The 70% plausibility floor is our assumption. Large committed-use contracts can go deeper for specific buyers, but not for a public $60 retail plan.
- Cache write premiums and batch discounts are left out of the examples.
- The routed mix is an assumption, with no quality scoring. It shows where cost can go, not where your quality will hold.
Conclusion.
A price is evidence. When a plan sells heavy frontier-model use at a quarter of list, the gap is paid by a stolen key, a swapped model, or your data, and the November Mandiant report shows the first of those is now an organized business. Run the too-cheap test before you buy, give every key its own cap and its own baseline, and get the bill down the honest way: fewer expensive tokens at list price.
Sources: [The Register, "Token thieves costing companies $100K+ per day in illicit LLM charges," November 2, 2026](https://www.theregister.com/security/2026/11/02/token-thieves-costing-companies-100k-per-day-in-illicit-llm-charges/5306967), reporting Mandiant's "LLMjacking: Monetizing Compromised Cloud Models." [Cloud Security Alliance research note on LLMjacking](https://labs.cloudsecurityalliance.org/research/csa-research-note-llmjacking-black-market-ai-model-hijacking/). [Wiz, What is LLM Jacking?](https://www.wiz.io/academy/ai-security/llm-jacking), on Sysdig's May 2024 discovery. [Anthropic, Pricing](https://claude.com/pricing), retrieved November 2, 2026. Charts were generated with Python and seaborn from the illustrative model described above.