You can pay for Zero Data Retention (ZDR), set the flag on every request, and still have the AWS key inside your prompt tried by a stranger within hours. That is one of the results of a canary study that Dragos published on November 19.
HD Moore, Chief Research Officer at Dragos, and his team sent nearly two million prompts to AI services between July and November 2026. Each prompt carried secrets that existed nowhere else. These included real AWS keys tied to empty accounts, passwords, unique URLs and private git repository references. Then they watched which secrets were used, and when. Dragos's write-up describes provider breaches, resellers that kept customer prompts, and providers that ignored privacy settings. Ars Technica covered it the next day.
I did not run any of these tests myself. This article is built from the Dragos post, the incident reports that followed it, and OpenRouter's documentation. The goal is practical: understand why a privacy flag did not protect these prompts, then map, narrow and test your own prompt path.
What a canary token is
A canary token is a fake secret that should never be used. You put it in one place only. If anyone uses it, you know that place was exposed. The name comes from the canaries miners once carried to detect bad air.
Dragos started in July with Thinkst Canarytokens, then built its own service. It created unique hostnames, URLs and credentials for every prompt and ran the systems behind them. Every hit could be tied back to the exact prompt, model, router and privacy setting that carried it.
To see who handled each request, the team also built something like traceroute (a tool that lists each hop a network packet takes) for AI inference. For example, requests carried an image URL, so every system that fetched it revealed its IP address.
What the study found
1. Attackers were inside three hosting providers
Dragos calls this its most serious finding. Attackers were stealing data from three different hosting providers. The earliest incident dated back to mid-July. None of the three knew about the breach until Dragos told them.
The largest breach involved a couple hundred of the planted AWS keys. Each key was sent once, to one provider, during a few short windows in late October. Every request sent in those windows was stolen. Some stolen keys came from requests the provider rejected before any model ran. Dragos reads this as the attacker copying requests "at the provider's front door".
In the other two breaches, some stolen requests were marked ZDR. Dragos put it plainly: "A privacy flag doesn't help when the attacker is already inside."
The attackers then followed a predictable path:
- They tested each key, sometimes within a few hours.
- They listed S3 buckets and searched Secrets Manager and Parameter Store for more credentials.
- They tried to enable hosted models in AWS Bedrock, created Bedrock API keys, and added their own IAM users to keep access.
In total, the bait keys were used for tens of thousands of AWS API calls. On November 1, one attacker added an AI-driven penetration testing tool called ARTEX. Dragos lists two of its user agents, artex-agent and artex-judge-r121, as worth adding to your detections.
2. Marketplace resellers kept the prompts
The second finding needed no exploit. Some routers are open marketplaces where the cheapest seller gets the request. A seller who wants customer data only has to list a popular model at the lowest price, turn on request logging and wait.
Dragos caught this by sending prompts for the same model through different sellers. When secrets sent through one seller were used and the others were not, the leak pointed to the seller. In one case, someone on a home broadband line opened two secret URLs about a day and a half later, then started guessing usernames at the login page.
The route tracing also found hops nobody had disclosed. One router was quietly forwarding some traffic to a marketplace. One seller added about a thousand hidden tokens to every prompt. Out of about two thousand traced routes, several hundred included a system Dragos could not identify.
3. Privacy settings were ignored
The third finding involved scraping, not stolen credentials. Dragos says a Chinese AI lab's systems fetched the secret URLs from more than half of the prompts sent to its models between July and October. That included roughly two-thirds of requests marked "no data collection" or ZDR. US hosting providers that resell this lab's models triggered the same scraper, so the prompts were flowing back to the lab.
Large US providers had issues too. One crawled a secret URL more than two months after a single call to its search endpoint.
The strangest case: 24 days after a ZDR-flagged prompt was sent to a US-based provider, its secret link was posted into a Feishu (Lark) company chat. Within two minutes, it was opened from three desktops and three phones in Beijing and Shanghai.
The disclosures that followed
Several companies have now published or sent their own notices.
OpenRouter and MiniMax. On November 21, a user posted an email from OpenRouter to Hacker News, saying it appeared authentic. According to the email, a researcher placed unique test URLs in prompts sent to MiniMax models from July to October. A third party opened those URLs 40 to 130 hours later, whether MiniMax served the request itself or another provider forwarded it there. AtlasCloud, Novita and StreamLake told OpenRouter they had forwarded requests for MiniMax models to MiniMax. OpenRouter removed the ZDR label from those endpoints. The email says none of the AWS test keys were used.
Phala. On November 10, Phala published a preliminary incident report. An attacker first chained a legacy internet-facing service with management interfaces that trusted loopback (local machine) access without checking the caller. Later, a new GPU server that was serving production traffic without full security hardening was taken over in a similar way. Phala tells users to treat DeepSeek V4 Flash 0731 requests that OpenRouter routed to Phala between October 21, 00:00 UTC and November 8, 05:35 UTC as exposed.
Together AI. On November 21, Together AI published a security notice. It had stored prompt samples for software testing in a private Hugging Face repository. The samples came from MiniMax M3, GLM-5.2 and Kimi K2.6 requests made in June and July. An AI coding agent committed a credential for that repository to a public GitHub repository. Someone used it to download the samples, then tested credentials found inside them. Five were Dragos canaries. Together has since made ZDR the default for new accounts.
These are three different causes: a forwarding chain, a compromised server, and a leaked credential for stored samples. In none of them did the customer's privacy setting decide the outcome.
Why the ZDR flag did not protect these prompts
TLS (Transport Layer Security, the encryption behind HTTPS) protects a prompt while it travels between two machines. But every router, reseller and provider decrypts it to do its work. A router reads the prompt to pick a model. The provider reads it to run the model. So every hop can see the full prompt and the full response.
A ZDR flag is a policy promise. It asks the next hop not to store your data. It cannot stop an attacker who is already inside that hop, a reseller who logs traffic anyway, or a provider that forwards your request to someone you never chose. Dragos says it directly: "a privacy flag only binds the first hop."
OpenRouter's own ZDR page also lists limits:
- ZDR enforcement applies to provider routing for inference. It does not cover plugins and tools you enable, such as web search.
- Safety Retention endpoints may keep prompts to detect abuse. When ZDR is enforced, self-serve accounts allow them by default unless you choose "ZDR only".
- In-memory prompt caching is not treated as retaining data.
The documentation is not wrong. A routing filter picks endpoints by their declared policy. It cannot check what happens behind an endpoint, and the MiniMax email shows that gap: providers forwarded requests on.
Step 1: Write down every hop
Start with a simple map for each feature that sends data to a model. Keep it in the repository, so changes go through review:
feature: support-ticket-summary data_in_prompt: [ticket text, customer email, order id] hops: - name: our backend sees_plaintext: yes logs_prompts: no - name: AI gateway or router sees_plaintext: yes privacy_setting: zdr=true, data_collection=deny - name: upstream provider chosen_by: us (pinned) | router (default pool) forwards_to_others: unknown -> ask in writing - name: tools and plugins examples: web search, fetch covered_by_zdr: check docs owner: platform team last_reviewed: 2026-11-22 The key fields are chosen_by and forwards_to_others. If the router picks from a default pool, you do not know your full path. If you cannot say who else gets the prompt, write unknown and treat it as a risk.
Then compare real traffic with the map. OpenRouter's Logs page shows the final provider for each generation, plus an Upstream Requests tab with every routing attempt, including retries and fallbacks. A provider that shows up there but not on your map needs a decision.
Step 2: Pin your providers instead of accepting the pool
Dragos advises picking upstream providers yourself instead of accepting the default pool, and staying away from reseller marketplaces. On OpenRouter, you do this with the provider object. These fields come from the provider routing docs:
-
order: the providers to try, in order. -
allow_fallbacks: defaults totrue. Set it tofalseso the router cannot move to other providers. -
onlyandignore: allow or skip specific providers. -
data_collection:"deny"skips providers that may store data. -
zdr:truelimits routing to ZDR endpoints.
This small Python client removes obvious secrets first, then sends a request that can only reach the provider you reviewed:
import os import re import requests MODEL = "your/model-id" # the model you reviewed PROVIDER = "provider-slug" # the one provider you reviewed SECRET_PATTERNS = [ (re.compile(r"AKIA[0-9A-Z]{16}"), "[AWS_KEY_ID]"), (re.compile(r"(?i)aws_secret_access_key\s*[=:]\s*\S+"), "aws_secret_access_key=[REDACTED]"), (re.compile(r"ghp_[A-Za-z0-9]{36}"), "[GITHUB_TOKEN]"), (re.compile(r"-----BEGIN [A-Z ]*PRIVATE KEY-----.*?" r"-----END [A-Z ]*PRIVATE KEY-----", re.S), "[PRIVATE_KEY]"), ] def scrub(text: str) -> tuple[str, int]: hits = 0 for pattern, label in SECRET_PATTERNS: text, n = pattern.subn(label, text) hits += n return text, hits def ask(prompt: str) -> dict: clean, hits = scrub(prompt) if hits: print(f"removed {hits} secret(s) before sending") resp = requests.post( "https://openrouter.ai/api/v1/responses", headers={"Authorization": f"Bearer {os.environ['OPENROUTER_API_KEY']}"}, json={ "model": MODEL, "input": clean, "provider": { "order": [PROVIDER], "allow_fallbacks": False, # fail instead of drifting to the pool "data_collection": "deny", "zdr": True, }, }, timeout=60, ) resp.raise_for_status() return resp.json() Test scrub before you trust it. Given a sample config with an AWS key ID, an AWS secret line, a GitHub token and a private key block, it should replace all four. The request follows the shape of the documented examples. Fill in the model and provider you actually reviewed.
Two limits remain. Pinning narrows the path, but it does not prove what the pinned provider does behind its endpoint. And with fallbacks off, a provider outage means a failed request. For sensitive features that is usually the right trade, as long as the feature returns a clear error instead of quietly moving to an unreviewed provider.
Step 3: Keep secrets out of prompts
The safest secret is the one the model never sees. Coding agents make this harder. Dragos notes that agents "will happily send whatever they can read, including credentials." An agent that can read .env files can paste those values into its next request.
Two layers help:
- Filter in your own code before the request leaves your network, like
scrubabove. You control it, and it runs before the first hop. - Use the router's filter as a second layer. OpenRouter's Sensitive Info Guardrail can redact or block known secret formats. Redacted text becomes a label such as
[SECRET:github-token], and a blocked request gets an HTTP 403. It scans prompts, not responses.
Dragos calls secret filtering useful but "not a panacea". A regex catches a key that looks like a key. It does not catch a customer list, a roadmap or a URL that works only because it is secret. Those need a decision about what each feature may send at all.
Step 4: Plant your own canary
Dragos's last tip is the easiest to start with: add a fake credential to the context your agents and pipelines already send, and treat any use of it as an incident.
A free AWS keys Canarytoken gives you a key pair that looks real. If anyone calls the AWS API with it, you get an alert. The docs warn that alerts pass through Amazon's logging first, which can add 2 to 30 minutes of delay.
Use one token per path. A token in your support-bot prompts and a different one in your coding-agent context tells you which path leaked. Write down where each token lives, and decide in advance what an alert means: rotate real keys on that path, remove that provider from routing, and ask it for an incident report.
A canary does not prevent a leak. It tells you one happened. Dragos says its July tokens were still firing in November.
Step 5: Check whether you are already affected
If you used AI routers between June and November 2026, check these first:
- DeepSeek V4 Flash 0731 via OpenRouter, served by Phala, between October 21 and November 8. Phala says to rotate any keys, tokens or passwords in those requests.
- MiniMax models via OpenRouter, July to October. Read any OpenRouter email about your account.
- Together AI serverless requests to MiniMax M3, GLM-5.2 or Kimi K2.6 in June and July. Together says it will contact affected customers.
On AWS, search CloudTrail for the artex-agent and artex-judge-r121 user agents. Then rotate any credential that was ever pasted into a prompt, whether or not you can prove it leaked.
Choosing how much exposure you accept
Dragos's recommendations line up as a ladder, from fewest to most parties reading your prompts:
- Self-hosting is the only option where no one else reads them. Dragos lists prices from $6,950 for an NVIDIA DGX Spark to $570,000 or more for an eight-GPU B300 server. For most teams, it fits only highly sensitive work.
- Going directly to a first-tier provider means one company, one contract and one privacy policy. It can still leak through a breach or a data-sharing deal, but it is the smallest exposure you can buy.
- Routers keep one API and one bill, if you pick the upstream providers and check the logs.
- Open reseller marketplaces are the ones Dragos says to avoid, because some of that capacity comes from stolen keys.
Most teams will mix these. A code-review agent that reads private repositories might go direct to a first-tier provider, while a public FAQ bot stays on a router.
The short version
Dragos frames it this way: where your prompts go is a decision, and if you do not make it, the lowest price will make it for you. Set the ZDR flag, but treat it as a request to the next hop, not a wall around your data. Map the hops, pin the providers, keep secrets out, and put a canary in every path you care about.
Which AI features in your stack send prompts through a router today, and could you name every company that sees them?
Sources
[1] Dragos: Three breaches, endless leaks
[2] Ars Technica: Researcher plants 2m canaries into the AI supply chain
[3] Hacker News: OpenRouter prompts to Minimax may have been read
[4] Phala November Preliminary Incident Report
[5] Together AI: Prompt leakage for requests in June and July of 2026
[6] OpenRouter docs: Zero Data Retention
[7] OpenRouter docs: Provider Routing