TL;DR
Mandiant investigated 2026 attacks in which criminals used stolen cloud credentials and AI keys to run models at someone else’s expense. Some incidents generated over $100,000 in reported charges in one day.
A budget alert can tell you costs are climbing without stopping them. Actual spending limits differ by provider and service.
I’d test who notices unauthorized model usage, who can revoke the access and what happens to legitimate work when they do.

On November 2, Mandiant published details of attacks that caused more than $100,000 in fraudulent AI usage charges in a single day. In some of the incidents it investigated, cumulative charges approached $1 million before the attackers lost access.
The people running up those bills weren’t buying AI services with their own money. They were using cloud credentials and model access that belonged to someone else. Mandiant calls it LLMJacking, meaning someone hijacks access to large language models, often to consume or resell the service.
Mandiant doesn’t say which team at each victim organization discovered the abuse, or how much the companies ultimately paid after any disputes.
Here’s the question I’d put in front of the security leader: If somebody uses a stolen credential to run up our AI bill, who has the access and authority to shut it down?
How a stolen key becomes a very expensive service
AI models are usually billed by usage. An application sends a request to a model through an API, a connection that lets software use the model directly. The provider processes the request and records usage against the account tied to the credential. Depending on the service, that can mean paying for the text processed, the output generated or other compute resources.
The application may be completely legitimate. The problem starts when somebody else gets the credential.
In Mandiant’s investigations, the common entry points included stolen cloud login tokens, keys for service accounts used by software and model API keys accidentally exposed in public code repositories. Some attackers used those credentials to turn on AI services that the victim hadn’t been using. Others created new keys and accounts so they could keep making requests.
The attackers didn’t always use the models themselves. Mandiant describes services that collected stolen AI credentials and routed paying customers’ requests through them. Someone bought cheap model access from the criminal service. The model provider billed the organization whose credential was being used.
One of those operations sent more than 500,000 model API requests in less than eight hours, according to Mandiant. The researchers attributed nearly $1 million in token costs to a victim organization in that case. That’s the cost of the model usage reported in the investigation.
The model provider can see a valid key and bill the account attached to it, even if the person using the key stole it. A security team might have excellent endpoint protection on employees’ laptops and still have to answer why a cloud service account suddenly began purchasing large volumes of AI processing.
The first requests may be almost invisible
Mandiant also saw attackers testing stolen keys by limiting a model’s response to just one output token, a small unit of text. It reminded me of credit card testing. Someone steals a card number, runs a tiny charge to see whether it works, then tries to spend more. Here, the attacker is checking whether a stolen AI key works before using it more heavily.
A spending dashboard might barely move during those first checks. The requests can still show up in API logs, but a team watching only for a sudden jump in costs could miss the testing altogether.
Credit card companies don’t just watch for large purchases. They also look for unusual activity, like transactions from unfamiliar locations or sudden changes in spending habits.
We should be looking for similar warning signs with AI services. A model being used by an application that never called it before, a new API key, unexpected permission changes or requests coming from somewhere unfamiliar. Any one of those could be legitimate. But together? I’d want someone looking into it.
I covered a related problem in The Zombie Agent: How a Rebrand Killed Security: exposed model keys, resale and bills that could keep growing through auto-refill. Mandiant’s report adds evidence from actual investigations.
I’d want to know how quickly we can spot those early requests, identify the stolen credential and stop the spending before it gets out of hand.
An alert isn’t the same as a stop
The timing of the other announcement caught my attention.
On October 30, three days before Mandiant’s report, Google Cloud announced that spending caps were generally available. For eligible services, a cap can pause new usage when estimated costs exceed a set monthly amount.
That’s different from a budget email. An email tells someone a limit was crossed. Somebody still has to read it and act.
Google’s documentation limits each cap to one eligible service in one project. Eligible services currently include Gemini API, the Gemini Enterprise Agent Platform, Cloud Run and Cloud Run functions. Requests already running can finish and add charges. Storage and other ongoing resource costs also continue. Google’s announcement says requests using reserved model capacity, called Provisioned Throughput, keep running too.
Enforcement isn’t instantaneous, so charges can exceed the cap. At the start of the next monthly budget period, Google automatically lifts the block and the service can accept requests again. If the stolen credential is still valid, the attacker can resume using it.
OpenAI’s API documentation makes a similar distinction between an alert and a hard spending limit. With an enforced hard limit, API requests are rejected when tracked spending reaches the applicable monthly amount. There’s still a delay before enforcement fully takes effect, and setting the limit too low can interrupt legitimate production requests.
So I wouldn’t be satisfied with a screenshot showing a budget has been configured. I’d want to know which service it covers, whether it actually blocks requests and what happens when it blocks work the company needs.
There’s another question: who can change the cap? If someone with compromised cloud privileges can enable expensive services, create fresh credentials or alter the controls, the spending limit needs an owner and an audit trail too.
What I’d test before the next bill arrives
I’d give security, engineering and finance one exercise. No elaborate red-team campaign required.
Suppose a valid service-account credential starts calling an expensive AI model in a project that normally uses a cheaper one. The requests are coming from somewhere you don’t recognize. Spending begins climbing.
I’d ask the teams to show me the actual path from first signal to stopping the use:
Who sees it first? Is there a warning for a new model service, a new key, unexpected traffic or a sharp cost increase? Does it reach somebody who can investigate, rather than sit in a billing inbox until Monday?
What identifies the account? Can responders connect the model requests and charges to the project, credential and user or service account responsible? Can they distinguish legitimate application traffic from requests the organization didn’t authorize? Are the necessary logs enabled? Mandiant notes that the Data Access logs needed to record model requests on Google’s Gemini Enterprise Agent Platform are off by default.
Who can stop it? Name the person or on-call role authorized to revoke the key, disable an account, pause a service or enforce a provider-supported spending limit. The right action depends on which credential was stolen and what other access the attacker created.
What breaks when it stops? A shared key might also serve a customer-facing application. Have a replacement credential or clean project ready where practical. Decide who approves restoration after the team has removed the attacker’s access, including any additional accounts or keys the attacker created.
I’d also want the team to preserve key-creation events, model-request logs, records showing who enabled the service and billing data. Collect what’s needed without delaying the work to stop the abuse. Rotating the first stolen key won’t remove another account the attacker created earlier.
This is where finance belongs in the incident process. Finance can say what charges appear, which billing account they belong to and when the unusual usage started. Security can investigate the access. Engineering can keep the legitimate application working or explain what stopping it will interrupt.
The cloud provider may have a process to review disputed usage. Ask about it promptly, keep the supporting records and confirm what the invoice will actually require. The Mandiant figures alone don’t tell us whether any particular victim recovered the charges.
Mandiant’s cases don’t establish that every organization is facing a six-figure AI bill. They establish that criminals have found a way to turn stolen model access into charges quickly enough that the response time matters.
I’d rather test that handoff now than find out who owns it when finance asks why yesterday’s model usage cost more than the month’s budget.
Resources
Google Threat Intelligence Group and Mandiant, The Rise of LLMJacking, November 2, 2026. Original incident investigations, entry paths, stolen-key resale and reported usage charges.
Google Cloud, Spend Caps Now Generally Available, October 30, 2026. Product announcement describing service-level controls.
Google Cloud documentation, Manage Spend Cap Budgets. Eligible services, enforcement behavior, exclusions and limitations.
OpenAI API documentation, Spend Limits. Differences between spend alerts and enforced hard limits, including enforcement delay and application impact.

