LLMjacking is the theft of AI access: someone steals your OpenAI, Anthropic, Gemini or Bedrock credentials, or the cloud identity behind them, and runs their traffic on your bill. On 10 November 2026 Railway published its full incident report on an October breach in which, in its words, the attacker was "specifically targeting AI provider credentials", and it estimates unauthorized spend on the stolen keys at about $740,000. Railway is not alone: Wiz counts at least nine AI developer platforms that disclosed incidents in October, and Google's threat intelligence team says LLMjacking charges have passed $100,000 in a single day and reached $1 million at some organisations before access was cut. If your product calls a model API, the fix this week is simple and boring: rotate any key that lived on an affected platform, put a hard spend limit on every provider account, and stop treating an AI key like a low-value config string.
Here is the line I want founders to remember: an AI API key is a company credit card with no PIN, and attackers now have a resale market for it.
Who should care
- Anyone who deployed on Railway before 21 October 2026 and stored AI provider keys (or other secrets) as variables there. Railway recommends that all customers who signed up before 21 October rotate their keys.
- Anyone on the other platforms Wiz lists: Fireworks AI, Andromeda, Zeabur, Lightning AI, OpenCode, Warp, CommandCode and Northflank in October, with later additions including Brev, Trigger.dev, Chainstack, kernel.sh, Blacksmith, Tensorlake and NEAR AI. Check each vendor's own notice; the details differ a lot.
- Every AI startup with keys in more than one place. If your OpenAI or Anthropic key sits in a PaaS dashboard, a CI secret, a teammate's
.envand an agent config, you have four places to lose it. - Teams on Google Cloud or AWS whose service account keys, IAM users or GitHub tokens could be used to switch on Vertex AI, the Gemini API or Bedrock in a project you are not watching.
What actually happened
Railway: a build escape that ended at the key vault
Railway's incident report (published 10 November, superseding its 22 October preliminary report) lays out a long chain. Attacker accounts first appeared on 18 October. On 20 October the attacker exploited a previously unknown bug to partially escape filesystem isolation on a multi-tenant build VM, took a build credential, and used it against internal systems that trusted it. Early on 21 October they abused an erroneous OIDC binding to get short-lived cloud credentials, reached an orchestration machine that held a decryption credential, queried encrypted variables whose names matched AI providers, and decrypted some of them through the cloud KMS. Railway says the attacker was fully evicted at about 09:25 UTC on 21 October, and that it notified AI vendors at the same time.
The numbers Railway gives:
- Scope: at most 1.85% of workspaces, about 100,000, which Railway calls an upper bound because its logs identify environments, not individual variables.
- Linked tokens: 1,852 users had linked-account tokens (bring-your-own agent keys and GitHub OAuth tokens) decrypted; all were reset, and Railway found no logins to Railway accounts with stolen credentials.
- Databases: forensics did not indicate customer databases were accessed.
- Spend: "Unauthorized spend on the stolen keys was estimated to reach ~$740,000." Railway does not explain how it estimated this, as The Hacker News also points out.
Railway says it believes the attacker wanted AI credentials to sell for use in distillation, but that it has "not established" whether the attacker ran the resale services or supplied keys to others. Refunds depend on the provider: Railway reports that AWS (Bedrock) and Google (Gemini) initiated fraud refunds, OpenAI and SpaceXSI review cases individually, it is in discussions with Anthropic and covering those costs meanwhile, and it is covering OpenRouter costs because OpenRouter does not refund. One detail matters a lot: filing a charge report with Railway does not revoke anything. You still have to rotate the key with the provider that issued it.
Black October: nine platforms in one month
Wiz's "Black October" post (30 October, Benjamin Read and Rami McCarthy, updated into November) frames Railway as one of a run of attacks on AI developer platforms that led to "LLMJacking at scale". The causes differ: credential access at Fireworks, Zeabur and Lightning AI, a third-party dependency at Warp, a legacy system at OpenCode, and distillation attempts cited by OpenCode and CommandCode. Wiz also traced two stolen enterprise keys being resold: one ran about 800,000 Bedrock calls in roughly 30 hours, the other about 1.7 million calls in roughly 13 hours, together likely over $100,000 at list price. Wiz says it could not definitively link those resellers to the platform breaches.
Google: UNC6993 and the "LLM mixers"
Google Threat Intelligence published its LLMjacking research in early November (covered by The Hacker News on 3 November and GBHackers on 4 November; Google's own page would not load for me, so the details below come through those two outlets). The main points:
- A cluster Google tracks as UNC6993 got into a cloud environment through a misconfigured service account key, created additional API keys, enabled managed AI services and ran up more than $100,000 in charges.
- The most common way in was exposed or stolen cloud identity material: IAM credentials, service account keys, GitHub personal access tokens and live session tokens. One lure was a fake "application portal" that got users to paste raw JSON containing an active access token, which sidesteps passwords and MFA.
- Google describes LLM mixers: gateways that pool stolen access and resell it. The Hacker News names one, Jet Night, selling an "unlimited" plan for about $60 a month. GBHackers adds that one actor made more than 500,000 calls in under eight hours to feed it; that figure appears only in GBHackers' write-up.
- Charges can spike within hours, with some organisations reaching $1 million cumulatively before access was revoked.
The pattern is the same everywhere: AI access is now a commodity with buyers, so every key is worth stealing.
Why this keeps working
Three things make AI keys unusually attractive:
- They pay out instantly. A stolen database needs a buyer and a story. A stolen model key can be resold the same hour as tokens, and the victim pays.
- They sit in the least protected places. Keys go into PaaS variables, CI secrets and local config files because that is the easy way to ship. The Railway chain shows that "encrypted at rest" helps only until someone reaches the machine that holds the decrypt credential.
- Bills are watched monthly; attacks run hourly. Wiz's 1.7 million calls in 13 hours would be finished long before most founders open the billing page.
If you have read my posts on the Claude Code settings.local.json leak and the wfx-loot GitHub Actions attack, this will look familiar: secrets leak from wherever developer convenience puts them. What changed in 2026 is that AI keys became the secret attackers want most.
The AI key checklist to run this week
1. Make a list of every AI credential you have
For each provider (OpenAI, Anthropic, Google, AWS Bedrock, Azure, OpenRouter, Mistral, anything else), write down every key or identity that can call it and every place it lives: hosting platform variables, CI secrets, secrets manager, .env files, agent and editor configs, notebooks. Delete the ones nobody can explain.
2. Rotate anything that lived on an affected platform
If a key was stored on Railway before 21 October, or on any platform in Wiz's list during its incident window, treat it as stolen. Create a new key at the provider, deploy it, then revoke the old one at the provider. Do the same for other secrets stored alongside it (database URLs, payment keys, GitHub tokens), because Railway notes that one attacker query also matched cloud, database and payment credentials. Then check your provider usage dashboards back to mid-October for traffic you don't recognise, and if you find any, open a fraud case with that provider straight away.
3. Put a hard ceiling on every provider account
Find the spending controls in each provider console and set them to a number you could survive losing, per project or workspace, not just per organisation. Know which controls actually stop traffic and which only send email: a budget alert that fires at 2 a.m. does nothing on its own. Where a provider only alerts, wire that alert to something that pages a human, or to automation that disables the key. Google's own recommendations, as relayed by GBHackers, include API quotas, spending limits and budget alerts.
4. One key per service, per environment, with the least scope you can give it
Production, staging and each internal tool get separate keys, ideally in separate projects, so one leak has one blast radius and one obvious revocation. Restrict each key to the models and endpoints it needs where the provider allows it. A key used by a summarisation feature has no reason to reach your most expensive model.
5. Keep provider keys on your servers, behind your own gateway
Model keys should never ship to a browser, a mobile app or a build artifact. Route calls through your backend (or a gateway you control), load the key at runtime from a secrets manager, and add your own per-user rate limits and per-hour spend counters there. If you run an open-source LLM gateway such as LiteLLM, patch it promptly: the reports cite a LiteLLM key-handling flaw, though they disagree on the CVE number, so check the project's advisories directly.
6. Prefer short-lived cloud identity to static keys
On AWS and Google Cloud you can often call Bedrock or Vertex AI with a role or workload identity instead of a long-lived key. Then lock down the identities themselves, since that is how UNC6993 got in. On Google Cloud, block new service account keys at the organisation level and check which projects have AI APIs switched on:
# Block creation of new service account keys across the org (needs org policy admin)
gcloud resource-manager org-policies enable-enforce \
iam.disableServiceAccountKeyCreation --organization=YOUR_ORG_ID
# For each project: are Vertex AI or the Gemini API enabled where you don't expect them?
for p in $(gcloud projects list --format="value(projectId)"); do
echo "== $p"
gcloud services list --enabled --project="$p" \
--format="value(config.name)" | grep -E "aiplatform|generativelanguage" || true
done
On AWS, look at Bedrock spend day by day since mid-October; a sudden step change is your signal:
aws ce get-cost-and-usage \
--time-period Start=2026-10-15,End=2026-11-16 \
--granularity DAILY --metrics UnblendedCost \
--filter '{"Dimensions":{"Key":"SERVICE","Values":["Amazon Bedrock"]}}'
Treat anyone switching on Bedrock, Vertex AI or the Gemini API in a project that never used them as a security event, which is also what Google recommends.
7. Scan your repos and history for keys
Keys committed months ago are still keys. Scan full history, not just the current branch, and only trust a scan once you have rotated what it finds:
# Full git history, every branch
gitleaks detect --source . --log-opts="--all"
# Only report secrets that still work
trufflehog git file://. --only-verified
8. Alert on the shapes of abuse
Hourly spend far above normal, requests at times your users are asleep, calls to models your product doesn't use, and bursts of tiny requests (GBHackers reports attackers validating stolen keys with one-token calls) are all worth an alert. A scheduled job that compares the last hour's usage to last week's and posts to Slack beats a monthly invoice.
9. Write the 15-minute runbook now
Who can revoke each provider key, where the new key goes, which services restart, how you contact each provider's fraud or billing team, and where you note timestamps for the refund claim. Railway's report shows refunds vary by provider, so having timestamps and request details ready matters.
What I'd do as a CTO
Today I would do steps 1 to 3 before anything else: list every AI key, rotate anything that touched an affected platform, and set hard per-project limits at every provider. That is an afternoon, and it caps the worst case.
This month I would move model calls behind one internal gateway with per-user limits and spend counters, split keys by environment, and get rid of static cloud keys wherever a role can replace them. I would also add AI spend to the weekly metrics the founders actually look at. Cost per request is a margin number for any AI product; after this month it is a security signal too.
And I would question the habit of storing high-value keys in a PaaS dashboard at all. Platforms can be breached, as October showed nine times over. A secrets manager you control, with access logs you can read, is not much more work. If you want a second pair of eyes on how your AI stack handles keys, cost and agents, that is the kind of thing I cover as a technical advisor or, for a deeper engagement, as a fractional CTO. My posts on AI agent security and self-hosting an LLM vs using an API go further into both sides, and the Expedia and Qubole vendor-access audit covers the cloud-trust side of the same problem.
FAQ
What is LLMjacking?
LLMjacking is using stolen credentials to run AI model traffic on someone else's account. Attackers steal model API keys or the cloud identities that can call model services, then use the access themselves or resell it, and the victim gets the bill.
What happened in the Railway security incident?
In October 2026 an attacker escaped isolation on a Railway build VM, moved through internal systems and decrypted some customer environment variables, apparently targeting AI provider keys. Railway's 10 November report says at most about 100,000 workspaces were in scope, estimates about $740,000 in unauthorized spend on stolen keys, and recommends that customers who signed up before 21 October rotate their keys.
Do I need to rotate my keys if I use Railway?
If you stored keys or other secrets on Railway before 21 October 2026, yes: Railway itself recommends it. Rotate them with the provider that issued each key, because filing a report with Railway does not revoke anything.
Will OpenAI, Anthropic or Google refund LLMjacking charges?
It depends on the provider. In Railway's case, AWS and Google started fraud refunds, OpenAI reviews cases individually, Anthropic was still in discussions, and OpenRouter does not refund. Contact the provider quickly and keep timestamps and usage details.
How do I stop someone running up my OpenAI or Anthropic bill?
Set hard spend limits per project or workspace, use separate keys per service and environment, keep keys on your servers behind your own rate limits, and alert on hourly spend instead of waiting for the monthly invoice.
How do attackers get AI API keys?
Mostly from places developers leave them: public repos, CI secrets, PaaS variables and local config files, plus stolen cloud credentials such as service account keys and GitHub tokens that let them create keys or enable AI services. In October 2026 they also went after the hosting platforms that store those keys.
If you want to talk through your own setup, book a 30-minute call and we'll go through where your keys live and what would happen if one leaked tonight.
Sources
- Incident Report: October Security Incident (Railway)
- Preliminary Report: October Security Incident (Railway)
- Black October for AI Developer Platforms (Wiz)
- LLMjacking: Monetizing Compromised Cloud Models (Google Threat Intelligence)
- Google Warns LLMjacking Attacks Are Costing Some Enterprises Up to $1 Million in Cloud Charges (The Hacker News)
- Railway Says Stolen Customer AI Keys Led to $740,000 in Estimated Unauthorized Usage Charges (The Hacker News)
- Google Warns of LLMJacking Attacks That Generate Over $100,000 in Cloud AI Bills Per Day (GBHackers)
Written By
Kunal Vohra
Technical Co-Founder & Fractional CTO
I've co-founded 6+ startups across India, the UAE, and the US, spanning AI, Web3, fintech, and cybersecurity. I write about the technical and strategic decisions that determine whether a startup thrives or stalls.
Comments
Loading comments…