Google Threat Intelligence has published a report on LLMjacking: stealing credentials for large language model services and either using or reselling the access, with the bill going to whoever owned the key.
The figures it carries, as published:
- Individual incidents produced fraudulent charges exceeding $100,000 in a single day.
- Cumulative charges at some organisations reached $1 million before access was revoked.
- One actor made more than 500,000 API calls in under eight hours, passing nearly $1 million in token costs to the victim.
Work that last one. Five hundred thousand calls across eight hours is about 17.4 calls per second, sustained, for a working day. And a million dollars spread over half a million calls averages about two dollars a call, which tells you something the report does not say directly: this was a frontier model being driven with large contexts, not a cheap one being hammered.
The price is the evidence
The most useful thing in the report is not an incident. It is a price list.
A service called Jet Night advertised an unlimited plan at about $60 a month with claimed access to frontier models. Google notes that typical consumer pricing for comparable access is $100 to $250 a month, and assesses that the service depends on stolen keys to remain profitable.
That is an elegant piece of analysis and worth understanding as a method. You do not need to compromise the seller or trace a payment. You only need to observe that they are selling below the wholesale cost of the input. Nobody resells at a loss at scale. If the retail price of the underlying commodity is higher than the all-you-can-eat resale price, the commodity was not bought.
Google describes the surrounding machinery as LLM mixers: gateways that proxy, pool, meter and resell stolen access to subscribers, built on tools like model hubs and CLI-to-API proxies. One relay on lookalike domains fed a resale ecosystem that drained victim quotas to serve paying customers. There is a division of labour, with access brokers selling pre-validated keys to separate operators who run the monetisation side.
That is not improvised crime. That is a supply chain with specialists in it.
Two techniques worth knowing by name
Validation with a token limit of one. Before using a stolen key, sweep it with a request whose maximum output is set to a single token. The call succeeds or fails, which is all you need to know, and it generates almost no billable volume. If your detection for stolen credentials is a spend anomaly, this technique is specifically designed to pass under it. The attacker learns the key is live; your billing alert learns nothing.
Burn and rotate. Short-lived service accounts, used hard and discarded before rate limits engage. One actor's entire pattern was creating accounts, exhausting what they could, and moving on.
Between them these defeat the two controls most organisations actually have: a monthly spend alert and a per-key rate limit.
Why the victim often cannot tell you what was taken
This is the part that connects to something we wrote about earlier this month. When Railway disclosed its incident, it could not say which secrets had leaked, and the reason was envelope encryption: the architecture that protects the secrets also prevents the operator from enumerating which ones were accessed. Railway recorded about $740,000 of unauthorised AI spend and said AI provider keys were the primary target.
The same property shows up across these incidents. Quota is pooled, keys are abstracted behind a gateway, and the logs record that the gateway made calls rather than which credential was behind each one. So the victim sees the bill clearly and the blast radius not at all.
How they got in, which is the boring part
Google's answer is almost disappointingly ordinary. The dominant vector is exposed or stolen cloud identity credentials: IAM credentials, service account keys, GitHub personal access tokens, active session tokens. Plus API keys harvested from public GitHub repositories, and publicly exposed endpoints where actors probe for open model services and in some cases register their own models.
Targeted providers include Amazon Bedrock, Google Cloud's model endpoints, Azure Cognitive Services, and self-hosted gateways and runtimes.
There is no clever new exploit here. There is a key in a repository, and a market that pays for it.
What to do
- Treat a model provider key as a payment instrument, because that is what it is. The budget is the blast radius.
- Set hard spend caps at the provider, not alerts. An alert fires after $100,000 in a day. A cap does not let the day happen.
- Alert on call rate and model selection, not only on cost. Seventeen calls a second against a frontier model is visible immediately and cost is visible in arrears.
- Watch for validation sweeps: many distinct keys tried once each, trivially small responses, from one source.
- Scan your own public repositories for keys, then rotate and revoke sessions, because a session minted from a key outlives the key.
What is not established
- Google gives no incident count, no market size and no growth rate. The report describes incidents it responded to in 2026 across North America, South America and Asia Pacific, in financial services, retail, technology and transportation, and does not quantify the phenomenon.
- The Jet Night unit economics are Google's inference from advertised pricing, not verified financials, and the report says so.
- Whether the $1 million figure and the 500,000-call figure describe the same incident. They are presented separately and we have not assumed they are one.
- Google's expectation that attackers will increasingly prefer this to cryptojacking is a forecast, not a measurement.


