On 12 November 2026 Railway published a short bulletin with a promise most platforms never make after a breach: if an AI provider will not refund the tokens an attacker burned on your stolen key, Railway will pay for them. It is a good response to a bad event, and it has a date attached. It also leaves a question for anyone running production software: how many platforms are holding one of your AI provider keys right now?
We covered the first phase of this incident on 21 October, in Railway's environment variable breach: rotate every secret. This post is about what came after: the money, the policy, and what Railway's full incident report says the attacker was after.
What Railway has committed to
The bulletin, "Bulletin: Compensation for unauthorized AI usage" (published 12 November 2026), opens with the scale. In Railway's words, customers lost "at least ~$740K in AI tokens". That is a floor with a tilde on it, not a final total.
The policy itself is one sentence:
"Simply put, we will attempt to help you get compensated by the AI provider for unauthorized usage on a key exposed in this incident, and if the AI provider will not refund, we will pay for it."
The window it covers is narrow and specific:
"Unauthorized usage on any AI provider key stored in Railway and compromised from 13:50 UTC on 10/20 until the attacker was expelled on 10/21 at 9:25 UTC."
And the date, quoted whole because the second half matters as much as the first:
"Please submit claims by Weds 11/18/2026, though we will do our best to honor claims submitted after that."
If you were a Railway customer during that window and you saw AI spend you did not make, 18 November is the date to aim for. It is not described as a hard cutoff.
The bulletin also lists, provider by provider, how claims are handled. AWS Bedrock and Google Gemini refund under their fraud policies, OpenAI reviews cases one at a time, OpenRouter refunds under a goodwill agreement, and for Anthropic the table reads "Railway covers costs while we finalize the process". A final row covers everyone else: Railway pays unrefunded spend. Railway says it is paying "from Railway's own funds now" while it seeks insurance reimbursement in the background.
One detail worth knowing before you file: Railway's own two pages disagree on OpenRouter. The full incident report, published on 10 November, says OpenRouter decided to enforce its no-refund policy and that Railway will cover those costs. The bulletin, published on 12 November, lists OpenRouter as refunding under a goodwill agreement. The bulletin is the newer page. Read the current table on Railway's site, not a summary of it, including this one.
What the attacker was actually after
Railway's full incident report is long and unusually candid. Three points in it matter beyond Railway's own customers.
The target was AI keys, chosen by name. The report says database logs show the attacker "was specifically prioritizing AI provider keys in their queries by selecting rows where the variable name matched attacker-provided regular expressions", and was also targeting customers with large numbers of variables. Variable values were encrypted. Variable names were what made the valuable rows easy to find. OPENAI_API_KEY says exactly what it is.
AI keys were the priority, not the whole exposure. The report says "An additional query also matched cloud, database and payment service credentials", while adding that forensics did not indicate customer databases were accessed. And when Railway asked providers to revoke potentially compromised keys, the list included GitHub, GitLab and Stripe alongside the AI providers. If you had any secret in Railway during the window, the original advice to rotate it still stands.
Encryption at rest held, and still was not enough. Railway used envelope encryption: each environment's variables encrypted with its own key, that key encrypted by a root key held in a cloud provider's key management service. The attacker did not break that. After a chain of steps (a partial escape from build isolation, a build credential trusted more widely than intended, then a misconfigured cloud identity binding), they reached a machine that held a credential allowed to ask the key service to decrypt, because that machine legitimately needed it to start customer workloads. Encryption at rest protects you from someone who steals the database. It does not protect you from someone who gets hold of what the platform itself uses to decrypt.
It was not a one-off. The report's own assessment: "We assess this to be one of a series of attacks on platforms that hold AI keys." It names other developer tools that disclosed similar thefts in October, and says the stolen keys appear to have been resold for uses ranging from coding agents to training pipelines.
Railway puts the exposure at no more than 1.85% of workspaces, about 100,000, and is clear that this is an upper bound because its logs identify environments, not individual variables.
The question for everyone else: where do your keys live?
An AI provider key is unusually attractive to steal. It converts straight into money with no further exploit needed, the bill lands on you, and it can be used from anywhere. Most teams now hold several, and they are scattered:
- Your hosting platform's environment variables, often one copy per environment
- CI secrets, so tests and preview builds can call the model
- Preview and staging deployments that nobody remembers to clean up
- Developer laptops, in
.envfiles and shell profiles - Third-party tools you pasted a key into for a trial
Each of those is a place a breach somewhere else becomes a bill for you. Here is a short list that helps no matter where you host.
1. Make an inventory, per key
List every AI provider key you have and every place it is stored. If you cannot answer "which platforms hold this key?" in under a minute, that is the first thing to fix. After a breach somewhere else, the inventory is what tells you what to rotate.
2. One key per deployment, never one key everywhere
If production, staging, CI and your laptop all share one key, revoking it after a breach on any one of them takes all four down at once, and the provider's usage dashboard cannot tell you which copy leaked. Separate keys let you revoke surgically and read the usage per key.
3. Cap the spend at the provider, not just at the host
The cost in this incident came from usage, not from the breach itself. Check what your AI provider offers for spend limits, budgets or usage alerts per project or per key, and set them to something close to your real usage. A stolen key that hits a cap after a day of normal spend is an annoyance. One with no cap is how a breach becomes the kind of bill Railway is now paying.
4. Know how fast you can rotate
Rotation is two steps: issue a new key at the provider, then get it into every running app. Practise the second step before you need it. A key that takes a full redeploy to change is a key you will hesitate to rotate.
5. Watch usage, not just uptime
Without monitoring, the first sign of a stolen key is often the invoice. A daily look at per-key usage, or an alert on a sudden jump, catches a stolen key in hours instead of at month end.
Where a key lives on DeployBase
We would rather state this precisely than reassuringly. On DeployBase, the variables you set in the dashboard are written to your app's own .env file in your app's folder on the server. They are not copied into a central database table of every customer's variables, and DeployBase has no feature that stores an AI provider key on your behalf: no linked AI accounts and no bring-your-own-key integration. If an AI key is on our server, it is there because you put it in your app's environment.
That is a different shape from the database Railway's attacker searched by variable name. It is not immunity. The file is readable by your app, which needs it, and anyone who gained root on the server could read it, just as Railway's attacker read what its orchestration machine could decrypt. So every point above applies to keys you keep with us too: separate keys per deployment, a spend cap at the provider, and a rotation you have practised. Updating a variable in the dashboard rewrites the file and restarts the app, so the second half of a rotation takes one save.
The short version
- Railway customers with unauthorized AI spend between 13:50 UTC on 20 October and 09:25 UTC on 21 October: file a claim. Railway asks for claims by Wednesday 18 November and says it will do its best to honour claims submitted after that. The bulletin has the provider table and the process.
- Everyone else: the attacker wanted AI keys specifically and found them by variable name. Know where yours live, give each deployment its own, and cap the spend at the provider so that a breach on someone else's platform has a ceiling on your bill.
Sources, read 14 November 2026: Railway, "Bulletin: Compensation for unauthorized AI usage" (12 November 2026), and "Incident Report: October 21st Security Attack" (10 November 2026).