Key Thieves Read Your Bill, Not Your Data
Why stolen API keys on metered AI services are a billing attack, how to separate a theft spike from a workload spike, which controls bound the loss, and a 60-minute response sequence.
Introduction
Most API-key incident response is built around a mental model that does not fit metered AI services. The assumption is that an attacker who steals a key wants what sits behind it: customer records, source code, internal documents. That model drives spending toward data access controls, exfiltration detection and database activity monitoring. It is not wrong, but on inference platforms it is aimed at the wrong loss.
A bearer credential is a spending authorization as much as an access grant. Whoever holds the key can invoke the model, and the account owner pays. Google Threat Intelligence Group (GTIG) and Mandiant documented this pattern under the name LLMjacking: across individual incidents they observed fraudulent charges exceeding $100,000 in a single day, with cumulative charges at some organizations reaching $1 million before access was revoked (GTIG). In a separate disclosure, METR reported that attackers stole an API key for inference on public models in March 2026 and consumed a substantial amount of credits (The Register).
This article treats the bill as a security control surface. It covers why stolen inference is attractive to attackers, how metered abuse differs from data theft in ways that matter for detection, how to separate a stolen-key spike from a legitimate workload spike, which controls bound the loss most efficiently, a 60-minute response sequence, and a testable checklist. It is operational guidance, not legal advice; the breach-notification section explains why that distinction matters here.
Why Steal the Key When the Data Is Right There?
A bearer token authorizes on possession alone. There is no second factor in the request itself, no proof that the caller is the party the key was issued to. When an attacker obtains one, they inherit the full authority attached to it: which models it can reach, which projects it can bill, and how much it can spend before anything stops it. They inherit none of the obligations that come with that authority, because those obligations attach to the account holder.
GTIG's investigations show the dominant initial access vector is exposed or stolen cloud identity tokens, including IAM credentials, service account keys, GitHub personal access tokens and active session tokens. In one case a threat actor harvested exposed corporate LLM API keys from public GitHub repositories. The credential is often not the primary target; it is what the attacker finds while enumerating repositories, configuration files and logs.
What the thief gains is different from what a data thief gains. GTIG describes an emerging division of labor between actors who establish access and operators running "LLM Mixers" — illicit routing gateways that proxy, aggregate and resell unauthorized LLM access to underground subscribers. The economics are straightforward: the seller's compute cost is zero, so resale can undercut market rates and still be profitable. GTIG cites the service jet-night.com, which offered an unlimited token plan for roughly $60 per month against a typical consumer-tier rate of $100 to $250, and which passed nearly $1 million in token costs to one victim organization. The same report attributes more than 500,000 LLM API calls in under eight hours to that actor.
Contrast that with data theft. Exfiltrated records must be stored, sold and carried, and they expose the buyer to legal risk. Stolen inference is consumed and gone. There is no artifact to trace, no buyer who has to explain possession. The attacker also gets anonymity for free, because the requests originate from infrastructure they control and terminate at a provider that sees a valid key.
The operational consequence is timing. GTIG notes that unlike the gradual resource consumption of cryptojacking, LLMjacking can generate large spikes in fraudulent cloud charges in a matter of hours. Mandiant's broader incident data puts global median dwell time at 14 days (M-Trends 2026), but that figure describes intrusions where attackers are establishing persistence and moving laterally. Metered abuse does not need that dwell time. The loss is realized in hours, which means the detection window is measured in billing cycles and alert latency, not quarters.
The Bill Is the Attack Surface
Cost telemetry is usually treated as a finance artifact. For metered AI services it is one of the few signals that fires when an attacker is succeeding, because the attacker's success and the account's spend are the same event.
The mechanics that make this cheap to execute and expensive to notice are documented in GTIG's report. Attackers validating stolen keys use automated credential validation sweeps built on minimal single-token requests (max_tokens=1). The purpose is explicit: confirm the key works while staying under endpoint detection and response and SIEM volume anomaly alerts. A validation sweep looks like almost nothing in request volume and almost nothing in spend, which is exactly why volume-based detection misses it.
Once a key is confirmed, the pattern changes. GTIG describes a "burn and rotate" strategy in which the actor continuously creates and deletes short-lived service accounts to bypass rate limits, while auditing the cloud provider's billing interface to monitor financial impact. The attacker is watching the meter too. Rate limits that reset per identity are not a constraint when identities are disposable.
A third mechanic is more specific to cloud AI and more damaging. In multiple incidents Mandiant investigated, LLM services were not enabled at the time of compromise. Abuse of access keys allowed the threat actor to modify and enable LLM API services such as Bedrock and the Gemini API. Once enabled, the APIs can generate massive bills in minutes or hours. GTIG's guidance is direct: treat any unauthorized enablement as a critical security event. "We do not use that service" is not a control if a key can switch it on.
The distinction that matters for control selection is between resource theft that touches data and resource theft that only touches the meter. The first is covered, at least in intent, by controls built for data protection: least privilege on data stores, exfiltration monitoring, database activity auditing. The second is largely invisible to them. A key scoped to invoke a model and nothing else can still cost six figures. If your detection portfolio assumes that unauthorized access implies data access, metered abuse sits in a blind spot by construction.
Telling a Stolen-Key Spike from a Workload Spike
Spend spikes happen for legitimate reasons: a product launch, a batch backfill, a customer onboarding, a retry storm after an upstream outage. Telling theft from growth requires dimensions that differ between the two, not a single threshold.
Request shape. Legitimate inference traffic is dominated by prompt and response pairs of meaningful length. Validation sweeps are short and repetitive. GTIG recommends monitoring model gateway and API access logs for anomalous low-volume requests such as max_tokens=1 or zero-temperature pings, and notes attackers use these micro-transactions for stealthy credential validation before launching large-scale abuse. A burst of near-zero-token calls from one identity is a stronger signal than a spend increase.
Identity churn. Legitimate growth usually runs on existing keys and service accounts, or on new ones created through a change-management process. Theft often produces new identities alongside the spike, because the attacker is rotating to escape rate limits. New service accounts appearing in the same window as a cost increase deserve a look at who created them and from where.
Model selection. Premium frontier models enabled on accounts or projects that never used them is a specific pattern. GTIG observed an actor subscribing victim accounts to pay-as-you-go agreements, selecting premium foundation models and launching high-volume inference streams. Model-level cost attribution makes this visible; a blended bill hides it.
Origin. Compare source networks and geographies against allowlists. GTIG's hardening guidance includes network allow listing, restricting outbound connections from cloud services to known IP addresses where feasible. The same allowlist is a detection asset: traffic from outside it is a finding, not a metric.
Named correlation. Ask whether the spike correlates with something the business can name — a deploy, a campaign, a customer event. If nobody can attach the increase to a known cause within the same business day, treat that as an open question rather than a rounding error.
The telemetry to answer these questions exists but is not always on. On AWS, monitor CloudTrail for API events from bedrock.amazonaws.com, including model discovery operations such as ListFoundationModels and ListInferenceProfiles, and access operations such as PutUseCaseForModelAccess and CreateFoundationModelAgreement. On Google Cloud, inference operations land in Data Access logs for aiplatform.googleapis.com, and those logs are disabled by default because of volume and ingestion cost; you must configure IAM audit policies to capture them. Model gateway logs are the third source, and often the most useful, because a gateway sees request shape and identity together.
One caveat applies to every threshold you set: rate-limit and spend-cap behavior varies by provider and tier. Anthropic's documentation, for example, states that once an organization reaches its tier's spend cap, API usage pauses until 00:00 UTC on the first day of the next month unless a higher limit is requested sooner, and requests return HTTP 429 in the meantime (rate limits). OpenAI documents separate organization and project spend limits that return distinct 429 error codes (error codes). Validate your thresholds against the provider and tier you actually run.
Which Control Buys the Most Safety per Hour of Effort?
The ranking below is practical judgment, not a measured comparison. It orders controls by loss prevented per hour of implementation and operating effort, and it makes the tradeoffs visible so you can adjust for your environment.
1. Hard spend caps. A cap bounds the loss regardless of detection latency, which is why it ranks first. If the cap is enforced at the billing layer, an attacker who defeats every other control still hits a ceiling. The limitations are real and should be planned for. Google Cloud spend cap budgets are limited to a monthly period and to first-party Google Cloud customers, and enforcement has latency because usage and cost reporting lag (billing docs). Anthropic's tier spend cap pauses usage until the next month rather than resuming on approval. Some services are ineligible for caps entirely. A cap is a ceiling, not a graceful degradation path, so size it with headroom for legitimate peaks.
2. Scoping and short key lifetimes. These reduce blast radius and shrink the window. GTIG recommends restricting and segmenting API keys by specific model endpoints, environments and usage limits, so that a compromised token for a basic utility model cannot invoke expensive frontier models. Expiration is now an API parameter in several platforms: OpenAI's service account creation endpoint accepts expires_in_seconds, bounded at 31,536,000 seconds, and notes that when an organization or project policy sets a maximum lifetime, the value must be provided and must not exceed it (API reference). Short lifetimes convert a stolen key from a durable asset into a perishable one.
3. Revocation speed. This is the control that determines whether a cap becomes a ceiling or a suggestion. A cap stops spend at the threshold; revocation stops it at the moment you notice. The gap between those two moments is the residual loss. Measure it before you need it.
4. Budget actions that enforce, not just notify. Budget alerts alone are notification. AWS Budgets can run an action when a budget exceeds a threshold, including applying an IAM policy or a service control policy, either automatically or after manual approval (budget actions). That converts a threshold into an enforced stop. The distinction between an alert that pages someone and an action that denies the next call is the difference between a control and a hope.
5. Detection content for the patterns above. Validation-sweep alerting, enablement alerting and logging-tamper alerting rank below the controls that bound loss, because they depend on someone acting. They still belong in the portfolio: they are how you learn that a cap is being approached rather than hit.
The First 60 Minutes
Order the response by loss rate, not by investigation completeness. Console paths differ by provider, so map each step to your own tooling before an incident.
1. Identify and disable the abused credential, and anything derived from it. Revoke the key itself and any keys or tokens created from it. GTIG documents actors using token-creation privileges to generate temporary credentials for high-privilege service accounts, and using cloud federation tokens to programmatically generate fresh access keys to circumvent MFA. Revoking the original key without enumerating its descendants leaves the attacker working.
2. Check whether LLM services were enabled that should not be. This is the step most likely to be skipped and most likely to explain the bill. Compare current service enablement against your known baseline. Any enablement you cannot attribute to a change record is a critical finding.
3. Apply an emergency deny policy or cap now. Do not wait for a support ticket to be triaged while the meter runs. A deny policy on model invocation for the affected principals, or an emergency cap, stops the loss immediately and can be relaxed later.
4. Preserve logs before rotating anything else. Rotation destroys evidence of what the key did. Export the relevant CloudTrail events, Data Access logs and gateway logs first. Pay particular attention to attempts to view, alter or disable logging: GTIG treats calls to PutModelInvocationLoggingConfiguration or DeleteModelInvocationLoggingConfiguration by non-IaC principals as high severity, and on Google Cloud flags operations such as GetIamPolicy used to check whether Data Access logs are enabled.
5. Enumerate persistence. GTIG's investigations found unauthorized IAM and service accounts, administrative policies attached to service roles, and SSH keys injected into compute instance configuration files. Walk IAM users, service accounts, role attachments, instance metadata and any interactive management sessions. One backdoor service account in the reporting was disguised as an internal billing optimization utility; names are not evidence of purpose.
6. Notify finance and leadership with the current burn rate. Give them the number, the trend and the time the credential was revoked. Finance needs it to accrue; leadership needs it to decide whether the event crosses a disclosure threshold, which is a question for counsel.
Does Metered Abuse Trigger Breach Notification?
This section explains the structure of the question. It does not answer it for your facts, and it is not legal advice.
U.S. state breach-notification statutes are generally keyed to unauthorized access or acquisition of electronic data containing personal information. Florida defines a breach of security as "unauthorized access of data in electronic form containing personal information" (Fla. Stat. § 501.171). California requires notice to a resident whose unencrypted personal information "was acquired, or reasonably believed to have been acquired, by an unauthorized person" (California Attorney General). The trigger in both formulations is data, not spend.
That structure suggests a pure billing event — stolen key, unauthorized inference, no access to personal information — may fall outside those triggers. It also suggests the same intrusion may not, if the credential could reach data stores and the logs show it did. GTIG's reporting describes exactly that combination: actors enumerating data stores for credentials, executing targeted database queries against warehouse metadata, and performing object storage operations associated with data theft, in some cases within the same intrusion that generated the bill.
The answer therefore depends on facts you must establish: what the credential could reach, what the logs show was actually accessed, whether any personal information was acquired, and which jurisdictions' statutes apply to the affected residents. State definitions of personal information differ, and so do timing requirements and regulator-notification thresholds; Foley's state chart and the Privacy Rights Clearinghouse 50-state survey are useful starting points for the variation. Take the specific facts to counsel, and read your own state's statute text rather than a summary.
Making Cost Attribution a Security Control
Cost attribution is usually built for finance: show each team its spend, allocate chargeback, find waste. For metered AI services the same capability answers security questions that nothing else answers well.
An unattributed bill cannot be triaged. If the monthly invoice shows a large increase with no breakdown, the first question in an incident — which credential caused this — has no answer. An unattributed spike cannot be scoped to a credential, so it cannot be scoped to an owner, a project or a revocation action. And a credential that cannot be scoped cannot be revoked surgically; the choice becomes revoking broadly and breaking legitimate workloads, or revoking nothing and waiting.
Per-key, per-workspace and per-project attribution changes all three. It makes the spike attributable, which makes it triageable. It makes the credential identifiable, which makes revocation a targeted action. It also makes the detection dimensions in the previous section measurable: model selection by project, request shape by key, identity churn by workspace.
This is a reasonable criterion to apply when evaluating a data platform, alongside the usual performance and cost questions. Ask whether cost can be attributed to a key, workspace or project for the services you actually run; whether that attribution is available at the granularity your incident response would need; and whether a spike can be traced to a single credential without a manual reconciliation exercise. Singdata positions cost attribution and unified data management as part of its lakehouse platform; the useful test is whether the attribution granularity matches your revocation granularity, whichever platform you run.
Acceptance Checklist for This Quarter
Each item below has a pass condition you can verify. A policy statement is not a pass.
Control | Pass condition | Evidence |
|---|---|---|
Hard spend cap on every metered AI service | A cap exists on each service and has been tested by exceeding it in a non-production account | Screenshot of the cap configuration and the error or pause behavior observed at threshold |
Key lifetime and ownership | Every key has a defined maximum lifetime and a named owner | Inventory export showing expiration and owner for 100% of active keys |
Validation-sweep alerting | An alert fires on a synthetic | Alert record from the test, with timestamp and the rule that fired |
Enforced budget action | A budget action applies a deny policy or SCP automatically at threshold | Budget action configuration and a test showing the deny took effect |
Revocation speed | A tabletop revocation of a production key completes within your stated target | Timed tabletop record with the steps and elapsed time |
Enablement alerting | Any LLM service enablement not tied to a change record pages someone | Alert configuration and a test enablement that triggered it |
Logging-tamper alerting | Calls that alter or disable model invocation logging by non-IaC principals alert at high severity | Rule definition and a test call that fired it |
Cost attribution | Cost resolves to a key or workspace for the top services by spend | Report showing per-key or per-workspace breakdown for the highest-cost services |
Run the cap test and the revocation tabletop first. They are the two items most likely to reveal that a control exists on paper and not in practice.
FAQ
Won't a hard cap break legitimate workloads? It can, which is why caps need headroom sized from observed peaks rather than from average spend. Set the cap above your highest legitimate daily or monthly peak with margin, and pair it with alerting well below the cap so you learn about growth before you hit the ceiling. A cap that never triggers is not a control; a cap that triggers during a launch is an outage.
What if the provider's cap is monthly-only? Use it anyway, and add the controls that operate on shorter timescales: short key lifetimes, deny policies triggered by budget actions, and revocation speed. A monthly cap bounds the worst case; the other controls reduce the loss within the month.
Is least privilege sufficient on its own? No. Least privilege is necessary and it does not bound spend. A key scoped to invoke one model and nothing else is correctly least-privileged and can still generate a six-figure bill. Least privilege limits what the key can reach; caps and lifetimes limit what it can cost.
A colleague says the data was never at risk, so the incident is minor. The bill is the loss. GTIG's observed incidents reached $100,000 in a day and $1 million cumulatively, and the intrusion that generated the bill may also have touched data stores. Treat the event as a security incident with a financial dimension, not a finance anomaly with a security footnote.
What if the abused key belongs to a third party? You cannot revoke what you do not control, so the sequence changes: notify the key owner immediately with the evidence you have, disable your own use of the credential, and check whether the same integration path exposes other credentials. GTIG notes that Jet Night's advertised outages were likely caused by victims revoking stolen keys, which is a reminder that revocation by the owner is the effective stop.
Does this trigger breach notification? That depends on what the credential could reach and what the logs show was accessed, and on the applicable statutes. Take the facts to counsel; the previous section explains why the answer is fact-specific.
Conclusion
The dominant model of API-key theft assumes the attacker wants the data behind the key. On metered AI services, the attacker often wants the meter. A bearer credential is a spending authorization, the loss is realized in hours, and the controls built for data theft do not see it.
The shift this requires is organizational as much as technical. Unauthorized service enablement and spending spikes should be treated as critical security events, not finance anomalies routed to a budget owner. Cost telemetry should be a detection source with an owner in security. Caps, key lifetimes and revocation speed should be tested, not assumed.
The single action to take this week: put a hard spend cap on every metered AI service you run, test it by exceeding it in a non-production account, and record how the service behaves at the threshold. That one test tells you whether your ceiling is real, and it takes less time than reading the first invoice after an incident.
find out more
singdata.com/trending/forecast-accuracy-hierarchical-models
singdata.com/trending/sql-accuracy-vs-analytics-accuracy
singdata.com/trending/claude-dashboards-enterprise-analytics-governed-context