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.
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.
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:
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.
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.
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.
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.
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:
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.
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.
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 to true. Set it to false so the router cannot move to other providers.only and ignore: allow or skip specific providers. data_collection: "deny" skips providers that may store data.zdr: 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.
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:
scrub above. You control it, and it runs before the first hop.[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.
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.
If you used AI routers between June and November 2026, check these first:
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.
Dragos's recommendations line up as a ladder, from fewest to most parties reading your prompts:
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.
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?
[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