Key Thieves Read Your Bill, Not Your Data
Why a stolen AI inference credential is a metered liability, not a data breach: how billing anomalies surface theft first, which spend, rate, isolation, allowlist and revocation controls bound the loss, and what each leaves open.
Introduction
When an AI credential is stolen, the thing that walks out the door is not a database and not a password. It is a meter: a running, per-token liability that bills to your account for as long as the credential works. That changes where detection effort belongs. The first reliable signal is often the invoice, not the SIEM, and the controls that actually bound the loss are billing and identity controls, not the ones most runbooks reach for first.
The economics explain why the meter is worth stealing. SpyCloud reports underground shops selling AI subscriptions and API credit at 40% to 91% below list price, with wholesale services paying suppliers up to 35% of billings for uploaded keys. Sysdig's threat research team estimated in 2024 that a single abused account could run past $46,000 a day in charges, and later put the figure above $100,000 a day on frontier models. Those are vendor and researcher observations about specific campaigns and pricing catalogues, not a measured base rate for enterprises. Treat them as evidence that a market exists, not as a forecast of your exposure.
What follows is an argument about where to put detection and control effort, built from provider documentation and published incident reports. It runs in sequence: why this asset behaves differently from a password, why finance is positioned to see it first, which controls bound the loss and what each leaves open, what actually terminates a stolen session, how to test all of it before an incident, and what evidence to assemble afterwards.
The stolen asset is not the data — it is the meter
A stolen password is a credential the victim can rotate. A stolen row of data is already gone; the loss is fixed at the moment of exfiltration. A stolen inference credential is neither. It is a live entitlement that accrues cost per request, on your account, until someone stops it. The loss is a function of time and throughput, not of a single event.
SpyCloud's analysis of infostealer logs describes why this class of credential is harder to kill than a saved password. The families it tracks — WardenStealer and Aoki among them, with Gen Digital documenting the same collection behaviour across Remus and Amatera — lift OAuth access and refresh tokens, standing API keys, and session cookies from local installs of Claude Code, Codex, Cursor, GitHub Copilot, and the Claude and ChatGPT desktop apps. SpyCloud states that much of that access survives both a password reset and the multi-factor prompt that would stop a reused credential. It reports more than 130,000 WardenStealer infections since August 2026, and notes the technique is spreading through the commodity malware market rather than staying confined to two families.
Sysdig's LLMjacking reporting describes what happens next. In the verification phase, attackers did not run legitimate queries. They ran just enough to learn what the credentials could do and what quotas applied, and they queried logging settings where possible — behaviour consistent with maximising billable consumption while staying out of the logs. In later campaigns the team observed attackers calling the API to disable model invocation logging outright, and in the July 2024 Bedrock case it recorded more than 85,000 requests, 61,000 of them inside a three-hour window. That shape matters: the consumption is bursty, which is good for anomaly detection, and it is measured in tokens, which is what makes the bill the artifact of record.
The demand side completes the picture. Pillar Security's honeypot work documented a marketplace reselling access to more than 30 LLM providers at 40–60% discounts, with validation attempts following public scanning activity by two to eight hours. Anthropic's distillation disclosure describes proxy networks running "hydra cluster" architectures of fraudulent accounts, in one case more than 20,000 accounts simultaneously, mixing abusive traffic with unrelated customer requests to make detection harder. None of this establishes how common the problem is across enterprises. It establishes that a stolen key has a buyer, a resale price, and an operational model built around not being noticed.
Why finance sees it before security does
The claim that finance notices first is an inference, not a finding, and it should be labelled as one. The reasoning is straightforward: a stolen inference credential produces its primary observable effect in consumption data, and consumption data is already collected, aggregated, and reviewed on a schedule by people whose job is to explain variance.
The FinOps Foundation's anomaly management capability describes the machinery that inference already. It calls for standard procedures for detection and analysis so the team can react quickly, automated detection as typical practice, thresholds tied to cost allocation metadata, and integration into ticketing or process management systems. Its maturity model is unusually concrete about latency: crawl is monthly, walk is a two-to-three-day delay, and run is near real time, defined as under 12 hours. Its persona maturity axis moves from FinOps team only, to FinOps notifying resource owners, to automated alerts sent directly to resource owners. The working group's material adds the operational point that an identified anomaly could indicate an infrastructure issue, a software bug, or a possible cyber attack, and that systems looking beyond cost data have an advantage in early detection.
What the framework does not say is that finance will see an AI credential theft before security does. That conclusion depends on your specific cadence, and the counter-case is real. Billing data is aggregated and can lag; a provider that reports usage hourly still leaves you reconciling after the fact. A thief who stays under every configured threshold and spreads consumption across several keys may never trip a spend alert at all. The framework's own crawl tier — reacting more than a week after the anomaly occurs, post receipt of billing data — describes exactly the failure mode that makes the inference unreliable in a low-maturity shop.
So the honest version of the claim is conditional. If your inference spend is monitored at walk or run maturity, with per-project thresholds and alerts routed to the owning team, consumption data is a detection channel with a defined latency you can measure. If it is reviewed monthly by a spreadsheet, it is a post-mortem.
Which controls bound the loss, and what each one leaves open
Order the controls by what they actually stop. Each one bounds a different quantity, and each leaves a specific gap.
Hard spend limits bound dollars. OpenAI documents two controls with different effects: a spend alert sends a notification and traffic continues, while a hard spend limit makes affected requests return a 429 with organization_spend_limit_exceeded or project_spend_limit_exceeded. Anthropic documents a different response for a limit you set: requests return HTTP 400 with error type invalid_request_error, and the message states when access resumes. The discrepancy matters operationally — a runbook that greps for 429 will miss an Anthropic cap, and a monitoring rule keyed to one provider's error shape will not generalise. Both vendors state that enforcement is not instantaneous; OpenAI notes the platform can process a small amount of extra usage while the limit state propagates, so recorded spend can slightly exceed the configured amount. The gap: a cap bounds dollars, not access. The key still authenticates. Anything not billed through that limit — a different project, a different organisation, a provider the key also reaches — is untouched.
Rate limits bound throughput. Anthropic measures Messages API limits in requests per minute, input tokens per minute, and output tokens per minute per model class, with separate limits for some model tiers and fast modes. This constrains how fast a thief can extract value and makes the consumption curve more visible, but it does not stop the spend; it stretches it.
Workspace and project isolation bounds blast radius. Anthropic lets API keys be scoped to a single workspace, so the key can only access resources within it, and assigns members and resource limits per workspace; the automatically created Claude Code workspace isolates that tool's keys, usage, and rate limits from other workloads. OpenAI applies project hard limits only to traffic billed to that project. The gap: isolation converts a catastrophic loss into a bounded one. It does not prevent the bounded loss.
IP allowlisting rejects the request. OpenAI's key-safety guidance states that when allowlisting is enabled, only requests from configured addresses or ranges are allowed and all others are rejected even with a valid key. This is the strongest single control against a key used from outside your network. The gap is obvious and important: a key stolen from a developer's laptop and replayed from inside the allowed range — through a compromised host, a VPN, or a build runner — passes the check. SpyCloud's observation that these tokens are lifted from developer machines alongside source-control and cloud access makes the inside-the-perimeter case the likely one, not the edge case.
Rotation bounds the window, if the credential is the kind that rotation kills. Google Cloud's API key guidance recommends deleting unneeded keys and rotating periodically, and its key overview notes that exposing credentials can lead to unexpected charges. For a standing API key, rotation is effective once the old key is actually deleted. For an OAuth refresh token or a live session cookie, rotation of the underlying password does nothing, which is the subject of the next section.
What actually ends a stolen session token
The runbook step that ends a stolen session token is revocation, not a password reset. Microsoft's Entra documentation is the clearest published statement of the mechanics, and its revocation table is worth reading line by line.
A password change by the user revokes password-based cookies and password-based tokens. It leaves non-password-based cookies, non-password-based tokens, and confidential client tokens alive. A user performing self-service password reset produces the same result. An admin reset behaves differently depending on the console used: through the Azure portal it revokes only the password-based classes, while through the Entra admin center or the M365 admin center it also revokes non-password-based tokens and confidential client tokens — but non-password-based cookies survive all three. Only two rows clear every column: the user revoking their own refresh tokens, and an admin revoking all refresh tokens for a user. Single sign-out is a partial measure, revoking cookies but leaving tokens alive.
Default refresh token lifetimes in that documentation run to 90 days for most scenarios, 24 hours for single-page applications and email one-time passcode flows. A token that survives a password reset therefore has a long runway.
Two scope limits apply to this. First, this is Microsoft's documented behaviour for the Microsoft identity platform; it is not a universal rule, and the revocation semantics of each AI provider's OAuth implementation need to be confirmed against that provider's documentation rather than assumed. Second, the table describes refresh tokens, not every credential class. A standing API key is a different object with different revocation mechanics — deleting it from a console may not be the same as revoking it, and The Hacker News's reporting on the OpenCode Console breach makes the point sharply: a provider key is a bearer credential, deleting it from Console does not revoke it, and a Console budget cannot cap use that does not pass through the Console gateway.
The consequence for the reader is a runbook edit. "Reset the user's password" is not a containment step for a stolen AI session. The steps are: revoke all refresh tokens for the affected identity, invalidate active sessions, delete and reissue every standing API key the host could reach, and confirm each action against the provider's own documentation. SpyCloud's defender guidance lands in the same place — rotate exposed keys and tokens, revoke active sessions, and watch for anomalous API use.
Testing the controls before an incident
The following test design is a proposal, not a standard. Its purpose is to convert documented behaviour into measured behaviour in your own environment before you need it under pressure.
Create a dedicated test workspace and a scoped key. Use a workspace or project that carries no production traffic and set a hard spend limit low enough to reach quickly. Confirm the key is scoped to that workspace only.
Drive consumption past the limit. Confirm the exact error your provider returns — a
429with the spend-limit code on OpenAI, an HTTP 400invalid_request_erroron Anthropic — and confirm that requests actually fail rather than merely alerting. A spend alert that fires while traffic continues is a different control, and the test should record which one you have.Verify the alert fires before the cap. If you run both, set the alert threshold below the hard limit and confirm the notification arrives with enough lead time to act.
Attempt a request from a non-allowlisted address. With IP allowlisting enabled, confirm the request is rejected despite a valid key, and record the error.
Revoke and retest. Revoke the token or delete the key, confirm the old credential fails, and confirm a freshly issued credential works. For OAuth-based tools, test the refresh-token revocation path specifically, since that is the step a password reset does not perform.
Time every step. Record the interval between the triggering request and the enforcement you observed. Enforcement propagation is documented as non-instantaneous, and the measured latency is what tells you how much spend can slip past a cap.
What the test cannot prove is that a thief would be caught. It validates configured behaviour — that the cap enforces, the alert fires, the allowlist rejects, the revocation takes effect — not that an adversary operating inside your thresholds will trip any of them. Run it quarterly, and re-run it after any provider changes its error codes or limit semantics, because the error shapes differ enough between vendors that a monitoring rule built for one will silently miss the other.
The evidence packet: what finance, legal and the provider each need
The packet contents below are a recommendation assembled from what published incidents show was needed. They are not a standard, and no provider is obliged to accept them.
Railway's October 2026 disclosure is the model to work from. The company stated it was unable to refund customers for spend performed with compromised API keys, and directed affected customers to reach out to AI token providers directly, then submit a support request with timestamps, prompts, and additional proof of fraudulent spend so Railway could escalate on their behalf. It also asked upstream vendors to revoke keys, and provided all keys registered on the platform for some services regardless of whether they were known to be impacted. The lesson is that the escalation path runs through the platform to the provider, and it runs on evidence.
Build the packet around what that path requires:
Request identifiers and timestamps. Request IDs, start and end times in UTC, and the model and endpoint called. AWS Bedrock's model invocation logging, for example, records a
requestId,timestamp,operation,modelId,identity.arn, and input and output token counts per invocation — the fields an investigator needs to attribute consumption to a principal.Token and key identifiers. Which credential was used, when it was issued, and when it was revoked.
Billing line items. The charges attributable to the fraudulent window, separated from legitimate baseline.
The revocation record. Timestamps of each revocation action and the confirmation that the old credential failed afterwards.
Separate the audiences. Finance needs the chargeback and cost-allocation trail; the FinOps invoicing and chargeback capability frames this as validating the provider invoice against expected costs, discounts, tax, and credits, and ensuring budgets and forecasts are not distorted by incorrect charges. Legal needs the disclosure and notification record — what was known, when, and who was told. The provider needs the escalation evidence: request IDs, timestamps, prompts where available, and proof the spend was fraudulent.
One caution from Railway's own report: because keys were envelope-encrypted, the database query alone could not identify which specific customer keys were affected. Attribution took reading the attacker's payload logs to see which key names were being searched for. Assume your own attribution will be partial, and build the packet from what you can prove rather than what you suspect.
The strongest counterargument
The strongest case against this argument is practical. Hard spend limits interrupt production traffic — OpenAI says so directly — so many teams run alerts only, and an alert does not stop a thief. Billing data lags and aggregates, so the invoice is a trailing indicator. And the market may be thinning: SpyCloud notes that providers detect and revoke exposed keys faster than they did a year ago, and that abnormal consumption is easier to flag than it was. If that trend continues, the window in which a stolen key is worth stealing narrows, and the case for rebuilding detection around billing weakens with it.
The response is about placement, not replacement. The claim is not that billing telemetry substitutes for security monitoring. It is that when the loss is metered, the meter is a detection surface with properties security telemetry may not have: it is already collected, it is already reconciled by a named owner, and it is denominated in the thing being stolen. That argues for adding consumption anomaly detection to the security escalation path, not for removing anything from it.
The weakest point should be conceded plainly. A determined thief who stays under every threshold, spreads usage across multiple keys, and rotates credentials faster than you revoke them may be caught by neither the bill nor the SIEM. Against that adversary, the controls that matter are the ones that bound the loss rather than detect it: workspace isolation that caps the blast radius, allowlisting that rejects off-network use, and revocation procedures that actually terminate sessions. Detection is a race; containment is a floor.
Conclusion
The asset stolen in an AI credential breach is metered inference billed to your account, and the controls that bound it are billing and identity controls with specific, documented gaps.
The operational shift is to treat AI credentials as a billing-exposure category with its own controls, test order, and evidence trail — not as a password variant with a longer expiry. Two checks are worth running today. First, determine whether your inference spend limits are alerts or hard limits, and whether your monitoring keys on the right error code for each provider. Second, read your revocation runbook and find the line that says "reset password." If it does not say "revoke all refresh tokens and invalidate sessions" instead, it does not contain a stolen session.
Frequently asked questions
Does a spend cap stop the request or only alert? It depends on the control you configured and the provider. OpenAI distinguishes spend alerts, which notify and let traffic continue, from hard spend limits, which return a 429 with organization_spend_limit_exceeded or project_spend_limit_exceeded. Anthropic returns HTTP 400 with invalid_request_error when usage reaches a limit you set. Both document that enforcement is not instantaneous, so recorded spend can slightly exceed the cap. Check your provider's current documentation rather than assuming a shared error shape.
Does a password reset end a stolen token? Not on its own, per Microsoft's Entra revocation table. A user-initiated password change revokes password-based cookies and tokens but leaves non-password-based cookies, non-password-based tokens, and confidential client tokens alive. Only user-initiated refresh token revocation or an admin revoking all refresh tokens for the user clears every class. This is documented behaviour for the Microsoft identity platform; confirm the equivalent mechanics for each AI provider you use.
Is IP allowlisting sufficient? No. It rejects requests from addresses outside your configured ranges even with a valid key, which is valuable against external replay. It does not help when the key is used from inside the allowed range — a compromised developer machine, a build runner, or a VPN egress — which is the case SpyCloud's findings suggest is likely, given that these tokens are harvested from developer endpoints alongside source-control and cloud access.
Will the provider refund fraudulent spend? Railway stated it could not refund customers for spend performed with compromised API keys, and directed them to contact AI token providers directly and then submit timestamps, prompts, and proof of fraudulent spend so Railway could escalate. Whether any given provider refunds is a matter for that provider's terms and your negotiation; do not plan on recovery as a control.
find out more:
https://singdata.com/trending/reprocess-pb-scale-data-in-minutes-with-cloud-analytics/